cyberine

How it works

The mechanism

Four stages, the same every time. Many workers on one task, sealed off from each other, and one result kept because it passed a check, not because it sounded sure.

One task branches into four sealed worktrees off HEAD. One worker gets stuck and is cancelled; three diffs pass git apply and the typecheck; one diff is recorded and lands on the live tree.your live tree, HEADtaskloop-deepseek-buildloop-commandcode-freestuck, cancelledloop-mimo-buildloop-openrouter-buildapply tsc+4/-1 lands

The recorded run, as a git graph. Scroll drives it.04 Ship

  1. 01

    Dispatch

    A task fans out to every worker whose credentials are present. Two kinds: loop workers running a tool-calling loop against any OpenAI-compatible endpoint, and CLI workers where Cyberine spawns a real headless coding agent as a subprocess.

    Before any worker starts, the daily spend cap is checked.

    • CYBERINE_DAILY_USD_CAP, checked first
    • subscription seats: no marginal cost per run
  2. 02

    Isolate

    Each worker that writes code gets its own detached git worktree off HEAD. They cannot collide, cannot see each other, and cannot touch the live tree. Every one returns a git diff and nothing else.

    CLI workers run inside a host sandbox when one is available. A worker that stalls is cancelled by the stuck guard; the others keep going.

    • one detached worktree per worker
    • output: a git diff, nothing else
  3. 03

    Judge

    Four judges. Consensus counts votes. LlmJudge reads. AdversarialJudge sends N skeptics to refute. DiffJudge applies each candidate diff in a throwaway worktree and gates on git apply plus tsc --noEmit.

    For code, DiffJudge is the default, and it starts only after the last worker has stopped. When no worker carries a diff, the verdict says so in plain words:

    No candidate carries a diff — nothing to apply or verify.

  4. 04

    Ship

    The surviving diff lands in run.json. Integration applies it to the live tree and re-verifies, because a worker’s own claim of success is never evidence.

    • one command: cyberine apply

One real run, read stage by stage

What the four stages print

Recorded 2026-09-25 and trimmed. Four implementers dispatched, one stuck and cancelled, three diffs applied cleanly, one kept.

you$ cyberine run --cheap "Fix the off-by-one bug in src/chunk.ts"
01 / 02dispatch 4 implementers, each in its own git worktree
loop-deepseek-build done
loop-commandcode-free stuck, cancelled by the stuck guard
loop-mimo-build done
loop-openrouter-build done
03judge DiffJudge applies every diff in a throwaway worktree
loop-mimo-build diff applies cleanly (2/2)
loop-openrouter-build diff applies cleanly (2/2)
loop-deepseek-build diff applies cleanly (2/2)
04diff 1 file(s), +4/-1 from loop-deepseek-build
apply cyberine apply 81cbc07c

What run.json keeps

Every run leaves a record you can read after the fact. The decision lives in the verdict, not in any worker’s output.

Hover or focus a field to see which printed lines it records.

  • workerRunsone entry per worker: agent, provider, model, state, tool calls, tokens, cost, duration, sandbox
  • verdict.methodwhich judge ruled
  • verdict.winnerthe kept candidate, or none
  • verdict.rationalethe ruling, in a sentence
  • verdict.applyOutcomesper candidate: had a diff, applied or not, and why
  • winnerOutputthe surviving git diff

Run your first race.

Install it, point it at a repo, give it a task.

Read the docs
run 81cbc07cangle: the pipelinerecorded 2026-09-254 workers3 diffs applied1 kept$0.10 spent