antigravity
agyAntigravity CLI
your Google account
Long PDFs, papers, many-file reading, web research. Gemini, plus the other models agy lists.
- read-only
- agy -p … --mode plan
- to write
- --mode accept-edits --sandbox
- resumes
- agy --conversation <id>
Codex, Gemini, GitHub Copilot, DeepSeek, a second Claude and local models review your change side by side, race on fixes your tests judge, and take turns in pipelines. From your terminal, or from inside Claude Code.
pipx install git+https://github.com/JayPokale/farmout
# Python 3.9+ · zero dependencies · runs on the logins you have
# then: farmout doctor --live · farmout review32/32
bugs flagged by at least three of the four models; 27 by all four
23 planted + 9 real BugsInPy regressions, 2026-11-17 · bench/README.md
−59%
of Claude's own tokens when Antigravity reads the papers instead (−74% cost)
three arXiv papers, 43 pages, same answers · bench/results/2026-11-17/head_tokens.md
59s
for four models to review a change, merged and checked against the code
files_api case: all 5 planted bugs found, 4 of them by 4/4 · demo-review.md
Zero
dependencies: standard-library Python you can read before you hand it your logins
pyproject.toml · dependencies = []
See it work
farmout review hands your uncommitted change to every subscription you have, at once and read-only, then merges what they found into one table. farmout race has each one fix a bug in its own worktree and lets your tests pick the winner. Both are the unedited output of real runs; only the wait is sped up.
$
files_api.py, a 61-line change with five planted bugs, reviewed by four subscriptions at once. All five planted bugs are there, three flagged by every model, plus a real race in the quota update that nobody planted, which all four caught. Each row is one defect with how many models flagged it, and a finding that cited a missing file or line would have been dropped. Every reviewer is now a session you can question: farmout send review-1-codex "…".
Bench
Everyone argues about Claude, GPT and Gemini. farmout bench settles it on your own git history, with the subscriptions you already pay for.
Finds your bug fixes
Recent commits whose subject says fix, bug, crash or regression, small enough to judge: at most 4 files and 80 changed lines.
Puts each bug back
In a scratch git worktree the fix is undone, so the bug is an uncommitted change in its real codebase. Your own tree isn't touched.
Asks every subscription
Each one reviews the change with farmout's brief and scores when a finding lands within 3 lines of the bug.
$ farmout bench --share--share writes a post that fits on X, an image card and a one-click post link. The card carries scores only: no repository name, file names or code.

