Self-host the console. Run one local daemon on each machine.

One spec in.
A fleet of agents out.

Jerico is a fleet orchestrator for the CLI coding agents already on your machines. One spec becomes a DAG of todos, dispatched in parallel across every machine you own. Includes role routing, approval gates, and usage monitoring where each CLI exposes it. Five todos on three machines, running at once, without you scheduling any of it.

Jerico for macOS · Apple Silicon · macOS 12+

New here? Open Jerico, create a daemon token in Settings, then connect your first machine. See the three-step setup →

Latest public release Signed & notarized macOS app MIT-licensed daemon Privacy & data handling Built by Appnova EU OÜ

Write the spec. Approve the plan. Watch it dispatch.

Instead of manually scheduling agents across tmux panes and copy-pasting context, you write one Markdown spec. Jerico decomposes it into a role-routed DAG, waits for your approval, and dispatches independent todos in parallel across your connected daemons.

01

Spec

One Markdown spec carries context into every spawned todo.

Write the intention once, in Markdown. Jerico reads that spec instead of asking you to prompt each agent separately, and the same context reaches every todo it spawns.

02

Decompose

The spec becomes a role-routed DAG.

A planner breaks the work into todos, resolves dependencies, and emits a topologically-sorted graph. Each todo carries its role, its inputs, and the layer it lives in.

03

Approve

You approve the plan.

You see the plan before any agent touches a file. Reject it and re-spec, or approve — then the run starts. You steer the run; you don't supervise the agents.

04

Dispatch

Todos ship in parallel to your fleet.

The dispatcher claims a panel on whichever machine has the right agent free — claude-code here, codex there, qwen on the box under the desk. A reviewer agent gates every layer; you gate the plan.

Watch Jerico orchestrate your agents.

Eight moves Jerico makes — every clip a real capture from a running instance.

panel grid 01 / 08

Every agent, side by side.

One panel per agent, live. Claude, Codex, OpenCode — each with its own role, status and streaming output, gathered in one roster.

bring your own 02 / 08

Your supported CLI agents.

Jerico detects Claude Code, Codex, Qwen, opencode, Kimi, Antigravity, Aider, Ollama, Forge, GitHub Copilot CLI and Shell — with the accounts and quotas you already use.

orchestration 03 / 08

Watch every todo dispatch.

Jerico assigns each ready todo to a free matching panel, injects its dependency context, and starts completion tracking as soon as dispatch succeeds.

monitoring 04 / 08

Claude & Qwen usage and quota.

Context-window percent and five-hour prompt quota for Claude panels, quota for Qwen. Watch a runaway agent's quota climb and kill it from the browser — no tmux dive required.

workspace 05 / 08

From welcome screen to live project.

One dialog: name, machine, folder. Jerico creates the project, and the workspace is ready for its first session — no setup scripts, no folder wrangling.

natural language 06 / 08

Ask for your fleet in one sentence.

create a claude developer, codex developer and an opencode developer — one line, three engines, all three spawned. Ask an orchestrator agent in plain language and it uses Jerico's panel-management tools to dial the supported agents and roles you request.

groups 07 / 08

Squad up your agents.

Create a + Group, drop agents in, and the sidebar reorganizes into the teams you actually work in — a developers group with its own count and hierarchy, visible instantly.

blueprint 08 / 08

Keep the project blueprint current.

Jerico records important run events. The orchestrator can write confirmed conclusions back to the project blueprint so later sessions start with the latest decisions.

Stop scheduling agents pane by pane.

CapabilityJericoAgents by hand
One spec decomposed into a dependency graphautomaticyou plan it
Independent work dispatched in parallelautomaticyou schedule it
Human approval gate before any agent writes a fileyesnone
Destructive commands held for confirmation before they runautomaticmanual terminal monitoring
Role routing: planner, developer, revieweryesmanual
Agents on more than one machine, one viewyesssh per box
Context handed from a finished todo to the nextautomaticcopy-paste
An agent can drive the orchestration itself over MCPyesmanual prompt copy-paste
Local indexed code-graph tools for symbols, callers and diff impactavailable over MCPmanual grep / ripgrep
Live Claude & Qwen context / quota countersyesno
Uses your existing agent subscriptionsyesyes
Agents, keys and code stay on machines you ownyesyes

Jerico keeps your existing agents and credentials; it adds dependency-aware scheduling and context handoff.

One browser tab. Every machine you own.

Run one daemon on each machine you want to use. Jerico can assign ready todos to available agent panels across those machines and stream their terminals into one browser tab.

Each daemon connects outward to your Jerico server, so one run can use panels on several machines.

  1. BrowserOne view for the run and all PTY output
  2. Your Jerico serverStores the run graph and dispatches ready todos
  3. One daemon per machineConnects outward and launches supported local CLIs

Role-routed agents: planner, developer, reviewer.

Each todo records its dependencies and required role. Ready developer todos can run together; reviewer todos wait for the work they inspect.

  1. Planner

    Decomposes Markdown specs into a dependency-ordered todo graph

    One planner agent reads the Markdown spec, breaks it into todos, decides what depends on what, and emits the graph you approve. No build step until the plan is right.

  2. Developer

    Executes assigned todos in parallel across available nodes

    Developer agents pick up todos whose dependencies are met. They run in parallel — siblings don't block each other. Each reports done, failed, or blocked, with its transcript attached.

  3. Reviewer

    Audits layer diffs and gates execution before downstream tasks unlock

    When a layer's developers are done, a reviewer reads the combined diff: approves, requests changes, or fails a todo back to the queue. You signed off on the plan; from there the reviewer holds the gate.

