Agents write the code. Someone still has to answer for it.

The AI-native SDLC, enforced

The published playbooks for agentic development converge on the same shape: six stages, each ending by committing an artifact the next stage reads — the intent, the spec, the plan, the diff, the review findings, the incident record. That discipline is right, and it is held together by convention, inside the same tool that wrote the code. A convention does not bind automation. ADP is the layer where the chain becomes a constraint: typed, signed, and checked where changes are admitted.

Your repository does not move

Companion mode. Your issues, branches, pull requests and Actions stay exactly where they are, and ADP fills its record as you work — no migration, no second place to look, and nothing about the day changes. The loop below is on GitHub, and none of it is an ADP command.

# your usual loop, on github.com, unchanged
gh issue create --title "Rate limiter drops bursts"
git switch -c fix/rate-limiter
git push origin fix/rate-limiter
gh pr create --fill  # your Actions run on GitHub's runners, as before
gh pr merge --squash

And two checks appear on the pull request

Where the work already is, rather than in a console somebody has to remember to open.

GitHub stays the merge authority. Publishing a verdict GitHub already knows how to require is the same enforcement with none of the migration — so ADP refuses to merge an ingested pull request itself, and says why. Choosing between two merge planes is the thing companion mode exists to avoid.

Every change carries its proof

Git records what changed and discards why and whether anyone checked. ADP records a change as a signed transaction, and the merge is gated on it.

Where that sits

Two planes over one domain model, with the gate between them. Above it, tools that cannot tell ADP from GitHub; below it, your runner, your delivery stack, and the repository you did not move.

The record outlives the session

Verification is the bottleneck — and it is not the finish line. Past review sit deployment and operations, and that is where the failures are. Machine-written code passes review looking better than the code a human wrote — and introduces roughly 1.7× more critical runtime issues once it ships. Four in five teams surveyed had suffered a major production failure caused by AI code in the previous six months, and one of the four leading causes was the audit trail itself going missing.

ADP does not deploy your software and does not watch your metrics. It makes the change that broke production identifiable, attributable and reversible — because the record was written in the same transaction as the change, rather than reconstructed afterwards from a session transcript that no longer exists.

And the record is portable, whichever agent wrote it. Every harness ships its own checkpoints, session store and memory files; run three and you hold three incomplete audit trails, none of which the next harness can read, and none of which outlives the vendor that wrote it. ADP records the intent, the harness, the model and the session on the change itself, in a published, versioned, MIT-licensed wire format — so work started in one agent can be reviewed, reverted or continued in another, and an auditor gets one answer instead of three. The precedent is OpenTelemetry: its win was not making tools talk to each other but standardising the record, so any backend could read all of them. Version control is one layer below, with the same problem and no such standard yet.

That is built, not planned, and make demo ends on it: one task is started under Claude Code, stops mid-work, and is picked up by Codex — one continuous signed history, with nothing calling checkpoint or resume by hand. The recording happens out of band, by reading the event stream each harness already writes, so it costs the agent nothing and needs no cooperation from the vendor: a reader is about two hundred lines, and harness stays a string the server never branches on. One command per harness connects a repository — adp connect claude-code — and then proves it worked by opening and closing a real session.

Production-failure figures: New Relic, The 2026 State of AI Coding Report — Hanover Research, 200 US technology decision-makers, June 2026.

What that buys you

Working today

The wire contract is published and versioned, served as ADP-API-Version on every response, with the spec, the image and the git tag moving together. See what a version bump promises.

Try it

One command starts a throwaway ADP against an ephemeral PostgreSQL, then uses ordinary git and an unmodified gh to clone, push, propose, gate and land a change — narrating each step. It ends where the point is: the merge is refused while the change has no gate result and no approval, and allowed once it does. Then you read the signed evidence bundle and the operation log that record why.

git clone https://github.com/DeDuva/adp.git && cd adp
make demo

Needs Docker and Node 22. Nothing is installed, no account is created, and it all tears down when you press Enter. About a minute, most of it the first npm ci.