Use
Threads
Run a job in the browser app, from the terminal or headless, and keep what the agent learned.
A thread is a conversation with the agent. You describe a job in plain words; the agent plans it, reads files, runs commands and records findings. Threads are saved, can be resumed and can be archived.
00 starts the browser app on this computer. No account is needed. It binds to 127.0.0.1:48123.
| Flag | Default | Effect |
|---|---|---|
--port <port> |
48123 |
Port to bind. 0 picks a free loopback port. |
--host <host> |
127.0.0.1 |
Loopback address to bind. |
--no-open |
Start without opening a browser. | |
--db-path <path> |
local store | SQLite database for findings and runs. |
--ready-json |
Print the bound URL as JSON, for scripts. |
Run 0 --help for the full list.
Run a thread
Section titled “Run a thread”- Press New thread.
- Pick a folder if the job involves code. The folder is always allowed.
- Choose a model with the model picker under the composer. Connect a provider first if the list is empty; see Models.
- Describe the job, for example “Review this repo for auth bypasses and verify anything you find”.
- Watch tool activity in the transcript. Findings land in Findings.
The sidebar holds New thread and your history, Findings, Skills, Memory, Computers, Extensions and your Sentinels. Press ? outside a text field for the keyboard shortcuts.
The composer can attach images or text files, set a thinking effort for models that support it, and takes slash commands. A message sent while the agent works is queued and goes out when the response ends; Send now interrupts instead, and Stop response stops. If a model connection drops, the thread reconnects and continues from its last completed tool result.
Slash commands
Section titled “Slash commands”Type / for a menu. Each entry mirrors a CLI command, and anything that changes or deletes asks first.
| Slash command | CLI |
|---|---|
/threads start, /threads list, /threads export |
0 threads send new, 0 threads list, 0 threads list <id> --export |
/findings list, /fix [finding-id] |
0 findings list, 0 threads send new |
/sentinels list, /sentinels create |
0 sentinels list, 0 sentinels set --create |
/computers list, /models list, /skills list, /memory list |
the same words after 0 |
/config get, /doctor |
0 config get, 0 config doctor |
Chat-only commands are /help, /status, /tools, /explain [topic], /feedback <message>, /shortcuts and /usage.
Limits and approvals
Section titled “Limits and approvals”A thread has one mode: the agent has shell access and runs commands as your user in the folder you chose. What limits it is the scope, its budget (cost ceiling and time cap), the optional sandbox and one global setting, Ask before running commands under Settings → Helpers (off by default). When it is on, each command or change is put to you first. See Configuration.
The agent also has a web_search tool (Parallel’s anonymous hosted search, with DuckDuckGo as a fallback; no key needed). Results are links and snippets, not a sign that a page was read in full. ZERO_FEATURE_WEB_SEARCH=0 turns it off by default. It can clone a public HTTPS repository to review it; cloning does not add the host to your scope.
AGENTS.md or CLAUDE.md files inside a target repository are never loaded, because whoever wrote the target controls that text. Your own instructions live under Settings → Instructions: a global ~/.0/AGENTS.md and one file per folder, each up to 32,000 characters.
Saved threads
Section titled “Saved threads”A saved thread opens at /chats/saved/<id> read-only, with its transcript and panels, and resumes when you send a message. Search with ⌘K; it matches message text and titles and skips tool payloads and private reasoning. Settings → Threads sets title instructions, idle archiving (off, 7, 14, 30 or 90 days) and the helper limits: concurrent helpers (1-128, default 32), nesting depth (1-16, default 8) and helpers per call (1-4096, default 1024).
Memory
Section titled “Memory”Memory is what 0 remembers across threads: short plain notes about a folder or about your team’s decisions, such as an accepted or rejected fix, a convention, how to run the tests, or something to avoid. A note is one or two sentences, either for one folder or for everywhere. Open Memory to list, search, add, edit and forget notes, filter by folder, export or import them, or turn Memory off for new threads.
At the start of each turn the model reads the notes for the folder and the global ones, newest first, up to a budget of about 2,000 tokens. When notes do not fit, the model is told “N notes not shown”, and 0 memory list and the Memory page say how many were left out and why. The notes are labelled as untrusted context: they never override system rules or your request, and the model checks them against the code. The model has one memory tool with three actions: remember, update (replace the text of a note by id) and forget. A repository cannot supply notes: nothing is read from the repository.
Who may write what depends on what the thread has read:
- You commit immediately. Typing “remember that …” in a thread,
0 memory addand the Add button on the Memory page all save the note at once. - 0, in a clean thread, commits a note it chose to keep. Once a thread has read untrusted content (web pages, the browser, HTTP responses, repository files, shell output, MCP or extension results, sub-agent output), a note 0 remembers goes to the Proposed inbox instead. Proposals are not shown to any thread and never reach the scan verifier until you accept them. In that state
updateandforgetare refused. - Review: the Memory page shows a Proposed section at the top (Accept, Edit then accept, Reject) and a dot on the Memory sidebar item. From the terminal use
0 memory proposed list,0 memory proposed accept <id>and0 memory proposed reject <id>. - Limits: 0 may save 5 notes per thread and 20 per day. A note close to an existing one is not duplicated; the tool returns the existing id so the model can update it.
- Secrets: a note that looks like a key, token, password, private key or other high-entropy secret is refused (“Not saved: looks like a secret”), whoever writes it. Zero-width, direction-changing and control characters are removed, and text that hides characters this way is refused.
- Verification: only
avoidnotes you wrote or accepted are shown to the verifier, as untrusted context. Notes 0 wrote on its own, proposals and imported notes are not.
Every note records where it came from: who wrote it (user, model or import), the thread, whether that thread had read untrusted content, and when. Notes are keyed by the repository, not the path: the normalised origin remote (for example github.com/acme/app), falling back to the real path, so worktrees (app-wt-*) and clones share notes. Notes saved under the older path-keyed folders are still read.
Notes are plain Markdown in the computer’s private state: ~/.0/memory/MEMORY.md for global notes and ~/.0/memory/<folder-hash>/MEMORY.md for each folder. Nothing is written into your repository. You can edit these files by hand or search them with grep. 0 records when a note was last shown at most once a day, and never ranks by it. ZERO_DISABLE_MEMORY=1 turns Memory off. Memory is not available inside an isolated workbench.
To share what a team decided, export it: 0 memory export --to AGENTS.md adds a “Notes from 0 memory” section (only notes you wrote or accepted, for the current folder) between two marker comments, prints the lines it added, and leaves the rest of the file alone. Review it with git diff and commit it like any other change. The export goes one way: 0 never imports notes from a repository file automatically.
From the terminal: 0 memory list, 0 memory add "<note>", 0 memory remove <id>, 0 memory clear --yes, 0 memory proposed list|accept|reject, 0 memory export -o <file> (JSON for 0), 0 memory export --to AGENTS.md and 0 memory import <file> (imported notes are never trusted by the scan verifier). The first time Memory opens after an update, 0 copies the older stores (source lessons, hunt memory, triage memories and lessons) into notes once, and records what it did in ~/.0/memory/import-report.json. The older files are left in place.
From the terminal
Section titled “From the terminal”0 threads does what the thread menu does, against the app started by 0:
id=$(0 threads send new "Map the login flow" --folder ~/code/app)0 threads list "$id" --set --effort high0 threads stop "$id" # --force if owned execution does not drain0 threads send "$id" --retry0 threads list "$id" --rename "Login flow"0 threads list "$id" --export --format md -o login-flow.md0 threads list "$id" --delete --yessend new creates the thread and runs one turn. --wait blocks until the turn ends, prints the reply with tokens and estimated cost, and exits 1 if the turn errored. --cost-ceiling <usd> stops the thread once its estimated spend reaches that amount. Every 0 threads command needs a running app; without one it prints No console running. Start one with: 0 --headless and exits non-zero.
Headless
Section titled “Headless”0 -p runs one prompt through the same app process and exits.
0 -p "Review the selected folder" --scope scope.yaml0 -p "Summarize the open findings" --format jsonprintf '%s' 'Summarize the selected findings' | 0 -p| Option | Effect |
|---|---|
--format <text|json|ndjson> |
Output format. Default text. |
-m, --model <id> |
Model to use. |
--approvals <ask|auto> |
ask puts each command to you first; headless runs cannot answer, so effectful tools are refused. Default auto, or your approvals setting. |
--target <url>, --scope <file> |
Target and scope for the run. |
--finding <id>, --finding-intent <intent> |
Focus on one saved finding: investigate, verify, draft_fix or impact. |
--resume <id>, --continue |
Continue a saved thread by id or prefix, or the most recent one (0 -r <id>, 0 -c). |
A task that needs a human decision cannot finish headless; open it in the browser. To continue a live thread, pass --chat <id> (the thread keeps its own model and scope, so --model, --target and --scope are rejected; pending decisions are reported, not approved).
On a server or in CI, start the app with 0 --headless --ready-json. It opens no browser and serves the API only. To drive a running app from scripts, 0 api calls its backend HTTP API with the normal authentication and approval checks. Keep the token in an environment variable, for example --engine-token-env ZERO_AGENT_TOKEN, never on the command line.
Commands, skills and automations
Section titled “Commands, skills and automations”- The eight CLI commands (
findings,threads,sentinels,skills,memory,models,computers,config) are fixed entry points built into 0. They are not skills. In a thread, the/commands are a shorter list that mirrors the CLI (/threads listis0 threads list); a few exist only in chat. - Skills are know-how a thread loads when a task needs it:
SKILL.mdfolders, which extensions can also supply. See Skills. - Automations are prompts. An automation is a saved prompt plus a trigger (
schedule,manualorgithub-pr; a webhook only speeds upgithub-pr). A Sentinel owns automations. See Sentinels. - Verifier gate: a skill can declare a check that the engine runs itself, so a thread cannot claim Verified without it. See Findings.
Limits
Section titled “Limits”- Local means tools run on the computer’s host. Your model endpoint can still be remote; where tools run and which model you use are separate choices.
- A provider connection does not authorize a target. Scope and tool isolation are separate.
- A source build serves the app from built assets. Rebuild after changing source.