Explore / zeroshot

the-open-engine

zeroshot

Executor–verifier orchestration for code changes: a conductor classifies the task, an executor works in an isolated worktree, and a separate verifier must reproduce the evidence — looped to approval.

1,798 165 JavaScript MITupdated today

coding orchestration

View on GitHubDispute this mapping →

Curator's take

Built on one good sentence: the agent that wrote the code shouldn't be the one that says it works. A conductor scores every task on complexity (TRIVIAL→CRITICAL) and type (INQUIRY/TASK/DEBUG) with a junior model, escalating to a senior model when it answers UNCERTAIN, and that score picks the workflow — from single-worker with no validator up to debug pipelines with investigator/fixer/tester/completion-detector. Validators never share the executor's session or reasoning, and must reproduce reported failures. Runs default in a git worktree, keeps a crash-safe SQLite ledger, brings your own provider CLI and stores no keys. Reach for it when unattended runs need to be trustworthy, not fast. Skip it for interactive pair-programming: multi-agent verification loops cost several times a single agent's tokens and can run 90 minutes for one change. Linux and macOS only; the bundled Rust product is a separate, newer track.

Mapped by ShipWithAI editors · links verified

README.md

The agent that wrote the code shouldn't be the one that says it works.

Independent executor–verifier orchestration for software changes.

Install

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

Requires Node ≥ 22 and one supported provider. Guided setup detects installed providers, chooses a default, and configures worktree isolation for fresh repositories. Linux and macOS today; Windows is deferred.

This repository also contains Zeroshot Rust, the independent native product and zeroshot-rust CLI. It has its own releases and self-hosted target image; see the Markdown CLI reference, standalone HTML CLI reference, distribution contract, and target image guide. The remainder of this README describes the established Node product.

First run

cd your-repo
zeroshot run "Add a --json flag with tests"

In a git repository, the guided default runs in a separate worktree, so the current checkout is not edited. Use --no-isolation only when you explicitly want the run to modify the current checkout.

Observe the result from another terminal:

zeroshot list
zeroshot logs <id> -f

Zeroshot resolving an issue through the executor-verifier loop

Unattended, 100× speed · 90-minute run · 5 iterations to approval.

How it works

Zeroshot drives a coding agent through an executor–verifier loop. A conductor sizes the workflow, an executor implements the change in an isolated workspace, and a separate verifier judges the observable result. Validators do not share the e

Continue your stack

What teams reach for next — and why each earns a place beside zeroshot. Ranked by curator confidence.

Pairs well with

cwc-long-running-agents

Anthropic's harness primitives for long-running Claude agents: default-FAIL evidence gates, a fresh-context evaluator subagent and handoff hooks — each one standalone, readable file.

Why it fitsAnthropic's primitives — default-FAIL evidence gates and fresh-context evaluator subagents — are the doctrine Zeroshot productizes. Read the primitives to understand why independent verification is the whole game, then run Zeroshot to get it.

agentacct

Local-first work receipts for coding agents: reads the session logs Claude Code, Codex, OpenCode and Hermes already write and reports what each task did, what it cost, and whether a check proved it.

Why it fitsZeroshot's whole claim is that an independent verifier, not the executor, decides a change is done; agentacct is the ledger that records whether that actually held — decision and evidence on separate axes, per task, with provenance. Zeroshot produces the verdict, agentacct keeps the receipt.

Specula

Agentic formal verification: coding agents write TLA+ specs and invariants of your distributed system, model-check them, and reproduce violations at code level. arXiv paper + public bug list.

Why it fitsZeroshot's verifier is another LLM reproducing evidence. Specula gives it something machine-checkable instead: coding agents write TLA+ specs and invariants, model-check them, and reproduce violations at code level.

Alternative to See all + compare →

contrabass

Terminal-first orchestrator for issue-driven AI coding-agent runs — polls Linear/GitHub, runs Codex/OpenCode in git worktrees with retries and verification. Go/Charm rebuild of OpenAI's Symphony.

Why it fitsClosest neighbour: both run coding agents unattended in git worktrees with verification and retries. Contrabass is issue-driven, polling Linear/GitHub for work; Zeroshot starts from a prompt and puts its intelligence in classification and an independent verifier instead of the intake side.

fabro

Rust 'software factory' for coding agents: define the SDLC as a graph, agents execute it through verification gates, you intervene only at the stages that matter. Server, runs board, sandboxes.

Why it fitsSame conviction — agent output must pass gates — different locus of control. In Fabro you define the SDLC graph and the gates; Zeroshot ships an opinionated conductor that sizes each task and picks the workflow for you.

squid

Claude Code plugin that turns a feature spec into a reviewed PR through a 5-agent pipeline — PA → SWE → Tester → PR-Reviewer → On-Call — with exactly two human gates.

Why it fitsSquid is a fixed 5-agent Claude Code pipeline (PA → SWE → Tester → PR-Reviewer → On-Call) with exactly two human gates. Zeroshot routes dynamically by complexity and type, is provider-agnostic, and is built to finish without you.