Handoff
Your best model plans. Cheaper models build. You see what each Claude run cost.
Pick a chain or Auto crew, and Handoff splits a coding task: your top model plans it, each step goes to the smallest model in the chain that can do it well, and in a chain of three or more, a bigger model checks the small models' work on its way back up. A chain you pick yourself can give the small steps to a free or local model. Your agents also hand work to each other on a shared task board on your computer, so you stop being the copy-paste courier. It works in Claude Desktop, Claude Code, Codex, Gemini CLI, OpenCode and Grok Build.
Pay top-model prices mostly for the planning.
A chain lists up to four models, biggest first. The first one plans and the rest build, so most of a task's tokens are billed at the cheaper models' prices. The top model comes back only to fix a problem the check sends up.
Plan
Your top model can read files but not change them. It's asked to read only what it needs, then splits the task into up to six steps: design and tricky logic for the bigger builders; tests, docs, renames and small edits for the smaller ones.
Build
The steps run one after another in the task's own worktree, each committed on its own. Local and free models get short, exact directions, such as one change in one named file.
Check on the way up
If a smaller model fails its step, the biggest builder (the chain's second model) does it instead. When the steps are done, it checks the smaller models' work against the plan, with the diff in front of it, and fixes what's wrong. A problem too big for it, like a wrong design, goes back to the top model.
See the cost
The handback lists each step, check and fix with what it cost, and the Board shows what each task and the whole board have spent. Claude Code, Grok Build, OpenCode, Hermes and local models report what they used; Codex, Kimi Code, Cline and OpenClaw don't yet.
In this example, the crew costs about half as much. For new input and output, Sonnet 5.5 costs half of what Opus 5.5 does, and Haiku 5.5 a fortieth on prompts up to 100,000 tokens, at Anthropic's API prices (October 2026). On a Claude plan, lighter models use up less of your limits, so the same split stretches them.
Keep the top model's thinking for the plan. At max effort the top model is the most expensive part of a chain, so Auto crew uses Fable 5.1 only for heavy jobs, and the Board's ready-made chain starts Fable at low effort.
The example assumes Opus plans with 50,000 tokens read and 5,000 written, Sonnet builds with 300,000 and 30,000, Haiku does the small steps with 150,000 and 15,000, and Sonnet's check reads 100,000 and writes 5,000. Opus alone, with no check, does the job with 500,000 and 50,000. These are list prices without caching: with caching both cost less, and the ratio stays about the same. Real tasks vary. Each step starts fresh, so a crew can read more, and a step a small model can't do goes to a bigger one.
Handoff in a minute.
handoff board Handoff board 3 active · 1 open · 1 claimed · 1 handed_off Task Status Assignee Title T-2 handed_off claude Tests for /api/orders T-1 claimed claude Add /api/orders T-3 open codex Update the API docs
Check your handoffs.
Made for people who…
Use more than one coding agent
Give Claude, Codex, OpenCode or a local model the part each does best, and let them pass the work back and forth.
Are tired of copying between chats
Notes, acceptance checks and reviews travel on the board instead of through your clipboard.
Want a record of who did what
Every note, handoff and review is kept in order with its time, and agents' Handoff tools can't edit or delete it. (An agent with a shell on your account could still run the
handoffcommand as you.)Care about reviews
An agent can't review a task it worked on or sent for review, and by default an agent needs an approving review, or a reason, to mark a task done. Your Ixel MAT panel can give a second opinion too.
One ritual: "check your handoffs."
Split the work
In Claude, say
Hand the tests to Codex, and you do the endpoint.
Claude creates a task for each, with notes and acceptance checks.Check your handoffs
Switch to Codex and say
Check your handoffs.
Codex picks up its task and does the work.Hand it back
Codex hands the task back with what it did, what's left, how to check it, and the files it touched.
Review and finish
Claude reads the handoff, finishes up, and asks Codex or your Ixel MAT panel to review before the task is done.
Nothing wakes the other app up: an assistant only acts when you prompt it. So after one agent hands work over, you switch apps and say "check your handoffs." That's the whole ritual.
What you get.
- Handoff's tools in each app
- Claude Desktop, Claude Code, Codex, Gemini CLI, OpenCode and Grok Build each get Handoff's tools: an inbox, the board, and tools to create, claim, hand off and review tasks. Each joins the board under its own name.
- Your board in the terminal
handoff boardshows who's doing what and what's blocked.handoff show T-12prints a task's whole history.- Rules the board enforces
- Only the assignee can hand a task on, an agent can't review a task it worked on or sent for review, and agents' Handoff tools can't delete tasks or rewrite history.
- Warnings before edits collide
- When two active tasks claim overlapping files, both agents are warned: the second as it claims them, the first in its inbox and on its next note.
- Reviews by your Ixel MAT panel
- With Ixel MAT installed, a review can also ask your panel of models for a verdict.
- The worker (preview)
- Approve one task and let an agent work on it in its own git worktree while you're away. It commits on a branch and never pushes. On Linux and macOS it runs Claude Code or Codex in a sandbox, so they can run your tests. On Linux it needs bubblewrap, and socat for Claude Code;
handoff doctorsays what's missing. On Windows, Claude Code and OpenCode edit files only, for now. - Every agent and model you have
- OpenCode (its free models cost nothing), Ollama, LM Studio and any OpenAI-style server can take tasks, editing files only. Grok Build, Hermes Agent, Kimi Code, Cline, OpenClaw and agents you add run only after you switch each one on.
handoff agentslists what's on your computer. - The right model for each step
- Pick one model, let Auto crew pick for the job, or pick a chain: the biggest plans, and each step goes to the smallest model that can do it well. A chain's steps can run on any agent you have, local models included, and each is committed on its own. In a chain of three or more, a bigger model checks the small models' work on its way back up. Each model gets its own effort, in its tool's own words, sealed into your approval.
- No stop when a model runs out
- If a model hits its usage limit, the next best model you have takes over, and the result says who did. Handoff never picks a stand-in it knows costs more than the model you picked (in a chain written biggest first, than its planner). You see who would take over before you approve, and you can turn it off.
- What each run cost
- Each run on Claude Code, Grok Build, OpenCode, Hermes or a local model lists each model's tokens and an estimated cost at API prices (on a subscription, what it would have cost). The Board shows each task's cost and the whole board's spend. Codex, Kimi Code, Cline and OpenClaw don't report it yet.
- Merge when you're happy
handoff merge T-7, or Merge on the Board, brings a finished task's branch into your checkout as one merge commit. Nothing is pushed, and it refuses rather than touch files git doesn't track.
- Handoff never opens a network port. Each app talks to it over stdio.
- Everything on the board is marked untrusted: each agent is told it's information to weigh, not orders to follow.
- Common kinds of API keys and tokens, and private keys, are refused, not stored. Passwords aren't caught.
- The worker runs only tasks you approved on this computer, and never pushes. An approval covers the task as you saw it, for one run: if the task changes, approve it again. On Linux and macOS its sandbox keeps it in its worktree. On Windows, Claude Code's and OpenCode's edit-only modes, and Handoff's own file tools for local models, keep it there. An agent that runs with its own permissions (Kimi Code, Cline, OpenClaw) waits until you switch it on.
Get Handoff running.
You need:
- Windows 10 or 11, macOS 12 or newer, or Linux
- Python 3.10 or newer (the installer offers to get it, asking first). On Debian and Ubuntu, also
python3-venv - Git (the installer offers to get it if it's missing)
- At least one of Claude (Desktop or Claude Code), Codex, Gemini CLI, OpenCode or Grok Build; two or more, to pass work between them. Ollama or LM Studio adds free local models for small tasks
This installs Handoff on its own. It downloads Handoff from GitHub and updates it when you run it again. The installer itself needs no administrator rights (getting Git or Python may). You can read it first: install.ps1, install.sh.
Windows: in a normal PowerShell window (not "Run as administrator"), run:
irm https://ixelai.com/handoff/install.ps1 | iex
macOS or Linux: in a terminal, run:
curl -fsSL https://ixelai.com/handoff/install.sh | sh
Then open a new terminal window, go to your project's folder (it needs to be a git repository), run handoff setup --write, and restart the apps it connected. With a shell other than bash, zsh or fish, the installer first prints the line to add to your PATH.
Or get everything with Ixel
Ixel installs Handoff, Ixel MAT and the Ixel app together. With Ixel MAT, a review can also ask your panel of models for a verdict.
Windows:
irm https://ixelai.com/install.ps1 | iex
macOS or Linux:
curl -fsSL https://ixelai.com/install.sh | sh