ADP is a self-hosted, GitHub-compatible forge for AI coding agents.
Keep using git, gh and your existing CI, while ADP binds every change to
its intent, agent provenance, approvals and signed verification evidence — and refuses to land
changes that do not meet your requirements.
An agent saying “tests pass” is not proof. ADP converts that belief into evidence, and keeps the four answers production asks of every change: what was it for, what produced it, how was it verified, and can it be reversed without losing the reasoning — per change, in any harness, years later.
MIT · self-hosted · TypeScript · PostgreSQL · the real git binary
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.
| The stage commits | ADP binds it as |
|---|---|
| An intent, written down before the work | A typed intent the change record references, resolved from an ordinary git push |
| The spec and the plan that followed it | Artifacts carried on the change, versioned with it rather than beside it |
| The diff | Ordinary git objects — git clone keeps working |
| The review findings | Gate results, each linked to a signed evidence bundle bound to the state that ships |
| The approval | A land policy — instance ∧ organization ∧ repository — that no agent can bypass |
| The incident record | An operation-log entry with guarded undo, written in the same transaction as the change |
ADP speaks git's wire protocol and a compatible subset of GitHub's REST and GraphQL APIs. An unmodified agent clones, reads an issue, pushes, opens a proposal, watches checks, and merges — without knowing ADP exists.
# the same commands, pointed at your own instance git clone https://adp.example.com/acme/service.git gh issue view 41 gh pr create --fill gh pr checks # gate results, each linked to a signed evidence bundle gh pr merge
Validated in CI against the real,
unmodified gh binary — not a mock, and not a claim of full parity.
Mirror mode lets ADP sit alongside a repository that stays on GitHub, so adopting it is not a migration.
Helm chart or Docker Compose. Your data, your policy, your keys — no account to create.
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.
adp.yaml. A change that cannot show the evidence does not
land — and the refusal is recorded too.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.
An append-only operation log, written in the same database transaction as the change it describes — so there is no state in which the change landed and the record of it did not.
The intent, the harness, the model and the session are fields on the change record, not a transcript inside a tool you may no longer run.
Checkpoints and guarded undo are first-class operations, and the rollback goes on the record the same way the change did.
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.
Planning, context, model quality, when to fan out — that is where a coding agent earns its place, and where vendors should compete furiously.
Workspaces, history, the operation log, the evidence graph, signed identity. No harness should be able to compete on owning your history.
Production-failure figures: New Relic, The 2026 State of AI Coding Report — Hanover Research, 200 US technology decision-makers, June 2026.
| Instead of | You get |
|---|---|
| A transcript in one vendor's format, gone when the session ends | Intent, harness, model and session recorded on the change itself |
| CI output that scrolls away | A signed attestation bound to the change, verifiable later by anyone |
| An agent that decides for itself when the work is done | Merge-time requirements the agent cannot satisfy by editing its own tests |
| “Who changed this, and did anyone check?” | An append-only operation log, written in the same transaction as the change |
| A rollback that loses the reasoning | Checkpoints, sessions, workspaces and guarded undo as first-class operations |
| Capability | State |
|---|---|
Git smart-HTTP, REST and GraphQL compat, driven by unmodified gh in CI | Shipped |
| Signed change records, DSSE evidence bundles, SBOM per landed change | Shipped |
| Three-level land policy, push protection, dependency admission | Shipped |
| Operation log with guarded undo; sessions, checkpoints, workspaces, candidate sets | Shipped |
| Native plane over REST and MCP; read-only supervision UI | Shipped |
| Organizations: isolation, quotas, policy console, audit export, OIDC login | Shipped |
| Gate runner — isolated container, network denied, no host mounts | Shipped |
| Trajectory recording out of band — hash-chained, from the stream the harness already writes | Shipped |
| One task across two harnesses as one continuous signed history | Shipped |
| One-command harness connect — Claude Code, Codex, Gemini CLI | Shipped |
| Self-hosting: Helm chart and Docker Compose | Shipped |
| Dependency admission beyond npm | Partial — npm only |
| SCIM provisioning | Not built |
The wire contract is published and versioned — currently
0.6.0, 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.
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.
Helm chart or Docker Compose, with the sharp edges written down — self-hosting guide.
Why verification became the bottleneck, and what the record has to carry once it isn't — Why ADP exists, or the six SDLC stages one by one.
The contract is published as OpenAPI, with a conformance suite — spec/.