Tori

curl -fsSL https://gettori.app/install | sh

Tori is a macOS app for supervising the coding agents you already run. Every hunk an agent writes traces back to the turn, the reply and the tool call that wrote it, and every prompt is a checkpoint you can diff or revert on its own. Nothing leaves the machine without you: an agent's permission prompts stay yours to answer, and the autopilot stops and asks before it opens a pull request or sends anything else out. Around that sit a real terminal per session, an editor with LSP and debuggers, and a git client that stages, commits and reviews pull requests. Five agents ship with adapters, Claude and Codex among them, and any other CLI agent is a TOML file away, or a pack someone already wrote. No account, no telemetry.

Status: alpha. It is used every day by the person who builds it, it ships often, and things still move. macOS only, on Apple Silicon and Intel, with a companion Android app that shows a paired Mac's chats.

Why

Running one agent in one terminal is fine. Running four, across three repositories and a couple of worktrees, is a tab-management problem, and the part you actually care about (which one is waiting on you) is the part the terminal cannot tell you.

Tori watches each agent's own session transcripts and process state, so every row in the tree says working, needs you, or done, and a parent row rolls its children up. You look at one list and know where to go next.

What it does

Provenance. Every hunk in a diff, a checkpoint or a pull request built here says who wrote it: the prompt and session behind it, the reply the agent gave around the edit, and the exact tool call that made it. When a turn wrote the file in several calls and none can be singled out, it lists them. When a shell command wrote it, it shows the command. When nothing Tori recorded wrote a line, it says so and why, and never guesses. Ask why on a hunk and Tori forks the session that wrote it, puts the question to the fork with the hunk and the tool call attached, and shows the answer under the hunk; the original session never sees it. That works for Claude and for ACP agents that can fork a session. tori checkpoint diff --why prints the same thing for scripts.

Sessions. A tree of sessions grouped into spaces, with a git-branch graph and worktree support. Clicking a session focuses its terminal tab, or resumes it if it is not running. Turn-level checkpoints snapshot the repo per prompt, so you can diff or revert a single turn. A transcript viewer, a touched-file list, and a context-window meter come along for adapters that report one.

Editor and review. A CodeMirror editor with TypeScript/JavaScript LSP, diff gutters, and markdown/image preview. The Changes panel stages, unstages, commits, pushes, and opens a PR. You can send a hunk comment or an editor selection straight into a session, and search across the whole project.

Autopilot. Hand it a list of tickets and it runs each one in its own worktree with its own agent session, in the order their dependencies allow. It stops and asks before anything leaves the machine, such as opening a pull request, and a worker's permission prompts stay yours to answer.

Interface. Command palette (Cmd+K), quick open (Cmd+P), a shortcut sheet on Cmd+/. Menu-bar tray, OS notifications, and a dock badge for sessions that need you. Dark and light themes, and you can import a VS Code theme file.

Supported agents

Agent	Chat runs over	Measured
Claude (claude)	Claude's stream JSON, plus its hooks	Yes
Codex (codex)	ACP, through the codex-acp wrapper	Yes
OpenCode (opencode acp)	ACP	Yes
Copilot (copilot --acp)	ACP	Not yet
Pi (pi)	ACP, through the pi-acp bridge	Not yet

Tori drives the agent CLIs you have installed; it does not ship one. After first launch, Settings > Agents shows which ones it found, at what version, and what it can do with each, including what it cannot do with each, since the five bundled adapters do not have the same capabilities.

Measured means someone ran that agent at a pinned version and captured what it actually sends. The others were written from the vendor's documentation and are a starting point; an ACP adapter is mostly launch instructions, which is why shipping one unmeasured is reasonable. The pinned versions are in ADAPTERS.md.

Adding another agent does not require a fork. Drop a TOML file into ~/.config/tori/packs/agents/ describing how to launch it. For an agent that speaks the Agent Client Protocol that is the whole file - four lines and no Rust, because the protocol carries the models, the permission questions and the history itself. For one that does not, the TOML also says where its transcripts live and how to spot a live process. The schema is documented and stable at v2, and v1 files still load: see ADAPTERS.md.

