Menu
View on GitHubGitHub

When agents write the code, trust is the scarce thing.

05 is the acceptance layer for AI-written code. The agent declares what it will do before it starts; 05 seals that plan, checks the result on the exact code and signs the evidence. When it all matched, you approve, it lands as a commit and you push. No pull request to review. When something did not match, you read one page instead of the diff. And when several agents work in one repository, 05 keeps them out of each other's way.

View on GitHub How it works

Open source: the core, the local CLI and the portable runner, is Apache-2.0 at github.com/use05-dev/use05.

Terminal output. use05 prove runs ./test.sh on staged files and reports Proved with the tree hash, 10 ms duration, a receipt reference and the signing key, plus a note that a receipt made on this machine is advisory. use05 verify then reports Valid: the signature checks out and the tree matches the index.

From reading every line to accepting evidence

When an agent can write a change in minutes, reading it line by line stops being a plan. What scales is stating what you want up front, and accepting a change on proof.

Before: trust me

  • Read every line the agent wrote.
  • Take "tests pass" on the agent's word.
  • Ask the agent nicely to follow the rules.
  • Review time becomes the bottleneck.

After: with 05

  • State the intent first, as a card or inferred.
  • Accept a signed receipt from a run on the exact tree.
  • Check the actual diff against the declared plan.
  • Approve on one page, then land and push. No pull request needed.

Every change carries independent, signed evidence instead of "trust me, tests pass."

Agents write code faster than people can review it

Review is the bottleneck

Agents produce changes faster than anyone can read them. Reading every line does not scale.

"Tests pass" is an assertion

When an agent says its tests pass, that is a claim. Until something independent runs the checks on the exact tree, it is not a fact.

Prompting is not a control

Telling an agent the rules is an administrative control. It is not an engineering control: nothing stops the change when the rules are broken.

You own the request and the acceptance. Agents own the plan and the work. 05 holds them to the plan.

One change, start to finish. The step-by-step page explains each stage.

How a change moves through 05 Seven steps left to right. A person asks and the agent declares its plan, which 05 seals. Agents work, watched by advisory hooks. The runner proves the checks on the exact git tree and signs a receipt. A drift check compares intent to the actual diff. A one-page brief is produced. A human approves with a passphrase-signed approval. The change lands as a commit and is pushed; a CI required check enforces it, and the pre-push gate is advisory. A dashed side path shows a logged break-glass bypass from the brief to the landing. Humans own the request and the acceptance; agents own the plan and the work. HUMANS OWNTHE REQUEST AGENTS OWN THE PLAN AND THE WORK05 HOLDS THEM TO THE PLAN HUMANS OWNTHE ACCEPTANCE HUMAN 1 Human asks,agent plans The plan issealed beforethe first edit. AGENT 2 Agentswork Claude Code,Codex, others.Hooks watch(advisory). 05 RUNNER 3 Runner provesand signs Runs checks onthe exact tree,signs a receipt. 05 CHECK 4 Driftcheck Compares intentto the actualdiff. No AIjudges a gate. 05 BRIEF 5 One-pagebrief Intent, outcome,evidence, drift,unknowns, howto undo. HUMAN 6 Humanapproves Signed with apassphrase-protected key. GIT HOST 7 Landand push CI requiredcheck enforces.Pre-push gateis advisory. Break-glass bypass (logged) Human step Agent step 05: local CLI and portable runner Git host: a thin, replaceable enforcement adapter How a change moves through 05 Seven steps top to bottom. A person asks and the agent declares its plan, which 05 seals. Agents work, watched by advisory hooks. The runner proves the checks on the exact git tree and signs a receipt. A drift check compares intent to the actual diff. A one-page brief is produced. A human approves with a passphrase-signed approval. The Git host enforces the merge. A dashed side path shows a logged break-glass bypass from the brief to the landing. Humans own the request and the acceptance; agents own the plan and the work. HUMANS OWN THE REQUEST AGENTS OWN THE PLAN AND THE WORK HUMANS OWN THE ACCEPTANCE 1 HUMAN Human asks, agent plans The agent declares its plan; 05seals it before the first edit. 2 AGENT Agents work Claude Code, Codex, or any other agent.Hooks watch, and say they are advisory. 3 05 RUNNER Runner proves and signs Runs the checks on the exact git treeand signs the result as a receipt. 4 05 CHECK Drift check Compares intent to the actual diff.Deterministic: no AI judges a gate. 5 05 BRIEF One-page brief Intent, outcome, evidence, drift,unknowns, and how to undo it. 6 HUMAN Human approves Approval signed with apassphrase-protected key. 7 GIT HOST Land and push A CI required check enforces it;the pre-push gate is advisory. Break-glass bypass (logged) Human step Agent step 05: local CLI and portable runner Git host: replaceable enforcement adapter