How it works
You, a coding agent or a git hook hands farmout the work. farmout fans it out to the CLIs you have, keeps every conversation, and brings the answers back merged.
Hover a box, in the diagram or below it.
Get started
farmout drives the official CLIs you already use, logged in as you. No API keys, no proxy, no extra bill: each task spends the quota of the subscription that runs it.
You need
Python 3.9+, git, Linux (tested) or macOS, and at least one of: Antigravity CLI, Codex CLI, GitHub Copilot CLI, a second Claude Code account, or an OpenAI-compatible endpoint.
$ pipx install git+https://github.com/JayPokale/farmoutAdds the farmout command. Python 3.9+ and nothing else.
Whatever you already pay for. A second Claude account logs in to its own config folder; a local model is two environment variables. Then ask farmout what it found:
# a second Claude account$ CLAUDE_CONFIG_DIR=~/.claude-2 claude$ export FARMOUT_CLAUDE_DIR=~/.claude-2
# any OpenAI-compatible model$ export FARMOUT_API_BASE=http://localhost:11434/v1 FARMOUT_API_MODEL=qwen3:32b
$ farmout doctor
ready antigravity agy 1.4.6
ready codex codex-cli 0.163.0
ready claude 2.1.323 (Claude Code)
ready copilot GitHub Copilot CLI 1.0.112.
missing deepseek install DeepSeek Harness (`npm i -g @deepseek-ai/dsh`) and set DEEPSEEK_API_KEY
missing api set FARMOUT_API_BASE and FARMOUT_API_MODEL (and FARMOUT_API_KEY if needed)
Logins are not checked. `farmout doctor --live` sends each ready worker one tiny prompt.
every model reviews your change
farmout review
one question, every answer
farmout ask "Is this migration safe?"
your tests pick the winner
farmout race "Fix the flaky test" --test "pytest -x"
a conversation that remembers
farmout run codex "Add tests for parse_date()" -n dates
Every command takes --json for scripts. Workers are read-only unless you pass --write or --isolate.
Workers
Each worker is the vendor's own CLI in its documented non-interactive mode, logged in as you. farmout resumes every conversation through that CLI's own session id, so a model really remembers earlier turns instead of rereading a summary.
antigravity
agyyour Google account
Long PDFs, papers, many-file reading, web research. Gemini, plus the other models agy lists.
codex
codexyour ChatGPT account
Well-specified coding: implement a function, write and fix tests, focused refactors, reviews.
claude
claudea second Claude account
General work on separate quota, so your main session keeps its own.
copilot
copilotyour Copilot plan
Code review, focused coding questions, second opinions, with models from several vendors.
deepseek
dshyour DeepSeek API key
DeepSeek V4 at a few cents a task: bulk reading, summaries, routine coding and one more opinion. Experimental.
api
apiDeepSeek's API, Ollama, vLLM, OpenRouter, …
Bulk or simple work on any open or local model. No tools: file text goes into the prompt.
Features
One model's answer is a guess. Several at once are a review with agreement counts, a race your tests settle, or a second opinion you can follow up with.
Cross-model review
Every worker reviews your uncommitted change, your staged files or a branch, at the same time and read-only. Findings merge across models with agreement counts, and a finding that cites a file or line that doesn't exist is dropped before you see it.
Races your tests judge
Every model attempts the same change in its own git worktree, with your uncommitted work copied in. Passing tests win, then the smallest diff, then the fastest. Your tree stays untouched until you apply the winner.
Sessions that remember
Named conversations with any worker. Send while it's busy and the message waits its turn; attach from any terminal; fork a side question with the same context; hand one session's reply to another.
farmout ask --debate
Every model answers, reads the others' answers, then answers again.
farmout bench -n 3
Recent bug fixes from your own history are undone in a scratch worktree, and each model is scored on finding them.
farmout fix-pr 128
Review comments and failing checks (through gh) become a race your tests judge.
--fallback codex,copilot
A worker at its limit sits out until the reset it reported, and the task moves to the next. farmout stats shows what each one did.
farmout hook install
The commit is blocked when two or more models flag a high-severity bug. FARMOUT_SKIP=1 skips it once.
farmout ls --watch
A live dashboard, status --line for tmux, export --html to share a conversation, --json on every command.
Pipelines
Chain workers into stages in a TOML or JSON file. Gates on tests, agreement or severity decide whether the next stage runs; foreach fans a list out in parallel; approve waits for you. A failed or stopped run picks up where it stopped with farmout pipe resume.
.farmout/pipelines/ship.toml
description = "Plan with Claude, build with Codex in a worktree, ship after I approve" [[stage]]name = "plan"worker = "claude"prompt = "Write a short plan for: {args}" [[stage]]name = "build"worker = "codex"isolate = trueprompt = "Implement the plan in {plan}. Run the tests."test = "pytest -x"gate = "tests" # only if the tests pass [[stage]]name = "review"skill = "review"in = "build" # review the build's worktreegate = "high == 0" [[stage]]name = "notes"worker = "copilot"approve = true # waits for: farmout pipe approveprompt = "Release notes for {build.patch}"
$ farmout pipe run ship "Add CSV export to the reports page"
plan · claude
reads {args}
build · codex
own worktree · pytest -x
review · every worker
skill review · in build
notes · copilot
approve = true
Every stage is a session: attach to it, or send it a follow-up.
fix · built in
Review your change, fix what two or more models agree on in a worktree, then review the fix.
$ farmout pipe run fix --set test="pytest -x"
spec · built in
Requirements, then a design, then independent tasks, each built in its own worktree in parallel, then one check of all the patches together.
$ farmout pipe run spec "Add CSV export to the reports page"
Placeholders: {stage} is a stage's output, {stage.patch} its patch, {args} your text, {item} a foreach item. Gates: ok, tests, agree >= N, high == 0, contains "TEXT". Pipeline reference →
Skills, hooks, the store
Skills in the SKILL.md format Claude Code, Codex and Copilot already share. Hooks on farmout's own events. And a store where every file is pinned by its SHA-256, because hooks and tools are code.
Run one on any worker with farmout security-review. Install from a folder, a git repo or a URL; a fetched skill that contains code or symlinks is refused.
skills/security-review/SKILL.md
---name: security-reviewdescription: Security problems only, every workermode: review # ask | review | raceworkers: [codex, claude, copilot]diff: true # hand over your change---Look only for problems an attackercould trigger: ...$ARGUMENTS
Six events, from SessionStart to PipelineEnd. A TaskStart hook can rewrite a brief or block it before it reaches a worker. A project's own hooks run only after farmout trust, pinned to the file's hash.
~/.config/farmout/settings.toml
[[hooks]]event = "TaskEnd"command = "notify-send farmout done"matcher = "codex|claude" # optional regextimeout = 30
SessionStart · MessageReceived · TaskStart · TaskEnd · StageEnd · PipelineEnd
farmout store show prints an entry's files so you can read them first; store add checks each one against the index and installs nothing if a single hash differs.
security-reviewskill
every worker hunts security bugs only, merged with agreement counts
test-gapsskill
behaviours in your change no test covers, and the test to add
notifyhook
a desktop notification, or a phone push through ntfy, when a long turn ends
guard-secretshook
refuses a task that would hand a worker .env files or keys
prunetool
deletes sessions idle for N days, with their worktrees
Benchmarks
Planted bugs and real regressions, the exact review brief, every worker's raw output committed. The method and the data ship in the repo, so you can rerun any of it on your own subscriptions.
Bugs found, of 32
23 planted in five realistic changes + 9 real regressions from BugsInPy
Every one of the 32 was flagged by at least three of the four models, and 27 by all four. In these runs, a finding flagged 4/4 was a real bug every time.
Claude's own tokens, reading three papers
Transformer, BERT, ResNet · 43 pages · same correct answers
−59% tokens, −74% cost for the head; the gap grows with every page it no longer reads.
Four reviews in about a minute
A parallel call is as slow as its slowest worker. With Antigravity on Flash low, a four-model review of a real change took 59s end to end; on its default model, 220s.
| Does delegating save Claude's quota? | Yes: −59% head tokens, −74% head cost on three papers. It took 62s instead of 13s. |
| Do four reviewers beat the best one? | Not when the best one has room: Claude (Sonnet) alone found all 23 planted bugs when allowed 30 findings. Four helped under a short cap (17 vs 10 of 23). |
| Does /farmout:review save Claude's quota? | No. Claude merges and verifies four reports: $0.122 and 59s, against $0.033 and 13s reviewing alone. |
| Does the read guard pay off? | On a 16-page deep read Claude's cost halved ($0.139 → $0.069), but it took 240s instead of 20s. |
Small samples: treat these as a sanity check, not a leaderboard. Better yet, run farmout bench on your own history. Raw outputs: bench/results.
Safety
farmout runs each vendor's official CLI in its documented non-interactive mode, logged in as you. It doesn't extract tokens, scrape web apps or proxy APIs, and it's small enough to read before you trust it with your logins.
# <repo>/.farmout/settings.tomlworkers = ["codex", "claude"] # who may see this repowrite = false # no write, no isolate hereweb = false # no web toolsfallback = ["codex", "copilot"] # who takes over at a limitredact = true # strip credentials first
Data still leaves your machine: briefs and files go to each worker's provider. You remain responsible for each provider's terms; don't use it to share accounts or resell access. Every flag, per worker →
Every worker starts in its CLI's read-only mode: plan mode for agy, -s read-only for codex, an allowlist of reading tools for claude and copilot. Writing needs --write, --isolate or write: true.
An isolated worker edits its own git worktree, and in-repo paths in its brief point there. Your tree changes only when you apply a patch. It's not a filesystem sandbox: a tracked symlink out of the repo can be written through.
Your settings and a repo's both apply, and neither can loosen the other: worker lists intersect, write and web are off if either says so, the shorter timeout wins. Keep work code off personal accounts with one line.
Hooks and tools come from you or from the hash-pinned store. A project's own hooks run after farmout trust, pinned to the file's SHA-256, and stop if it changes.
redact = true strips API keys, tokens, private keys, JWTs and password=… values from every brief and from piped input before anything leaves your machine.
Workers read whatever you hand them, and a hostile document can try to instruct them. Read-only mode limits the damage; it can't make injection impossible. web = false closes the web tools.
Alternatives
Good tools exist in this space. Choose by what you need.
| project | choose it when |
|---|---|
| Codex plugin for Claude Code | you only need Codex, and want OpenAI's official rescue, session-transfer and background-job commands |
| Claude Octopus | you want structured multi-model councils, many providers and workflow gates, and don't mind a large plugin |
| PAL MCP Server (formerly Zen) | you want many workflow tools (consensus, code review, planning) and API-key models, plus its clink CLI bridge |
| claude-squad, Conductor, vibe-kanban | you want a TUI, desktop app or board to run several interactive agents side by side |
| claude-code-router | you want to swap the model behind Claude Code rather than use other CLIs |
| farmout | you want the subscriptions you already have working together, read-only by default, from a terminal or an MCP client, with sessions, cross-model review, races, pipelines, skills, hooks and a hash-pinned store, in standard-library Python you can audit |
FAQ
MIT licensed, built in the open, no dependencies. Land a PR, or file an issue good enough to fix itself, and you're credited in the repo.
$ pipx install git+https://github.com/JayPokale/farmoutIf farmout saves you quota, a star costs none. Its own code is reviewed by the four models it drives.