An adapter that omits the optional [chat] table runs its agent as a PTY tab, and that is the universal fallback: any CLI you can launch in a terminal can be driven that way, with the session tree, checkpoints and the working/needs-you dot around it. What a TOML alone cannot add is a transport for a protocol Tori does not speak, or a parser for a transcript shaped unlike claude's; both need Rust.

Shell tabs run your own login shell with your rc files intact; what Tori sets in its environment, and how to keep a tmux auto-attach out of the tab, is in docs/TERMINAL.md.

Install

The line at the top picks the build for your Mac, checks its signature, puts it in Applications and opens it. With Homebrew, run brew install --cask gettori/tap/tori instead. Otherwise download the DMG for your Mac from the Releases page (Tori_<version>_aarch64.dmg on Apple Silicon, Tori_<version>_x64.dmg on Intel) and drag it into Applications. The app is signed and notarized, so it opens without a warning. However it got there, Tori updates itself from then on. docs/INSTALL.md covers the phone app, updating and uninstalling.

Requirements: macOS 13.4 or later, on Apple Silicon or Intel (one DMG each). Tori is developed and tested on macOS 15. At least one agent CLI installed. Node.js if you want the bundled TypeScript language server to run.

Privacy

Tori sends no telemetry. There is no analytics, no crash reporting, and no usage tracking of any kind. Its own network requests are these six. The forge calls carry what you send through them, such as a pull request you open or a review you submit; nothing about your code or your sessions goes out in any of the others:

• GitHub Releases, at most once a day, to see whether a newer version of Tori exists. Anonymous. It never downloads or installs anything.
• openrouter.ai/api/v1/models, at most once a day, for the published per-model context-window sizes the context meter reads. Anonymous, and cached to disk.
• SchemaStore's catalog (schemastore.org), at most once a day and only when the JSON or YAML language server starts, so it knows which schema validates which file. Anonymous, and cached to disk.
• Installs you accept: a language server, debugger or agent that Tori offers to install. A downloaded release is checked against the sha256 pinned for it; a package install runs npm or pip the way you would.
• GitHub or GitLab's API, only when you sign in to that forge and from then on, for pull requests, issues, checks and reviews. It carries your own token.
• api.anthropic.com/api/oauth/usage, only if you light a model's own weekly chip on a Claude account, for that window's quota. It carries that account's token, read from your login Keychain for the one request.

The first three fail silently. Use the app offline to stop all six.

Your agent's own traffic is its own. A chat tab runs the same claude on your machine that you would run in a terminal, under your own subscription, and that process talks to its vendor exactly as it always does. Tori starts it, reads its output and writes to its stdin; it adds no endpoint of its own, proxies nothing, and sees nothing the CLI would not already be sending. The same goes for MCP servers: Tori reads and writes Claude's own config files, and Claude, not Tori, connects to whatever they name. Git pushes and fetches go straight from the system git to your remote.

Everything else is a plain file on your machine: preferences, spaces, checkpoints, and adapter overrides under ~/.config/tori/, plus the cached model list under ~/Library/Caches/tori/. Your agents' own transcripts stay where the agents put them; Tori reads them and never modifies or uploads them.

Contributing

Issues are welcome: bug reports, feature requests and pack requests. Pull requests are off here for now, while one person maintains Tori and the design is still moving. Languages, debuggers, formatters, themes and agents are packs, and gettori/packs takes pull requests for them. The reasons, the build steps for a clean clone and how to write a pack are in CONTRIBUTING.md.

Security

Found a way for a folder, a transcript or a document to run code it should not? Report it privately, as SECURITY.md describes.

License

Apache-2.0. Third-party material is listed in NOTICE. The licence covers the code. The name Tori and its logo are not part of it: a fork is welcome, under a name and a mark of its own.

What that means if the project stops. One person maintains Tori and takes outside code only for the adapters, so it is fair to ask what you are relying on. The answer is the licence, which cannot be withdrawn for anything already published: every released version stays Apache-2.0 for good, and anyone may keep using it, build it from source, or fork it and carry on. The worst case is a fork, not a loss.

Nothing of yours is held inside Tori either. As the Privacy section says, your sessions are the agents' own transcripts and Tori's state is plain files under ~/.config/tori/, so without Tori you lose a window onto your work and none of the work.