Acceptance for agent-written changes, in six parts

Free, local

A command line tool that stays on your machine

The use05 CLI is free and open source. It runs entirely on the developer's machine: no account, no telemetry, nothing leaves it.

Privacy
Evidence

Signed receipts anyone can verify

A portable runner runs checks on an exact git tree and signs the result: a DSSE envelope with in-toto-style statements, Ed25519. Verify it offline.

How receipts work
Intent

Intent first, drift checked

An agent declares its plan and scope through its hooks, or you run use05 start --scope. Deterministic checks compare the actual diff to that scope; with no scope declared, 05 says scope drift could not be checked. No AI judges a gate.

See the steps
Review

One page for the reviewer

A single brief a person reads instead of the diff, in minutes. When everything matched, it says there is nothing to read.

What the brief contains
Policy

Rules that only get tighter

A policy file in the repo, plus a signed organisation floor that teams can tighten but never loosen. Folders and files can be locked, append-only, no-delete or do-not-read. Human approvals are signed with a passphrase-protected key. Bypasses are logged.

Locked folders and file rules
Gates

Hooks, a pre-push gate and CI

Hooks for Claude Code and Codex, a git pre-push gate, and a CI template. Each one says how strongly it is enforced.

05 with Claude Code and Codex

What the command line tool actually prints

These are screenshots from the current build, not mockups: real output from the use05 binary on a demo repository. Note how often it says advisory. 05 tells you how strong its own controls are.

  1. Terminal output. use05 prove runs ./test.sh on staged files and reports Proved with the tree hash, 10 ms duration, a receipt reference and the signing key, plus a note that a receipt made on this machine is advisory. use05 verify then reports Valid: the signature checks out and the tree matches the index.
    Prove, then verify. use05 prove runs a check on the exact tree and signs a receipt. use05 verify checks it offline, with no account and no network.
  2. Terminal output. use05 prove records that ./fail.sh failed with exit 1 and says the receipt says so, showing the last line of output. use05 verify then reports a valid receipt whose recorded check did not pass, and the command exits with code 2.
    Failures are evidence too. A failing check is recorded in a valid receipt, and use05 verify says plainly that the check did not pass.
  3. Terminal output. use05 init reports seven changes: a policy file proposing the test check, a .gitignore for agents' unsealed declarations, a signing key for this machine, Claude Code hooks with permission for the agent to run start, prove, finish, brief and land, Codex hooks, a git pre-push hook, and a block added to AGENTS.md. It then lists what is not covered: no approver key yet and no merge enforcement.
    Set up in one command. use05 init says exactly what it changed, what it did not touch, and what is therefore not covered. use05 uninstall reverses it.
  4. Terminal output of the bare use05 command. The task is Stop retrying failed charges forever, started at this machine (unverified), with the intent card written but not approved; three files are staged and approval is required. Agent hooks are on, the pre-push hook is on and advisory, the CI gate is off. A numbered menu follows.
    Bare use05 shows where you stand. The task, whether the staged change would be allowed, and which controls are on, with a short menu on a terminal. Piped, it prints and exits.
  5. Terminal output of use05 brief. Intent: cap retries at three, scope src/billing, risk high because of a migration and money code. Outcome: three files changed, two outside scope, including a migration and package.json. Evidence: the test check has not been run. Drift: a protected path changed, scope exceeded, dependency files changed, and the claim All tests pass is unsupported. Decision: approval required, two things hold the change back.
    The brief is what a person reads instead of the diff. Intent, outcome, evidence, drift, claims, approvals, unknowns and how to undo it, then one decision with the reasons.
  6. Terminal output of use05 brief on an agent's branch. The task Add the support address to receipts has scope src/receipts and low risk. One file changed, the test check passed, nothing differs from the intent, and the verdict is ALLOW, nothing to read.
    When it all matched, there is nothing to read. The change stayed inside its declared scope and its checks passed on the exact tree, so the brief says so in one line.
  7. Terminal output of use05 land. It lands claude/receipt-footer on main as a fast-forward, removes the agent's worktree and deletes the branch, then suggests pushing main.
    Land it, and nothing is left behind. use05 land moves an allowed change into its target branch, then removes the agent's finished branch and worktree.
  8. Terminal output of git push. 05 first proves the missing test check for the pushed commit, then stops the push: approval required, because a protected file changed. Break glass is logged. It states that git push --no-verify skips the hook and that branch protection can stop that.
    A push the gate does not allow. The pre-push hook stops it, names the rule and what to do next, and says plainly that --no-verify skips an advisory hook.
  9. Terminal output. use05 prove passes the test check. use05 approve shows what is being approved, three files, risk high, three findings, and that the approval is bound to this exact content and expires in seven days. The brief now ends with ALLOW, read the notes: two files outside the declared scope and a dependency change.
    A person approves, with a passphrase an agent does not have. The approval is signed, bound to this exact content, and expires. The brief then says allow.
  10. Terminal output. A Claude Code PreToolUse hook payload that edits .05/policy.toml is answered with a deny decision: the file is protected and a person must approve the intent first.
    An agent that edits the rules is stopped. Hooks deny risky commands and protected paths, and tell the agent to ask a person. They are advisory, and fail open if 05 itself breaks.
  11. Terminal output of use05 doctor. Setup, keys, controls and record sections with check marks. Agent hooks and the pre-push hook are on and described as advisory, the approver key is passphrase protected, and the CI gate is missing with a note that without it nothing is stronger than advisory.
    Doctor is honest about how strong each control is. Hooks and the pre-push gate are advisory. Without a CI check nothing here is stronger than advisory, and it says so.
  • ≈ 8 ms added to each agent tool call by 05's hooks, measured on a repository of 3,000 files.

