zeroshot

zeroshot

A multi-agent orchestration engine that keeps coding agents from grading their own work.

zeroshot.sh · Discord · Docs · Blog

npm install -g @the-open-engine-company/zeroshot

Single agents have a reliability ceiling. As context grows and complexity compounds, requirements get buried, assumptions go unchallenged, and shortcuts start to accumulate. The agent will optimize for completion and lose track of what correctness requires.

Independent, adversarial review fixes that. A reviewer starts with fresh context and looks for reasons the work should fail. Rejection turns those failures into concrete repair tasks. Each revision faces renewed scrutiny, allowing the system to recover from mistakes that would otherwise survive all the way to “done.”

zeroshot is a multi-agent framework built around this cycle. Define your graph topology, choose your agents and models, and make independent approval a requirement for delivery. The engine enforces the process.

Build your own graph

An example graph: independent reviews, end-to-end testing, and CI must pass before merge.

                           ┌─────────────────┐
                           │       Goal      │
                           └────────┬────────┘
                                    ▼
┌───────────────┐          ┌─────────────────┐
│     Repair    ├─────────▶┤      Worker     │
└───────┬───────┘          └────────┬────────┘
        ▲             ┌─────────────┴─────────────┐
        │             ▼                           ▼
        │  ┌─────────────────────┐     ┌─────────────────────┐
        │  │  Acceptance review  │     │     Code review     │
        │  └──────────┬──────────┘     └──────────┬──────────┘
        │             │                           │
        │             └─────────────┬─────────────┘
        ├◀─── either rejects ───────┤
        │                           │  both approve
        │                           ▼
        │                  ┌─────────────────┐
        ├◀───── fail ──────┤ End-to-end test │
        │                  └────────┬────────┘
        │                           ▼  pass
        │                        ┌─────┐     ┌─────┐        ┌───────┐
        │                        │  PR ├────▶┤  CI ├─pass──▶┤ Merge │
        │                        └─────┘     └──┬──┘        └───────┘
        └◀───────────── fail ───────────────────┘

Save your graph as a reusable profile and run the same process across tasks.

See more graph examples on zeroshot.sh.

Features

Bring your own graphs

One graph per process your team runs.

• Graphs are JSON: steps, reviewers, branches, parallel work, bounded loops and maps over lists.
• Profiles: save each graph by name and pick one per run with --profile.
• Agent and model per node: Claude Code, Codex, Copilot CLI, Pi and more, through the providers each agent supports: OpenAI, Anthropic, OpenRouter, Bedrock, Foundry or your own endpoint.
• Delivery: a run can end by pushing a branch, opening a PR, or opening and merging one on GitHub, GitHub Enterprise or GitLab, or by leaving the change in your working copy. The built-in template software-change defaults to PR delivery.

The engine enforces them

Agents do the work. The graph decides what happens next.

• Checked before it runs: type mismatches, unbounded loops and unreachable branches are rejected before any agent starts. --validate-only runs just the checks.
• Reviewers route the run: each reviewer returns an enum verdict, and the graph routes on it.
• Script steps: run a deterministic command as a step in local runs.
• Secrets stay out of the record: credentials are stored once as named connections and kept out of graphs, run history, logs and the UI.

See inside every run

• zeroshot ui: each node's input, output and logs in the browser, on a timeline you can replay.
• CLI: status and list return JSON, watch and logs stream resumable events, attach follows a running agent.
• SQLite: one SQLite file per local run.
• Resume: restart a failed run from a checkpoint without redoing finished steps.

Build on it

Drive zeroshot from your own code, CI or UI.

• Python SDK: async Python client for submitting, watching and waiting on runs. Each wheel bundles the matching zeroshot binary.
• JSON-RPC API: run zeroshot target serve and connect over WebSocket to submit runs, watch their status and which nodes are running, and stream logs. An OpenRPC spec describes the methods.
• API keys: expiring, revocable CI keys for hosted targets.
• Agent adapters: add support for another coding agent through a documented contract.

Get started

The installer adds skills for Claude Code, Codex, Copilot CLI and Pi. Open your agent in a repo and ask:

design a zeroshot graph for this repo

The skill reads your repo and builds the graph with you: agents, models, review gates, and delivery. Then plan a task:

plan this with zeroshot: let users export their data as CSV

Run the plan:

zeroshot it

Run locally with your agent's existing login and subscription. Watch with zeroshot ui. See installation options to skip skill installation.

Edit a graph directly

Export a template with Git delivery disabled:

zeroshot template show software-change --delivery none > graph.json

Edit the graph, choose a runtime, and run it. The review loop guide has complete graph, input, and runtime files; the CLI quick start shows validation and execution.

Hosting

Run locally, self-host with Docker, or share graphs and run on zeroshot Platform using your own model API keys.

Contributing

Development guide · UI development · Publishing · Security · Issues · Discord

MIT. See LICENSE.