Run it yourself.
Source-available core. The pipeline is yours to operate, audit, and extend once you have access.
- Full pipeline source
- Postgres state machine
- Community Discord
- Self-managed upgrades
Autonomous development pipeline
Your backlog, shipped. Every dollar and decision on record.
Nine specialized agents plus Code Map take issues from intake to a merged pull request — with a per-issue cost ledger, a full audit trail, and your branch protection intact. We run it on ourselves, and publish the receipts.
Last 30 days on Colony’s own development: 2,787 PRs merged · $2.06 median cost per PR · 83m median intake-to-merge. Live ledger
Most engineering work is orchestration, not authorship.
Built by Colony, on Colony · last 30 days
The pipeline that ships this site, ledgered. Numbers refresh from the Cloud audit trail.
2,787
Pull requests merged
across the Colony pipeline
83m
Median intake-to-merge
non-trivial issues
$2.06
Median cost per merged PR
tokens + workers, attributed
The field
Agents are powerful. Production is where they fall over.
Four failure modes the demo never shows. They compound. They get worse with scale.
Demos are not production.
Sandboxed agents ship code that fails on the third pull request — flaky containers, fabricated evidence in review, subprocess hangs that burn cost in silence.
You can’t see what it cost.
Without per-issue cost attribution and an audit trail, “the AI agents shipped these PRs” turns into a CFO question with no defensible answer.
“Merged” is not “shipped.”
Required reviews, branch protection, the cultural norm of not bypassing the human gate — merge discipline does not survive autonomy by default. It has to be engineered in.
The long tail kills demos.
Review-loop exhaustion. Fabricated test runs. Subprocess hangs. Cost-cap escapes. Eight categories of failure catalogued from running our own pipeline — each one encoded as recovery logic before it ships. Read the catalogue
The mechanism
A pipeline that behaves like infrastructure.
Not a copilot, not a task runner.
A resident orchestration layer with a state machine, a ledger, and an audit trail. Issues come in. Merged pull requests come out. Every decision in between is recorded.
State machine.
Thirteen states from intake through monitoring. Postgres is the source of truth; GitHub labels are a projection of it, not the other way around.
Per-issue cost ledger.
Every prompt, every tool call, every dollar attributed to the issue, the agent, and the tenant. Defensible spend, by construction: when someone asks why AI spend is what it is, the answer is in the ledger.
Full audit trail.
Every prompt, every response, every state transition retained for the lifetime of the issue. Not a log file — a record. 2,500+ pull requests merged all-time on Colony’s own development, every one on record.
Engineered.
Inspector agent enforces evidence requirements. Marshal agent respects branch protection. The human-defined gate stays human-defined. Your engineering standards survive autonomy. Governance
A claim we can audit
Colony builds Colony.
We don’t ship a demo and run our own development on something else. Colony’s pipeline does Colony’s engineering — issues filed, picked up by the Mayor, surveyed, drafted, built, inspected, merged. Same agents you’d run.
What you’re looking at on this site was shipped by it. The audit trail is open to pilot teams.
Read the case study Deployment
Self-host the core, or let us run it.
Three modes — no lock-in, the pipeline is the same. Your code stays where it is. See the full comparison
Let us operate.
Managed tenancy today. Hybrid tenancy is in private preview, available by arrangement for teams with stricter data residency. Per-tenant ledger and audit, your dashboard, your branch protection.
- Managed worker pools
- Per-tenant audit trail
- Per-tenant cost ledger
- Pilot in two weeks
Outcomes, white-glove.
You supply the requirements; we deliver the code. A managed engagement where Colony’s team and pipeline operate against your backlog, with weekly delivery cadence and no operational lift on your side.
- Requirements intake & refinement
- Weekly PR delivery cadence
- Same cost ledger, your visibility
- Scoped per engagement
Questions worth answering
Things you’re probably wondering.
Is this just a wrapper around GitHub Copilot / Claude Code / Cursor?
Colony is the orchestration layer. It picks issues out of a backlog, decides what work to take, runs analysis and planning before code is written, executes the implementation, reviews the result against your conventions, and merges it through your branch protection. The model that drives the developer agent is swappable — Claude, GPT, or whatever your enterprise procurement has already approved. The orchestration is the product; the model is a dependency.
Does this replace developers?
Colony expands your team; it does not replace it. The right question isn’t “how many developers can we eliminate” — it’s “what can this team accomplish with the pipeline’s capacity added to its own.”
In practice, teams that deploy Colony successfully don’t reduce headcount. They redirect developer capacity toward work that requires human judgment — architecture, technical strategy, complex problem-solving, exploratory and creative work that Colony handles poorly. Teams that try to use Colony to justify headcount reduction typically see quality degrade as the human review layer thins.
What stops the agents from doing something we don’t want?
Three configurable controls: per-issue cost caps that escalate to a human when an issue exceeds budget; an auto-merge switch that is off by default, per repository; and human-review-required labels that route any matching issue through mandatory human review. Start conservative and loosen as the escape rate proves out.
The Inspector agent enforces evidence requirements — tests must run, conventions must hold, the diff must justify itself. The Marshal agent respects branch protection: required reviews, status checks, code-owner approvals. Nothing reaches main without crossing the gate you configured.
Where does our source code actually run?
Three options. Colony Cloud: managed worker pools in our infrastructure, single-tenant per customer. Hybrid tenancy (recommended for enterprise): the orchestration engine runs in our cloud, but the agent workers that read and write your code run inside your own cloud — your AWS, your Azure AI Foundry instance, your existing model contracts. Source code never transits Colony’s managed infrastructure. Self-hosted: run the whole thing yourself.
Either way, we don’t train on your code. Security & trust has the long version.
Who is already running this?
Colony is in production with an enterprise customer, and runs Colony’s own development — receipts public at /built-by-colony/.
Pilot-specific questions — week one, measurement, loose specs — live on the pilot page. Conventions on governance. Audit and compliance on security & trust. The rest, grouped by audience, is in the full FAQ.
Most engineering work is orchestration. We should talk about yours.
Colony Software, Inc. · Source available