#Zeroshot

The agent that writes the code should not be the one that decides it works.

Zeroshot turns a software goal into an explicit multi-agent graph. One agent implements. Independent agents review. Failures route back into bounded repair. Delivery happens only after the graph's checks pass.

Delivery is explicit: keep work local, push the managed branch, prepare a mergeable PR, or ship it. PR and ship runs process visible GitHub feedback unless their delivery runtime binding opts out.

Zeroshot v8 is a hard interface cutover. The former Node.js runtime is retired; the native zeroshot executable is the product.

#Install

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

The npm package installs a verified native binary for Linux x64/arm64, macOS x64/arm64, or Windows x64. It also installs one Zeroshot skill for Codex, GitHub Copilot, and Claude Code at user scope. Native archives and checksums are attached to each canonical vX.Y.Z GitHub Release.

#The graph is the orchestration

Agent loops hidden inside prompts are difficult to inspect, reproduce, or trust. Zeroshot makes the control flow authored data: sequence, parallel review, retry paths, delivery, and exit conditions are all explicit before a run starts.

The built-in software-change graph:

gives the goal to a worker;
runs acceptance and code review independently and in parallel;
routes rejected evidence to a repair worker and repeats both reviews;
with delivery enabled, delivers an accepted change through Git, CI, and merge;
routes delivery conflicts back through repair and review.

No runtime agent chooses the next step. The graph is the orchestration. Every transition is bounded, and every event is written to a durable SQLite ledger.

Animated Zeroshot software-change graph: a goal moves through implementation, parallel acceptance and code review, bounded repair loops, Git delivery, and a merged result

One authored graph: implement, review, repair when evidence fails, and deliver when it passes.

Inspect the built-ins or bring your own graph:

zeroshot template list
zeroshot template show software-change

#One CLI, three environments

The graph and runtime plan stay the same. Only the target changes.

#Local: use your subscriptions

Run directly in your Git workspace. Local mode reuses an existing Codex or Claude Code login, including subscription-backed sessions; explicit provider credentials can be bound instead.

zeroshot run \
  --title "Add JSON output with tests" \
  --template software-change \
  --ship \
  --input ./input.json \
  --runtime-config ./runtime.json

Run zeroshot ui to edit profiles and inspect live or completed runs in your browser. Open http://127.0.0.1:4173/ui/. It shares the CLI's saved profiles and history; Ctrl-C stops the UI server while runs continue. See UI setup.

#Self-hosted: run the Docker target

Keep execution and durable state on infrastructure you control. The target image includes the native engine plus pinned Codex, Claude, and GitHub Copilot harness CLIs.

docker run --detach --restart unless-stopped --name zeroshot-target \
  -p 127.0.0.1:8080:8080 \
  -v zeroshot-data:/var/lib/zeroshot \
  ghcr.io/the-open-engine/zeroshot-target:latest

zeroshot target add local --url http://127.0.0.1:8080 --direct

The target also serves its profile editor and run viewer at http://127.0.0.1:8080/ui/.

See the target image guide for persistent storage, network isolation, builds, and HTTPS.

#Zeroshot Cloud: close the laptop

Use the built-in cloud target at https://api.cloud.zeroshot.sh for a shared team queue and durable run history:

zeroshot target login cloud

Open the printed link to sign in with the device code already filled in. Use --target cloud when submitting runs.

#Reference

#Development

npm ci
npm run check
cargo test --workspace # Unix; Windows: powershell -NoProfile -File scripts/test-windows.ps1

Node.js builds the static UI and supports repository tooling and npm delivery; Rust serves the UI. See UI development, CONTRIBUTING.md, PUBLISHING.md, and SECURITY.md.

#License

MIT. See LICENSE.