Cerberus Forge / in development

A coding agent that works unattended, and proves what it did.

Tell it what to do and what it's allowed to touch. It works on your machine, runs the tests, keeps a note of everything it tried (and what each try cost), and knocks when it's stuck. Then you look at the record and decide what actually merges.

Interactive prototypeCerberus Forge

Build status

Ledger events, evidence, budgets · shippedIndependent verifier runs the tests · shippedResident worker loop on the drawing boardUnattended dispatcher next upCost settlement not yet

Watch a session, sped up. Twenty seconds, two example tasks. One of them fails along the way.

idle

Fix the inventory cache keyqueued

Check inventory performancequeued

Budget spent (example)$0.00 of $0.40 held

6 hours max runtime4 attempts per task3 folders allowed$0.40 budget held18 tests before review

How it works

Three steps

There's nothing to babysit here. You set the job and the ground rules, it gets on with the work, and you look at the result whenever you feel like it.

Set the task and its limits

Say what you want in plain words. Then fence it in — these folders, this many hours, at most this much money.

Those fences hold. If it wants more room, it has to come and ask.

It keeps working

Then it works. Writes code, runs the tests, reads what failed, has another go. If the job takes four hours, it works for four hours. Every attempt lands in the log, the embarrassing ones included.

And when it's stuck? It stops. Writes down why. It doesn't improvise.

Two attempts on one taskattempt 1 17 of 18 tests passed · one failure recordedattempt 2 18 of 18 tests passed · change saved as c9a41e2

You check the record, then decide

What it made shows up in one queue, with the test results next to it and the bill attached. If something was never checked, it says so right there. Your call — yes or no.

One more thing. Your yes only covers the exact version you were reading. Change a line afterwards and the decision is void.

src/inventory/cache.js · the line that mattered- return this.tiles[id];+ return this.tiles[String(id).trim()];18 of 18 tests passed before you saw this.

Compare tools

How it compares

Let's be honest about the competition. Every AI coding tool writes decent code these days. The differences show up later, when you ask a simple question: did it actually work, and what did it cost you.

Same table, two levels of detail.

What you care about

Popular AI assistants

Cerberus Forge

Writes code for you

Yes

Works unattended, on your machine

Cloud agents do; local ones don't

Yes, inside limits you set

You set the rules it works under

Not really

Folders, time, budget, agreed up front

You see what was actually tested

Their summary of it

Every test result, saved and tied to the version

Anything checks the work before you do

You review whatever it hands you

A separate program checks it first

Where the work and records live

Usually their cloud

On your machine*

You know what it cost

A receipt somewhere

Every call is written down

*One caveat that hits every AI coding tool, ours included. The agent has to send your code's context to whichever model provider it uses. Everything else stays on your machine — the limits, the attempts, the test results.

Why it matters

What you get out of it

The practical difference, day to day.

Work that keeps moving

The boring backlog shrinks while you do something more interesting. It stays inside the fences you set.

You don't have to take its word for anything

A separate program re-ran the tests before the change ever reached you. Whatever nobody has checked yet is listed in plain sight.

Costs you can see coming

You set a budget up front. When the money runs out, it stops. And the bill holds no surprises, because every model call was written down.

Your work stays on your machine

Forge runs on your machine. Every attempt, result and receipt sits on your own disk. The one thing that leaves is the code context your chosen model provider needs, same as any AI coding tool.

Trust, in writing

What Forge won't do

Tools should state their limits. Here are ours.

It won't run your repo unsupervised

You set the task, the limits and the budget. Forge cannot loosen its own leash, and it never marks its own homework.

It won't merge quietly

Green tests are not a merge. A merge needs a person who looked at that exact version and said yes.

It won't pretend everything worked

When it isn't sure, it writes down the word unknown. The gaps sit next to the results, where you can see them.

It isn't a cloud service

There is no cloud. Your repo and every record of the work stay on your hardware. No account to create, no phone-home.

The two of us

Why we’re building this

We are two people and one shared frustration. Every agent we tried could write code, and every one of them would swear it had finished the job. Half the time it hadn’t. Checking its work took longer than doing the task ourselves, and the truth got lost somewhere in the chat log.

So we stopped asking agents to be trustworthy and started building one that doesn’t have to be. Forge can’t approve its own work. It can’t widen its own limits, and it can’t spend past the budget you set. Everything it did, and everything it never checked, lands in a ledger you can read. Trust stops being a feeling and becomes a record.

We’re building this the slow way, because it’s the tool we want on our own machines.

— the two of us at Hound Foundry, and one very patient dog

Interactive demo · example dataCerberus Forge control room

Work session / project Atlas

This session’s work

Example session · two assigned tasks · you approve before anything merges

The task

agreed up front

approved brief

“Speed up the inventory screen. Do not change the public API.”

Allowed foldersOnly src/inventory · tests/inventory · docs/performance

approved

Limits6 hours · 4 attempts · no dependency changes

agreed

Before changes mergeNothing merges on its own. A person reads the change and makes the call.

review needed

Progress

Last checkpoint saved at 16:39:52

2 tasks

1

Plan approved

Two tasks agreed — fix the cache, then check performance.

2

Cache fix done

Tests pass. The change sits in the review queue.

3

Performance check stuck

It's missing test data, so it stopped and told you. Guessing wasn't an option.

4

Progress saved

A checkpoint records both tasks and the change waiting for you.

Interactive demo · example dataCerberus Forge control room

Review queue / 1 item

One change needs your yes

What changed, what was tested. Your yes covers what's on this screen, nothing else.

Inventory cache key fixversion c9a41e2 · built on 61b2f0a · 4 files changedwork finished · tests passed · not merged

needs review

What was tested18 of 18 tests passed · lint passed · changes and recovery files saved

What nobody tested yetFaster in a local test. Untested against live traffic.

needs follow-up

What has happened so far

Three steps, in order.

not accepted

FinishedThe worker saved the change it wants merged.

yes

CheckedA second program ran the tests on exactly this version.

yes

AcceptedThat last step is you, and only you. Nothing can say yes to c9a41e2 in your place.

pending

This afternoon

How the change got to your queue.

16:32

Change savedcommit and file changes are on disk

recorded

16:35

Tests ran18 tests and lint, all green

checked

16:39

Waiting for younothing merged, nothing published

waiting

Interactive demo · example dataCerberus Forge control room

Evidence / example session

The session, from the inside

What ran, what waited, and why one task needed a second try.

Session summary

These are example figures.

demo

1 change ready to reviewThe cache fix is saved as version c9a41e2.

pending

1 task needed a second tryA failing test told it what to fix. That's the loop doing its job.

recorded

1 task is waitingThe performance check needs test data before it can continue.

waiting

Model comparison

Not enough finished work to judge yet.

too early

Which model is best for this kind of work? Honestly, we don't know yet.

Once enough work has been reviewed here, this panel will compare models on accepted changes, defects, review time and cost.

Work history

Every attempt and checkpoint, in order.

16:39:52

Progress saved2 tasks tracked · 1 change waiting for review

recorded

16:35:10

Tests ranversion c9a41e2 · 18 tests and lint passed

checked

16:32:18

Worker finishedcache fix and test results saved

recorded

Set the fences. Let it work. Come back to finished work with the proof attached.

Kick the tyres. Read the promises. Then tell us what it would take for you to trust this thing on your own repo — we really want to know.

Hound Foundry

Two people, one forge. We build Cerberus Forge because we wanted it.