Plan. Build. Test. Review.
On your own hardware.

Delegatron turns a plain-language request into tested, reviewed code, using whichever models you choose — on your own GPU or in the cloud.

Read the source Open source · AGPL-3.0 · v0.3 · published as-is
Delegatron dashboard: a zero-cloud report showing five events, all to localhost, none to the cloud.

Any model, any role

Anthropic, OpenAI, Google, or any OpenAI-compatible endpoint such as Ollama.

Tested before it's trusted

Every patch runs in a Docker sandbox before a reviewer looks at it.

Stays on your machine

Each run records every network destination it touched.

Ask one AI model to write code and it will tell you the code works. Delegatron makes models check each other's work before you ever see it.

One model plans, another writes, a sandbox runs the tests and a third reviews — around again until it passes or the budget runs out.

All of it can run on a single 12 GB graphics card, with nothing leaving the building.

Four roles, one loop,
clear rules.

The agents never chat with each other. They hand over checked documents — a plan, a patch, a test report, a review — and only the orchestrator touches your repository or runs code.

A model for every role

Mix and match per role. The local preset above fits on one 12 GB GPU; swap in Claude, GPT or Gemini wherever you like.

Hard limits, always on

Iterations, spend and time are capped by the orchestrator, not left to the model.

Every iteration on the record

Tests, verdicts and cost for every pass, saved to disk so a run can be resumed or retried.

CLI, API or dashboard

The same pipeline from a terminal, a REST API with live event streams, or a web dashboard. Each run works on its own git branch.

Security checks on every patch

Leaked secrets, new dependencies and imports that won't resolve are caught before a patch is accepted.

Evidence settles arguments

When agents disagree, the stronger evidence wins. If the same disagreement keeps coming back, a director makes one binding call.

Why it exists, and why it's open.

Delegatron started in April 2026 with one question: could ordinary local models — the kind that fit on a single gaming GPU — write code you could actually rely on, if they had to check each other's work?

A single model asked to write code will cheerfully say it's done. So Delegatron splits the job the way a small team would. An architect writes the plan and the acceptance criteria. An implementer writes the code. A sandbox runs the tests — the one opinion nobody can argue with. A reviewer reads the change and the evidence, then decides. When something fails, the loop goes around again with a clean slate and the failure in hand.

Most of it was built in one intense month by a single developer at StoriaBrevi, much of it pair-programmed with an AI coding assistant — which felt right for a tool about delegating work to AI. It was revisited in the autumn to bring it up to date with newer models.

It began as a possible product. In the end we decided it's more useful as an open, readable example of how a careful multi-agent pipeline fits together: the state machine, the evidence rules, the sandboxing and the budget limits. So it's published under the AGPL-3.0 — anyone can read it, run it and learn from it, and anything built on it as a network service has to stay open too.

Apr 2026first commit
393commits before release
40klines of Python
4,250+automated tests
1developer
12 GBGPU it was tuned on

See exactly
what happened.

The dashboard streams each run live. Every plan, patch, test report and review is kept, so nothing is a black box.

Run detail: seven iterations with test results, review verdicts and cost per iteration.

Screens from a real run on local models — phi4 and qwen2.5-coder 14B with a Docker sandbox. That run stalled after seven iterations, and the dashboard shows exactly why.

What it's good at,
and what it isn't.

Numbers from recorded runs. Local costs are electricity and hardware wear, estimated from GPU power draw.

Recorded end-to-end runs
TaskModelsResultCost
FastAPI CRUD service with SQLiteClaude Sonnet13/13 tests, approved$0.10
Express API with JestClaude Sonnet12/12 tests, approved$0.08
React counter with VitestLocal2/2 tests, approved$0.0062
Rust libraryLocal4/4 tests, approved$0.0054
Three-module projectLocal12/12 tests, approved$0.0057
Chess engine with GUIClaude Sonnetstalled at 40/41$0.43
Real GitHub issues (SWE-bench)Local0 of 11 resolved—

It can

  • Write new modules, services, CLI tools and their tests from a description
  • Run entirely on local models through Ollama, on cloud APIs, or a mix per role
  • Test every patch in Docker for six languages
  • Review an existing repository or log files, read-only
  • Split a larger project into milestones and run them in order
  • Resume, retry or refine a run, and open a GitHub pull request when one is approved

It can't

  • Reliably fix bugs in large existing codebases — tools with long exploration loops are better at that
  • Explore open-endedly; it works in a few short iterations per task by design
  • Guarantee that generated code is correct or secure — a person still has to review it
  • Isolate code safely without Docker or E2B; its local mode runs code directly on your machine
  • Be used as a hosted service — there isn't one

Good for

  • Prototypes, hackathon scaffolding and boilerplate
  • Generating a test suite for code you already have
  • Comparing models on the same task with the built-in benchmark
  • Experiments on networks where code can't leave the building
  • Learning how a multi-agent pipeline is put together

Built with, and works with

  • Python
  • FastAPI
  • Pydantic
  • SQLite
  • Docker
  • Next.js
  • React
  • TypeScript
  • Tailwind
  • Ollama
  • Anthropic
  • OpenAI
  • Gemini

Finished, and shared
as it stands.

Delegatron is a completed portfolio project by StoriaBrevi LLC. The code is published as-is for anyone to read and run on their own. There's no service, support, roadmap or promise of updates behind it.

Status
v0.3 — complete, not maintained
License
GNU AGPL-3.0, no warranty
Support
None, including installation help
Contributions
Issues and pull requests are not accepted