v0.1.0CLI, MCP server and Claude Code plugin

You already pay for the models.Put all of them to work.

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.

  • Read-only by default
  • Zero dependencies
  • Your logins, no API keys
  • Git-worktree isolation
  • CLI + MCP server
  • MIT licensed
One install. Every subscription you have.
pipx install git+https://github.com/JayPokale/farmout
# Python 3.9+ · zero dependencies · runs on the logins you have
# then: farmout doctor --live  ·  farmout review
Free and MIT licensed · star it on GitHub
bugs flagged by at least three of the four models; 27 by all four

32/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

of Claude's own tokens when Antigravity reads the papers instead (−74% cost)

−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

for four models to review a change, merged and checked against the code

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

dependencies: standard-library Python you can read before you hand it your logins

Zero

dependencies: standard-library Python you can read before you hand it your logins

pyproject.toml · dependencies = []

See it work

One command. Four subscriptions. One answer.

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.

~/demo

$

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

Which AI is best on your code?

Everyone argues about Claude, GPT and Gemini. farmout bench settles it on your own git history, with the subscriptions you already pay for.

  1. 1

    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.

  2. 2

    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.

  3. 3

    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.

A farmout bench card: Which AI reviews my code best? Two real bug fixes replayed. Claude 2/2, Codex 2/2, Copilot 2/2, Gemini 1/2.
A real card: two bug fixes from tqdm's history, 2026-11-17. Claude, Codex and Copilot found both; Antigravity's fast model found one.

How it works

Three ways in, one lane per subscription

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.

farmout CLIyou, in a terminalMCP headClaude Code · Codex · any clientgit hookreview on commit or pushfarmoutstandard-library Pythonsessionsinbox · runner · resumeworktreesisolate · patch · applymerge + checkagreement · citationslimitsreset times · fallbackantigravityagy · read-onlycodexcodex · read-onlyclaudeclaude · read-onlycopilotcopilot · read-onlydeepseekdsh · read-onlyapiOpenAI-compatible

Hover a box, in the diagram or below it.

Get started

Running in under a minute

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.

Full install guide →
  1. Install

    $ pipx install git+https://github.com/JayPokale/farmout

    Adds the farmout command. Python 3.9+ and nothing else.

  2. Log in to the CLIs you have, once

    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.

  3. Hand it work

    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

Your subscriptions, one interface

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

agy

Antigravity 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

codex

Codex CLI

your ChatGPT account

Well-specified coding: implement a function, write and fix tests, focused refactors, reviews.

read-only
codex exec -s read-only
to write
-s workspace-write
resumes
codex exec resume <id>

claude

claude

Claude Code

a second Claude account

General work on separate quota, so your main session keeps its own.

read-only
claude -p --tools Read,Grep,Glob,WebSearch
to write
--permission-mode acceptEdits
resumes
claude --resume <id>

copilot

copilot

GitHub Copilot CLI

your Copilot plan

Code review, focused coding questions, second opinions, with models from several vendors.

read-only
copilot -p … --available-tools view rg glob web_fetch
to write
adds apply_patch edit create; never a shell
resumes
copilot --session-id <id>

deepseek

dsh

DeepSeek Harness

your DeepSeek API key

DeepSeek V4 at a few cents a task: bulk reading, summaries, routine coding and one more opinion. Experimental.

read-only
dsh headless --permission-mode read-only --approval-policy never
to write
--permission-mode workspace-write
resumes
dsh headless --session-id <id>

api

api

OpenAI-compatible API

DeepSeek's API, Ollama, vLLM, OpenRouter, …

Bulk or simple work on any open or local model. No tools: file text goes into the prompt.

read-only
no tools at all
to write
n/a
resumes
farmout keeps the history

+ the next one

A new worker is one function in farmout/workers.py and one table entry, plus proof that its read-only mode really can't write.

Adding a worker →

Features

Every way to put them together

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

farmout 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

farmout race

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

run · send · fork

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.

Models that argue

farmout ask --debate

Every model answers, reads the others' answers, then answers again.

Your code, your leaderboard

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.

Pull request feedback, raced

farmout fix-pr 128

Review comments and failing checks (through gh) become a race your tests judge.

Usage limits, handled

--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.

Review on every commit

farmout hook install

The commit is blocked when two or more models flag a high-severity bug. FARMOUT_SKIP=1 skips it once.

Watch, share, script

farmout ls --watch

A live dashboard, status --line for tmux, export --html to share a conversation, --json on every command.

Pipelines

When one finishes, the next one starts

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"

  1. plan · claude

    reads {args}

    pending
  2. build · codex

    own worktree · pytest -x

    pending
  3. review · every worker

    skill review · in build

    pending
  4. notes · copilot

    approve = true

    pending

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

Extend it the way you extend your agent

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.

Skills

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

Hooks

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

The store

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

Browse the store →

Benchmarks

Measured, misses included

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

antigravity
32
claude (Sonnet)
32
copilot
30
codex
29
all four, in parallel
32

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

Claude reads the PDFs itself$0.148 · 13s
48,097
Claude + farmout (Antigravity reads)$0.039 · 62s
19,747

−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.

What it costs, honestly

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

Your accounts, your rules

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 →

Read-only unless you say otherwise

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.

Worktrees, then patches

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.

Settings only ever narrow

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.

Code runs only if you vouch for it

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.

Credentials can stay home

redact = true strips API keys, tokens, private keys, JWTs and password=… values from every brief and from piped input before anything leaves your machine.

Prompt injection is real

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

Pick the right tool

Good tools exist in this space. Choose by what you need.

projectchoose it when
Codex plugin for Claude Codeyou only need Codex, and want OpenAI's official rescue, session-transfer and background-job commands
Claude Octopusyou 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-kanbanyou want a TUI, desktop app or board to run several interactive agents side by side
claude-code-routeryou want to swap the model behind Claude Code rather than use other CLIs
farmoutyou 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

Questions, answered

farmout runs each vendor's official CLI in its documented non-interactive mode, logged in as you, exactly as you could from a script. It doesn't extract tokens, scrape web apps or proxy APIs. You're still responsible for each provider's terms: don't use it to share accounts or resell access.

Stop paying for idle subscriptions. Put them to work.

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/farmout

If farmout saves you quota, a star costs none. Its own code is reviewed by the four models it drives.