One interface for Claude Code, Codex, Copilot, OpenCode, and Pi agents.
Note
Otto is a modified fork of Paseo (© 2025–present Mohamed Boudra), reworked toward an autonomous AI coding IDE. It remains licensed under AGPL-3.0. See NOTICE for full attribution and a summary of changes.
Note
This is a one-person project run in spare time, and I'm obsessed with it; so if you message me you will get a reply instantly. Open an issue, or provide feedback right in the app to my discord!
I'm Philippe. Otto isn't a startup and I'm not trying to sell you anything — it's the environment I want to work in, and the way I'm getting better at agentic coding. Most of Otto is written by the agents Otto runs, which is either the point or the joke, depending on the day.
The problem I keep hitting: agents can now do an enormous amount of work on their own, and it's genuinely hard to see what they did, what it cost, and where it went sideways. So the work here leans toward observability and accounting — real per-subagent token and cost numbers, a live visualizer of the orchestration graph, browser-verified previews so an agent proves a change instead of just claiming it — and toward pulling good open-source pieces into one setup that actually works end to end, instead of five tools that half-talk to each other.
That's the whole thesis: let AI do the autonomous work, but make the operation legible while it happens. If that matches how you work, I'd like the help — issues, comments, and PRs all welcome.
Run agents in parallel on your own machines. Ship from your phone or your desk.
- Self-hosted: Agents run on your machine with your full dev environment. Use your tools, your configs, and your skills.
- Multi-provider: Claude Code, Codex, Copilot, OpenCode, and Pi through the same interface. Pick the right model for each job.
- Voice control: Dictate tasks or talk through problems in voice mode. Hands-free when you need it.
- Cross-device: iOS, Android, desktop, web, and CLI. Start work at your desk, check in from your phone, script it from the terminal.
- Privacy-first: Otto doesn't have any telemetry, tracking, or forced log-ins.
Otto runs a local server called the daemon that manages your coding agents. Clients like the desktop app, mobile app, web app, and CLI connect to it.
You need at least one agent CLI installed and configured with your credentials:
Download it from otto-code.me/download or the GitHub releases page. Open the app and the daemon starts automatically. Nothing else to install.
To connect from your phone, scan the QR code shown in Settings.
Install the CLI and start Otto:
npm install -g @otto-code/cli
ottoThis shows a QR code in the terminal. Connect from any client. This path is useful for servers and remote machines.
For full setup and configuration, see:
Run the Otto daemon and self-hosted web UI in Docker:
docker run -d --name otto \
-p 6868:6868 \
-e OTTO_PASSWORD=change-me \
-v "$PWD/otto-home:/home/otto" \
-v "$PWD:/workspace" \
ghcr.io/draek2077/otto:latestOpen http://localhost:6868 after it starts. Extend the base image with the agent CLIs you use, then provide credentials through environment variables or the persistent /home/otto volume. See the Docker documentation for full setup details.
Everything you can do in the app, you can do from the terminal.
otto run --provider claude/opus-4.6 "implement user authentication"
otto run --provider codex/gpt-5.4 --worktree feature-x "implement feature X"
otto ls # list running agents
otto attach abc123 # stream live output
otto send abc123 "also add tests" # follow-up task
# run on a remote daemon
otto --host workstation.local:6868 run "run the full test suite"See the full CLI reference for more.
Skills teach your agent to use Otto to orchestrate other agents.
npx skills add Draek2077/otto-codeThen use them in any agent conversation:
/otto-handoff— hand off work between agents. I use this to plan with Claude and then handoff to Codex to implement./otto-loop— loop an agent against clear acceptance criteria (aka Ralph loops), optionally with a verifier./otto-advisor— spin up a single agent as an advisor for a second opinion, without delegating the work itself./otto-committee— form a committee of two contrasting agents to step back, do root cause analysis, and produce a plan.
Quick monorepo package map:
packages/server: Otto daemon (agent process orchestration, WebSocket API, MCP server)packages/app: Expo client (iOS, Android, web)packages/cli:ottoCLI for daemon and agent workflowspackages/desktop: Electron desktop apppackages/relay: Relay package for remote connectivitypackages/website: Marketing site and documentation (otto-code.me)
Common commands:
# run all local dev services
npm run dev
# run individual surfaces
npm run dev:server
npm run dev:app
npm run dev:desktop
npm run dev:website
# build the server stack
npm run build:server
# repo-wide checks
npm run typecheckFive trees, five audiences. This section is the entry point to all of them.
| Tree | Audience | What it is |
|---|---|---|
docs/ |
Anyone building Otto | The official software documentation. How Otto works — system design, subsystem behaviour, conventions, gotchas. This is the specification we build against |
projects/ |
Anyone planning Otto | Charters for work not yet done, plus the single open-work ledger — the one place that says what is done and what is not |
findings/ |
Anyone diagnosing Otto | Dated, reproducible investigation reports — what was measured, how, and what it ruled in or out. Evidence, not specification |
archdocs/ |
Architects | The system-level architecture record: AsciiDoc pages with Mermaid diagrams, one level above docs/. npm run archdocs:serve |
CLAUDE.md |
AI coding agents | Working rules and constraints for agents in this repo. Deliberately not a documentation index — that is docs/README.md |
The three writing trees differ by tense: docs/ is present (this is how it behaves),
projects/ is future (this is what we will build), findings/ is past (this is what we
measured). A dated measurement in docs/ reads as a permanent fact, which is why it has its own
tree.
User-facing product documentation is published at
otto-code.me/docs and authored in public-docs/. It documents what Otto
does; docs/ documents how it is built.
Start here — Product · Architecture · Glossary · Coding standards · Development
Chat, agents and orchestration — Chat lifecycle · Agent personalities · Agent teams · Subagent accounting · Orchestration node capabilities · Safe unattended runs · Suggested tasks · Timeline sync · Visualizer · Activity stats · Terminal activity
Workspaces, files and git — Workspace lifecycle · New project · Changes view · Git providers · Git file history
Editor and code intelligence — Text editor · Code intelligence (LSP) · Markdown rendering · File icons
Providers and integration — Providers · Custom providers · Preview · Service proxy
Client and UI — Design tokens · Unistyles · Hover · Floating panels · Mobile panels · Expo Router · Forms · UI icons · Text effects · Onboarding · i18n · Feature flags
Protocol, data and performance — RPC namespacing · Protocol validation · Data model · Token economy · Terminal performance
Testing — Testing · Mobile testing · Ad-hoc daemon testing · Browser capture harness
Build, release and operations — Release · Fork release guide · Upstream merges · Android · Desktop Linux · Docker
Reference — References and sources · OpenCode event baseline
CONTRIBUTING.md · SECURITY.md · CHANGELOG.md · LICENSE · NOTICE
- paseo-relay — self-hosted relay in Go (built for the upstream Paseo project)
- paseo-vscode — VS Code extension (built for the upstream Paseo project)
Otto is licensed under AGPL-3.0, the same license as the upstream project it is based on. See LICENSE and NOTICE.
Otto is mostly other people's good work, assembled. Two projects carry it, and I'd rather name them properly than bury them in a footer.
Otto is a modified fork of Paseo, created by Mohamed Boudra and contributors, © 2025–present. Paseo is licensed under AGPL-3.0; Otto continues under the same license as required by its copyleft terms.
Mo got the hard parts right before I ever showed up: agent process lifecycle, a clean WebSocket protocol, genuinely cross-platform clients, an end-to-end encrypted relay. That's why the work here can be features instead of plumbing. Otto keeps the full foundation intact with upstream history preserved. → Sponsor Mo
Otto's Visualizer — the live node-graph of agents, subagents, tool calls, and timeline that makes an autonomous run something you can watch instead of guess at — is the render layer of Agent Flow (Apache-2.0) by Simon Patole, vendored as a git subtree.
It's beautiful work, and it fit because Simon kept rendering separate from event collection
behind a small documented bridge protocol. That one decision let Otto drive the same graph
from its own provider-neutral event stream, so it lights up for Claude, Codex, OpenCode, or
a local model alike — not just the runtime the original ingests. Adapting it has been the
most enjoyable part of building Otto. Carried patches and the Apache-2.0 state-changes
notice live in vendor/agent-flow/OTTO-PATCHES.md; upstream PRs are preferred over carrying
them. Agent Flow's name and logos are its own and Otto never ships them as its branding —
the feature is called "Visualizer" for exactly that reason.
→ Star Agent Flow
The original copyright notice is preserved verbatim in LICENSE. A summary of what Otto changes relative to Paseo, along with full attribution, lives in NOTICE. Otto is an independent project and is not endorsed by or affiliated with the Paseo project, the Agent Flow project, or their authors. Otto takes no sponsorships of its own — support goes upstream.