OPEN SOURCE DEEP DIVE
Paseo: One Self-Hosted Cockpit for Claude Code, Codex, Copilot and More Coding Agents
Self-hosted multi-agent orchestration (20.9k stars): Claude Code, Codex, Copilot, OpenCode, Pi, Antigravity and Muse Code behind one interface on your own machines; a local daemon (WebSocket + 33 MCP tools) orchestrates them while Electron desktop, Expo iOS/Android, web and CLI clients connect; git-worktree parallel isolation, local-ONNX voice, an end-to-end encrypted relay for remote follow-up, plus a plugin registry, skills and Hub ecosystem. Apache-2.0.
One-liner: one cockpit for every coding agent you already pay for
Paseo calls itself an agentic development environment (ADE). It is not another coding agent; it is the layer that takes the agents you already installed and already pay for - Claude Code, Codex, Copilot, OpenCode, Pi, Antigravity, Muse Code - and puts them behind one interface to run, watch, steer and merge. It runs on your machine with your tools, configs and skills, and four clients (Electron desktop, native Expo iOS/Android, web, CLI) all connect to the same local daemon. The first line of the README is the whole stance: one interface for Claude Code, Codex, Copilot, OpenCode, Pi, Antigravity, and Muse Code agents.
Against peers like Orca and herdr, the difference is not "can it run agents in parallel". It is three bets: self-hosting (the daemon lives on your box, your code never leaves), provider abstraction (native adapters plus an ACP catalog that swallows dozens of agents through one protocol), and treating mobile and voice as first-class (the phone app is the full app, not a notification shell; speech runs on local ONNX models by default). Those three bets drive every architecture choice below.
The numbers: a one-year-old repo, twenty thousand stars, a million lines of TypeScript
| Metric | Reading (2026-10-15) |
|---|---|
| stars / forks / open issues | 20,907 / 2,479 / 1,276 |
| created / latest release | 2025-10-13 / v0.11.2 (2026-10-09) |
| language / license | TypeScript / Apache-2.0 (GitHub API reports NOASSERTION, see below) |
| monorepo scale | 12 npm workspaces, 4,554 TS/TSX files totalling ~1.1M lines, 1,714 of them test files |
| maintenance | single lead maintainer (Mohamed Boudra), funded by GitHub Sponsors and company sponsors |
Three readings deserve a pause. First, the repo was created in October 2025 and is exactly one year old; its star curve is among the steepest in the agent-tooling layer this year. Second, the license reads NOASSERTION in the GitHub API because the LICENSE file carries a third-party portions preamble, while package.json and the docs both say Apache-2.0 - automated compliance scanners will misreport it and a human has to read the file. Third, 1,276 open issues is the real operational surface of a single-maintainer project; the limitations section returns to this.
The architectural bet: everything orbits one local daemon
Paseo is client-server in the same sense Docker is. The daemon is a Node.js process listening on 127.0.0.1:6767 by default, with all state under $PASEO_HOME (~/.paseo). It owns agent process lifecycle, the real-time timeline stream, workspace and worktree registries, terminals, schedules, and an MCP server. Clients are deliberately thin: the Electron desktop app supervises its own daemon subprocess; the Expo app and the CLI connect over WebSocket; the TypeScript SDK (@getpaseo/client) turns the same capabilities into a programmable interface.
The direct consequence is that your code never leaves the machine: agent processes, files and terminals all live where the daemon lives, and clients only receive timeline events and send instructions. This is also why the mobile client can be the full app - the phone does not need to run agents, it only needs to reach the machine that does. The docs state it as a product promise: your code never leaves your machine.
Persistence is file-based JSON rather than a database. Every store lives under $PASEO_HOME, validated with Zod and written atomically (temp file then rename); there is no migration framework, forward compatibility comes from optional fields with defaults. data-model.md carries a hard self-check: a good store method should map cleanly to one SQL statement or one transaction. The author treats JSON as an implementation detail and the store surface as the contract a future database could satisfy - "no database" is not the selling point.
Provider abstraction: six native adapters plus a 36-entry ACP catalog
The README headline names seven agents, but the docs' native-support list has six: Claude Code, Codex, OpenCode, Pi, Antigravity, Muse Code. GitHub Copilot arrives through the ACP (Agent Client Protocol) catalog, with a dedicated copilot-acp-agent.ts adapter in the code. The gap is worth stating because it exposes the real strategy: deep integrations get native adapters (Claude via its SDK, Codex via the app-server protocol, OpenCode and Pi with their own adapters), and everything else is swallowed by the generic ACP protocol.
| Provider | Transport | Notes |
|---|---|---|
| Claude Code | native SDK adapter | MCP, streaming, deep reasoning |
| Codex | native app-server adapter | sandbox controls, optional network access |
| OpenCode / Pi | native adapters | multi-model support |
| Antigravity | bundled provider plugin driving the agy CLI | the only always-full-access provider |
| Muse Code | provider plugin, MSP over muse serve | Meta's terminal agent |
| Copilot / Cursor / Cline / Gemini CLI / goose and 31 more | ACP catalog, one-click install of the underlying CLI | Cursor, Kimi, Kiro, TRAE and Copilot get dedicated adapters for their quirks |
Two disciplines run through the provider layer. Auth always stays with the provider: Paseo stores no API keys, and the Usage panel added in 0.11 merely reads the logins each CLI already holds to display quota windows. And Antigravity is the only provider locked to full access - agy cannot prompt for permission when another app drives it, so Paseo launches it with --dangerously-skip-permissions and warns at the start of every session. It is an honest but sharp-edged decision, revisited under limitations.
Orchestration: worktrees as the isolation unit, MCP as the language between agents
The isolation unit for parallel agents is the git worktree, created under $PASEO_HOME/worktrees/ grouped by a hash of the source checkout path, one branch per worktree so agents never step on each other. paseo.json attaches setup hooks, scripts and long-running services with per-worktree ports, and teardown runs only after the last workspace referencing a worktree is archived. Choosing worktrees over containers or copies buys three things: no repository duplication, branch semantics for free, and a merge-back flow developers already know.
Agent-to-agent coordination runs through a transport-neutral tool catalog of which MCP is one adapter: the daemon registers 33 tools as an MCP server, covering agent lifecycle (create_agent, send_agent_prompt, get_agent_status, list_agents, cancel_agent, archive_agent, kill_agent, update_agent, get_agent_activity, set_agent_mode), workspaces (create_workspace, list_workspaces, rename_workspace, archive_workspace), scripts and terminals, schedules and heartbeats, and list_profiles. injectIntoAgents is off by default and must be enabled - "agents directing agents" in Paseo is not a prompt trick, it is a set of RPCs with permission boundaries.
Three designs sit on top to lower orchestration cost. Agent profiles save provider, model, thinking level and mode with "when to use" notes so an orchestrating agent can pick by specialty. Schedules start a fresh agent on a cron. Heartbeats re-prompt the same agent periodically. The skills directory (npx skills add getpaseo/paseo) ships three ready workflows: paseo-handoff plans with one agent and hands implementation to another, paseo-advisor spins up a single advisor without delegating the work, and paseo-committee forms two contrasting agents for root-cause analysis and a plan.
Mobile and voice: the full app in your pocket, speech local by default
The mobile client is a native Expo app for iOS and Android with routing, workspaces, timelines, terminals and diffs on the phone, connected to the same daemon as the desktop. "Start at the desk, follow up on the train" needs no sync layer because state already lives in the daemon; the phone is just another session. With five agents running at once the scarce resource is your attention, and being able to glance and interject from anywhere is what decides whether you walk back to the desk.
Voice is local-first. STT defaults to parakeet-tdt-0.6b-v2-int8 (English only); switching to the v3 model auto-detects 25 European languages. TTS defaults to kokoro-en-v0_19. Both run ONNX on CPU, with models downloaded on demand into $PASEO_HOME/models/local-speech at daemon startup. The reasoning half of voice mode does not introduce a second cloud stack: it opens a hidden agent session on a provider you already installed and authenticated (claude, codex or opencode), keeping credentials and inference in your environment.
Relay and trust boundaries: the untrusted middle is a design premise
Remote access recommends the relay: the daemon connects outbound to a relay (the official implementation is the Elixir service getpaseo/paseo-relay) and the phone meets it there - no open ports, no port forwarding. Encryption is end to end. The daemon generates a persistent Curve25519 keypair in $PASEO_HOME/daemon-keypair.json; the pairing QR code or link carries the daemon public key as the trust anchor; both sides complete a NaCl box (XSalsa20-Poly1305) handshake before the daemon processes any command. The relay sees only IP addresses, timing, message sizes and session IDs - it cannot read content, forge messages or replay old sessions. Relay is off on new installations and offered only during pairing.
Direct connections get two more walls. One is a Host-header allowlist against DNS rebinding: daemon.hostnames defaults to localhost, *.localhost and all IP addresses, and the docs state plainly that CORS is not a complete security boundary. The other is a semantic permission model of nine permissions (daemon.read, daemon.manage, tunnel.manage, access.manage, workspace.read, workspace.write, workspace.manage, automation.manage, hub.execute), with principals separated from credentials so credentials rotate and revoke cleanly, sessions able to attenuate but never widen grants, and owner/operator/viewer existing only as UI presets that are never persisted. One sentence in the docs is the key judgment: agents and terminals share workspace authority because both execute code and mutate the workspace, so finer write permissions would claim an isolation boundary the daemon cannot enforce.
The ecosystem layer: plugins, skills and Hub each own a slice
Plugins run on the daemon and surface identically in every client: screens, sidebar items, workspace panels, Command Center items, slash commands, composer pills, attachment sources, timeline items and themes; they can also intercept agent lifecycle (configuration, environment, MCP servers, answering permissions, following up when a turn ends) and register new providers. Since 0.11.0 there is an official registry installed with paseo plugin add owner/slug, and the repo ships 14 plugin-examples plus a dozen usage-source plugins. The docs are blunt about trust: plugins are unsandboxed, server code runs with the daemon user's access, and paseo plugin add means "I trust this codebase", including its dependencies and its future updates.
Hub is the layer above daemons. The relationship exists only after an explicit paseo hub connect; the daemon opens an outbound WebSocket to the Hub, and the Hub never discovers daemons through the relay. Triggers from GitHub, Slack, Discord and Linear land on the hub.execute permission, and a fresh connection carries no execution authority at all. Hub can be hosted at hub.paseo.sh or self-hosted. It shows the author reaching toward the "assign work to agents" layer, but today the body of the project is still the runtime.
Engineering discipline: the protocol compatibility contract is the hardest part
The app and the daemon ship separately. Users update the app from an app store and the daemon whenever they feel like it, so new-app-against-old-daemon and old-app-against-new-daemon both exist in the wild - while in development both sides are always the same version, which is exactly the trap contributors fall into. protocol-compatibility.md turns this into two contracts. The protocol contract forbids any schema change that breaks parsing in either direction: new fields must be optional with sensible defaults, flipping optional to required, removing fields or narrowing types is banned, and wire schemas must be pure structural declarations (no transform, catch or preprocess, because inbound validators are generated and the generator only compiles pure schemas). Before committing you answer two questions: does a six-month-old app still parse this message, and does a six-month-old daemon still send something this app accepts. The feature contract runs the other way: features do not have to work across versions; detect the capability once in server_info.features, tell the user to update if it is missing, and never build degraded fallback paths or scatter defensive branches through the feature.
In scale this is a monorepo of 12 npm workspaces, roughly 1.1M lines of TS/TSX across 4,554 files with 1,714 test files; the server and app packages carry about 450k lines each. For a project built by one person and funded by its users, that volume plus the contract above says the author treats long-term maintainability as a product feature rather than a cover for debt.
Limitations and risks
Single-maintainer structure is the root fact: the README says built by one person, funded by GitHub Sponsors and company sponsors, and 1,276 open issues alongside several releases per week is the other face of it. Next is Antigravity's permanent full access: --dangerously-skip-permissions means every tool call including shell runs without asking under that provider; the docs warn and each session repeats the warning, but it is a product-level exposure, not a setting. Third is the session-replay gap: agy does not replay history, so after a daemon restart Antigravity remembers the conversation while Paseo's transcript starts fresh, and Claude transcripts living in another project folder produced "No activity to display" until 0.11.1 fixed one class of it - complete memory across restarts is still not a guarantee. Fourth, plugins are unsandboxed, so ecosystem openness and trust cost are the same coin. Fifth, local speech defaults to English only; other languages require manually switching to the v3 model, and Chinese is not among its 25 languages. Finally the NOASSERTION license reading: compliance automation flags it as unknown while the reality is Apache-2.0 plus a third-party preamble.
Where it sits in this site's coordinate system
The primary board is the open-source section /opensource; capability hubs are agents (orchestration) first, with code (AI coding) and harness (agent runtime, plugins plus skills plus MCP ecosystem) alongside, and the vertical is development. The closest relative is Orca: both are ADEs built on parallel agents and worktree isolation, but Orca bets on the IDE shape with Ghostty-class terminals and click-to-select design mode while Paseo bets on the self-hosted daemon, all-device clients and local voice. Against herdr, which takes over terminal processes, Paseo takes over agent processes and workspace registries. Against multica and paperclip, which sit higher and turn work into issues or companies, Paseo supplies the "make it run" layer underneath; the Hub trigger model is its first hand reaching up. For readers of this site it is one of the origin points of two hubs at once: to see how many agents run in parallel, read the worktree design and the MCP tool catalog; to see how a runtime grows an ecosystem, read the plugins, the skills and the protocol compatibility contract.