A free, local-first terminal for building precise AI prompts with the Action → Role → Context → Response → Format protocol. The third tool in the OWL family, after OWL (agent) and knOOgle (search). You choose each step yourself. The context step surfaces up to 3 short hint chips (audience, constraint, goal) derived only from what you have typed — click to append. The 5th step selects one of ten JEV deterministic JSON formats. Final planning fans only the APIs routed to that format, runs a miniLM analysis over real-time NLP sources, and returns a 2-3 sentence explanation of what you want to enhance the JSON file. Everything runs in your browser: no account, no tracking, no server.
ACTION — the verb that tells the AI what to do. 86 choices, clustered into authoring, analysis, planning, teaching, media, operations, discovery.
ROLE — the perspective or expertise the AI should adopt. 155 choices, clustered into engineering, languages, design, art & media, science & health, business/law/policy, education, trades, humanities.
CONTEXT — the scenario, audience, constraints, and details. Must be specific (10+ chars).
RESPONSE — the deliverable. 155 choices, clustered into languages, code shapes, software, documents, visual/media, data, teaching.
FORMAT — the JEV deterministic JSON organization. Ten formats, each with its own API routing.
Action, Role, Response, and Format are pure user choices — the app never guesses them.
Only the Context step offers short hint chips: an **audience**, a **constraint**,
and a **goal**, each under 8 words. Clicking a chip appends it to your context.
Chips for the four core steps are grouped into clusters with headers and filter
as you type — pressing Enter still validates against the full allow-list.
At finalize the app **reads your selected action, role, and response against your context**
and attaches a short guidance string to each step. For code, frontend, and backend
responses it also runs a **secondary fanned search** (GitHub, npm, Stack Overflow,
Dev.to, Hacker News) and includes those results as **output suggestions**. Every
source in the JSON carries a one-line **use** instruction. A generated
**exact final statement** paragraph is embedded so the downstream LLM knows precisely
what to produce — image vs text vs code vs data — instead of a generic “make a JSON”.
Every ARCR prompt is emitted as **JSON** in the JEV format you selected.
The ten JEV formats each have their own API routing:
After step 5 the app asks **“would you like to expand? (y/n)”**.
**N** finishes and builds the JSON immediately. **Y** opens a numbered menu
(1 action · 2 role · 3 context · 4 response) so you can edit a step first, then
returns to the Y/N prompt. No export or clipboard buttons appear until finalize.
| Format | Routed APIs | Primary use |
|---|---|---|
| flat | Wikipedia, Datamuse | single key-value artifacts |
| graph | OpenAlex, Crossref, Wikipedia | nodes/edges knowledge |
| hierarchical | Wikipedia, Wikidata, Open Library | nested trees, docs, file trees |
| tabular | GitHub, npm, Stack Overflow | records, languages, benchmarks |
| semantic | arXiv, Europe PMC, OpenAlex | embedding clusters, themes |
| agentic | Hacker News, Dev.to, GitHub | actions, tools, guardrails |
| stream | Hacker News, Dev.to, GitHub, Crossref | timelines, logs, transcripts |
| spatial | Wikidata, Wikipedia, GitHub, npm | layouts, levels, scenes, maps |
| relational | Stack Overflow, GitHub, npm, Wikipedia | schemas, ER models |
| temporal | GitHub, arXiv, Crossref, Hacker News, npm | roadmaps, version history |
Response-to-format pairings are **recommendations** surfaced to the user,
never auto-selected. For example: a language like `rust` or `python`
pairs well with `tabular` or `hierarchical`; `video game`
with `agentic` or `tabular`; `schema` with
`relational` or `hierarchical`; `roadmap` with
`temporal`. The user still owns step 5.
The final JSON carries four enrichment layers beyond the raw A·R·C·R values:
Every source entry also carries a **use** instruction (e.g. “Reference implementation —
adapt patterns, not code verbatim.”) so the downstream LLM knows how much weight to give each link.
When RESPONSE is a language (`rust`, `python`, `c++`, …)
or one of the code-shape values (`raw code`, ```
a full file no truncated code or stubs
, `snippet`, `function`, …), the final JSON
explanation will state that the deliverable is produced without truncation or stubs.
To reinforce that in CONTEXT, include one of the constraint markers:
`no stubs`, `no truncation`, `no placeholders`,
`single file`, `production-ready`.
owl: arcr fans your context out across **keyless public APIs** — Wikipedia,
Wikidata, OpenAlex, arXiv, Europe PMC, Crossref, GitHub, Hacker News, Stack Overflow,
npm, Lobsters, Dev.to, Open Library, Datamuse, DuckDuckGo (opt-in) — scores each
result by keyword overlap, freshness, depth and source weight, and attaches the top
references to the JSON. **All API fanning is guard-railed to the final planning stage**
and routed per JEV format.
/help guide only — this app runs a straight ARCR flow
Type `arcr` to begin. Choose ACTION → ROLE → CONTEXT → RESPONSE → FORMAT.
Then “would you like to expand? (y/n)” — N finalizes, Y lets you edit a step first.
Everything stays in your browser. There is no account, no cookie, no analytics, no
telemetry. The only outbound traffic is the query text sent to the public APIs routed
to your chosen JEV format. **No OpenAI, Anthropic, or Google endpoints are ever
contacted.** Your prompts and saved history live in `localStorage` on
this device and are never uploaded.
owl: arcr is a free tool from
[webXOS](https://webxos.netlify.app).
If it saves you time, you can buy the developer a coffee:
[buymeacoffee.com/webxos ☕](https://buymeacoffee.com/webxos).
Donations are optional and never unlock anything extra — the tool is and stays free.