Measured on the current release build, in a dev container. Your machine will differ. More measurements are on the receipts page.

Enforcement is only as strong as where it runs. We say which is which.

Hooks, the pre-push gate and receipts made on your machine are advisory, because an agent running as you can reach them. A CI required check, with evidence signed where the agent can't reach, is what enforces. See where each control lives, and how strong it is.

The core is free. A product for teams is launching soon.

There is no pricing yet.

Free, local core

For one developer

  • The use05 CLI, the portable runner and the receipt format.
  • Policy, a signed organisation floor, and folder and file rules.
  • Open source under Apache-2.0.
On our roadmap

05 for teams

  • A simple web layer for managing how your team works in its code.
  • Shared policy and an approval inbox.
  • Audit history and SSO.
  • Handles metadata only, never your code.

Several agents, one codebase, no collisions

Run as many agents as you like. 05 keeps them orchestrated, so they do not overwrite each other's work. How it keeps them apart.

Each claims an area

An agent declares where it will work before it starts. That area is reserved for it.

The others are told

An agent planning or editing inside another's area is told who holds it and why, at the plan and at every edit. Policy can make it ask a person, or refuse.

Each lands on its own

Every agent works on its own branch and worktree. A change lands only as a fast-forward of what was checked, then its branch and worktree are cleaned up.

Your agents, your Git host

Claude Code and Codex

The first two agents, through hooks that watch the session. Details.

Any other agent

Through a generic hook, and the git pre-push gate and CI template, which do not care who wrote the change.

GitHub first

The core is host-agnostic. Git hosts are thin, replaceable enforcement adapters, and 05 does not try to become one.

Straight answers

More on the FAQ page.

Do I still need pull requests?

No. Approve, run use05 land and push; pull requests still work if your team wants them.

Does 05 use an AI to judge my code?

No. Gates are deterministic: fixed rules compare the declared plan to the diff and check signed evidence.

What happens if 05 itself breaks?

It fails open, loudly: the failure is shown to you, never hidden as a pass.

Try 05 on your own repositories

The source, install steps and docs are on GitHub. Questions, or want to tell us which agent and Git host you use? Email us. No forms, no cookies.

View on GitHub [email protected]