Get started with 05: from install to an enforceable gate in about five minutes

Install the command line tool, run a first task, read the brief a reviewer would read, then turn on the one control that actually enforces. Every screenshot here is real output from the tool.

1. Install

One command downloads a release for your platform, checks its SHA-256 against a published list, and refuses to install on a mismatch. It works on Linux and macOS, x86_64 and arm64, and needs git.

curl -fsSL https://use05.dev/install.sh | sh

Or with npm, which installs the same binary for your platform:

npm install -g @use05/cli

Or build it from source with Rust 1.85 or later:

git clone https://github.com/use05-dev/use05
cd use05
cargo install --path crates/cli

Upgrading

Install the new version the same way. Then run use05 init again in each repository: it updates the agent hooks an older version installed and keeps other tools' hooks.

A repository set up by 0.0.2 records [use05] min_version in its policy, so everyone working on it needs that version or newer. From 0.0.2 on, an older use05 is told to upgrade instead of failing on a rule it does not know.

2. Set up a repository

cd your-repo
use05 init

use05 init proposes a policy from the checks it detects (for example your test script), creates a signing key for this machine, installs hooks for Claude Code and Codex if they are present, and adds a pre-push hook. It lists exactly what it changed and, just as important, what is not covered. use05 uninstall reverses it.

Terminal output of use05 init: seven changes (a policy file proposing the test check, a .gitignore for agents' unsealed declarations, a signing key, Claude Code hooks and permissions, Codex hooks, the git pre-push hook, a block added to AGENTS.md) and two things not covered: no approver key yet and no merge enforcement.

3. Do a task and read the brief

use05 start "Stop retrying failed charges" --scope "src/billing/**" --check test
# ... the work is done ...
use05 finish --outcome "Capped retries at three"
use05 prove      # run the policy's checks on the exact files and sign the result
use05 brief      # the one page you read

With Claude Code or Codex, the agent declares and finishes itself, as the AGENTS.md block tells it. Its hook seals the declaration and, when the agent stops, runs the checks, so you only read the brief. If nothing is staged, 05 looks at your working tree, so an agent's unstaged edits are not missed.

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. 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.

The brief is deterministic. No model judges it. It compares the declared plan to what changed, and an agent's claim such as "all tests pass" to the evidence on the exact tree. When everything matched, it ends with ALLOW, nothing to read.

4. Approve, with a key an agent does not have

use05 key new --approver     # once: protected by a passphrase
use05 approve --outcome      # asks for the passphrase on your terminal

The approval is signed, bound to this exact content and the policy in force, and expires. Change a file and it no longer counts.

Then land it and push. No pull request is needed:

use05 land                   # the approved change becomes a commit on its target branch
git push origin main

Terminal output. use05 prove passes the test check. use05 approve shows what is being approved and that the approval is bound to this exact content and expires in seven days. The brief then ends with ALLOW, read the notes: the two files outside scope and the dependency change.

5. Turn on the strong control

Everything above runs on your machine, so an agent running as you can reach it. 05 says so, and use05 doctor shows it. What enforces is a CI runner the agent cannot reach, plus a required check on your Git host.

Make a runner key: use05 key new runner.key.
Store the secret as a CI secret named USE05_RUNNER_KEY, then delete the local file.
Trust the public key in .05/policy.toml with role runner, and set accept = ["runner"]. Add expires so a leaked key cannot stay trusted forever.
Run use05 init --ci github for the workflow.
Require that check in branch protection. This is the step that turns advice into enforcement.

In CI, 05 reads the rules from the base branch, so a change cannot loosen its own rules. It gates every pushed branch, so the commit you land is one CI already checked, and a protected main accepts it with no pull request. It proves the base's required checks with the runner key and prints the brief in the job summary. See enforcement strength for what is advisory and what is not.

Terminal output of use05 doctor. Setup, keys, controls and record sections. 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.

Working with several agents

Run each agent on its own branch and worktree; its declared plan reserves its area, and 05 tells other agents to stay out of it. When a change is allowed, use05 land --task <id> lands it and removes the finished branch and worktree; see several agents, one codebase.

Every command

use05: Where this repository stands: the task, whether the change would be allowed, which controls are on.
use05 init: Set up policy, keys and hooks, and say exactly what changed. --ci github adds the CI workflow.
use05 start: Declare the plan: what you will do, where (--scope) and which checks must pass. Agents run it themselves.
use05 finish: Declare the outcome: use05 finish --outcome "..." says what was done. It is an assertion until the evidence supports it. Agents run it themselves.
use05 prove: Run the policy's checks, or any command, on the exact tree, and sign a receipt.
use05 brief: The one page a person reads instead of the diff, ending in one decision.
use05 approve: Approve or --reject a plan or an outcome, signed with your passphrase-protected key.
use05 land: Move an allowed change into its target branch as a fast-forward, then remove the finished branch and worktree.
use05 bypass: Break glass: let one exact tree through a block for a stated reason. Signed, and shown in the brief.
use05 verify: Check a receipt offline, with no account and no network.
use05 policy: Show the effective rules and where each one came from, including an organisation floor.
use05 doctor: Check the setup and say how strongly each control is enforced.

Every command takes --json for scripts and agents, with fixed exit codes.

Extend it

05 is extended from the outside, never by loading code into it, so nothing an extension does can change what the gate decides.

Your own commands. A program named use05-<name> on your PATH runs as use05 <name>, the way git finds git-<name>.
Any agent. use05 hook generic gives agents other than Claude Code and Codex the same hooks, with a plain decision, reason and context.
Events. Programs you list on your machine hear when a plan is sealed, work finishes, a gate decides or a change lands. They get identifiers and verdicts, never code or prompts, and they cannot hold work up.
Your own records. Other tools can keep their own signed records next to 05's receipts. 05 counts them and never mistakes them for its evidence.

The contract for extension authors is docs/extending.md in the repository.

Questions

The source, issues and docs are on GitHub. Or email us.

Keep reading

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]