The CLI agents Jerico detects.

Jerico dispatches to whatever supported CLI is already on your machine. The daemon detects supported CLIs automatically and uses the credentials and subscriptions already configured on that machine.

  • Claude CodePTY, MCP, usage telemetry
  • CodexPTY and MCP
  • QwenPTY, MCP, supported telemetry
  • opencodePTY and MCP
  • KimiPTY and MCP
  • OllamaPTY
  • AiderPTY
  • AntigravityPTY
  • GitHub Copilot CLIPTY
  • ForgePTY
  • ShellPTY

Install a supported CLI and the next daemon handshake picks it up. No plugin or wrapper to install on top of it.

Approve every gate before an agent writes.

Jerico pauses for plan approval, and again before dispatching a todo that contains a destructive command. From the browser you can watch a run, kill a stray todo, or redirect a stuck agent.

  1. Before the run Review the planner's dependency graph. Implementation waits for approval.
  2. Before destructive shell reaches a panel Jerico holds commands such as rm -rf, terraform destroy, and git push -f for a separate confirmation.

The plan is human-readable. No agent writes a file until you've approved it.

Self-hosted. Yours.

The bridge-agent daemon is MIT-licensed and published on npm. Run Jerico's server and web console on infrastructure you control. The daemon sends terminal output, commands, agent state, and supported usage data to that server; agent binaries and credentials remain on the machine. Jerico does not add third-party product analytics to the console or the daemon.

Self-hosted server
Run the Bun/Hono server on your own VPS or local machine. The web console connects to infrastructure you control.
MIT-licensed daemon
The daemon the Mac app bundles (bridge-agent) is MIT-licensed — read the source, audit what runs on your machine, patch it.
Outbound connections
Your code and your keys stay on your machines. Daemons establish outbound WebSocket connections; no inbound ports required.
Zero product analytics
No trackers, no beacons and no session recording inside the console. The daemon checks npm and GitHub for updates; session data goes only to your server. Analytics run on these marketing pages only.

Frequently Asked Questions

What is Jerico?

Jerico is a self-hostable fleet orchestrator for CLI coding agents. You write one Markdown spec; a planner agent decomposes it into a dependency graph of todos; you approve the plan; Jerico dispatches those todos in parallel to the agents already installed on your own machines — Claude Code, Codex, Qwen, opencode, Kimi, Antigravity and more — and streams every terminal panel into a single browser tab.

How is Jerico different from running agents in tmux?

In tmux you are the scheduler: you decide what runs next, you re-paste context between panes, and you are limited to one machine. Jerico plans the work into a dependency graph, routes each todo to a planner, developer or reviewer agent, and dispatches independent todos in parallel across every machine running a Jerico daemon — while you watch and approve from a browser tab.

Can an agent drive Jerico instead of me driving the UI?

Yes. Jerico exposes its orchestration surface over MCP. An MCP-connected orchestrator agent can create dependency-aware todos, spawn and assign workers, inspect their live output, and report work complete while the browser remains your observation and intervention surface.

What happens if a machine drops or the server restarts mid-run?

An approved run returns paused, not erased. Jerico persists its todos, dependencies, transcripts and retry context; after reconnect, you can resume without rebuilding the graph by hand. A watchdog retries timed-out todos and fails work that remains stuck. Plans that have not yet been approved are not included in this guarantee.

Which agents does Jerico support?

Jerico detects and drives the CLI agents already installed on your machine: Claude Code, Codex, Qwen, opencode, Kimi, Antigravity, Aider, Ollama, Forge, GitHub Copilot CLI, and a plain shell. Jerico drives them over a PTY, so it uses your existing subscriptions and API keys — there is no Jerico model and no Jerico API key.

Can Jerico coordinate more than one machine?

Yes. Each machine runs one bridge-agent daemon that connects out to your server. Todos in the same dependency layer are dispatched in parallel across all connected machines, so a run can span a laptop, a tower and a Linux VM at the same time — all visible in one browser tab.

When do agents start writing files?

After a planner produces the execution plan, Jerico pauses the run for your approval. No implementation todo is dispatched until you approve that plan; reviewer agents then gate implementation work during the run.

What stops an agent from running rm -rf on my machine?

Jerico scans every todo for high-blast-radius shell before it is dispatched — rm -rf, DROP TABLE, TRUNCATE, terraform destroy, kubectl delete --all, docker system prune, git push -f, dd, mkfs and more. A flagged todo never reaches the agent: it stops in awaiting confirmation until you click through, and its dependents wait behind it. That is a separate gate from the plan approval — it fires even on work you already approved.

What data leaves my machine?

The daemon connects outward, over an authenticated connection, to the Jerico server you configure — in the self-hosted setup, that server is yours. It sends terminal output, commands, agent status and supported usage metadata to that server; agents and credentials stay installed locally. The console and the daemon add no third-party analytics, trackers or session recording — these public marketing pages (this page and the guide) use Microsoft Clarity for aggregate funnel analytics. The privacy page is the complete disclosure.

Is Jerico open source?

The Jerico daemon (bridge-agent) is MIT-licensed and published on npm, so you can read and audit exactly what runs on your machine. The console is self-hostable — you run the server, you own the data.

Is there a mobile app?

There is no native mobile app. Use the web console from a phone to check a run or approve a plan; terminal-heavy work is still better suited to a larger screen.

Open a tab.
Connect a machine.
Dispatch.

Open Jerico, create a daemon token in Settings, and connect the first machine you want to use.

Free to self-host. No seats, no metering — you already pay for the agents.