a·dapt

Can a loop of agents evolve a real product on its own?

Can a closed loop of coding agents decide what to build, what to fix, and actually evolve a live product over many cycles — with no human in the loop — and can we watch how it decides?

The human is the observer outside the loop: never an approver inside it. You don't bless a plan or sign off a fix. You watch the organism think, and you keep the receipts.

The scenario is the contract.

Truth is not the code. Not a ticket. Not the agent's memory of what it meant to do.

Truth is a real user goal paired with the visible outcome that proves it. A persona, a path, a result you can see from the outside.

Reality is the judge.

The Dreamer asks what this could become.

It reads the north-star and the current product, then proposes the next ambition: new features, raised goals, a bolder version of the thing.

"What should this product become?" This is the highest-creative-risk seat in the loop — and the engine of demand.

The Critic keeps the dreams honest.

A skeptical product owner. It challenges each dream: real value to a real user — or bloat, busywork, reward-hacking?

Only the survivors live. The pairing is deliberately adversarial so the loop can't fall in love with its own ideas.

The Generator writes the contract.

Surviving ambitions become user-centered, black-box scenarios: a persona, the steps, the expected outcome, the signals that mean failure.

Stable IDs, machine-readable success criteria. From here on, the scenario is the thing being judged — not the code that happens to implement it.

The Runner behaves like a real user.

It drives the running app in a real browser — Playwright, through the accessibility tree — and has no access to the source code.

Pass or fail is judged entirely from the outside. It captures evidence: screenshots, console errors, the exact failing step. Black-box, by design.

Triage turns chaos into clean work.

Messy failures become tracked, deduplicated work items: one root cause that breaks twenty scenarios becomes one item, not twenty.

It classifies the noise — real bug vs. flaky environment vs. bad test data — and attaches the full evidence trail.

Implementation makes the smallest safe change.

It reads the work item and the evidence, writes the minimal fix, and commits to a branch in the target repo.

It can read and write the code — but it may not close its own work. The hand that fixes is never the hand that signs off.

Only Verification can say Done.

An independent agent — separate from whoever wrote the fix — re-runs the exact original scenario against the running app.

It alone marks a thing Done, and only because reality agreed. No proof, no done.

There is no success state.

Dream → critique → generate → run → triage → fix → verify → and back to dreaming. The pulse never stops at a finish line.

Success is the continued, perpetual evolution of the product. Each role is given deliberately different knowledge and tools — a separation of powers so the loop can't approve its own mistakes.

Git is the safety net and the genome: every change is a revertible commit; the whole history of code and ambition is replayable.

Many lineages, one baseline.

Fork the same starting point into independent lanes — different strategies, different models — and let them evolve in parallel.

Each lane is its own lineage, racing from the same genome. One dashboard watches them all, side by side, to see which way of evolving wins.

Observability is first-class.

A live console streams each agent's thinking, tool calls, and decisions in real time — the organism, narrating itself.

A durable decision log makes a whole run replayable. That log is the experiment's primary deliverable: not just what changed, but why the loop decided it.