Your agents write the code. The decisions you can't undo stay yours.
Reversible agent work, then mechanical checks, then reviewers who didn't write the code, then you.
3 cold reviewers read every diff — adversarial-reviewer, quality-engineer, security-reviewer · packs/core/.apm/agents
agentbundle uninstall removes what it installed and leaves your edited copies in place. What it keeps.
Claude Code, Codex, Cursor, Copilot, Gemini, Kiro. Switch agents, keep the loop.
web · work-loop
- spec
- accepted
- lint
- pass
- typecheck
- pass
- tests
- pass
- adversarial-reviewer
- returned
- findings returned — the loop repeats
- quality-engineer
- waiting
- security-reviewer
- waiting
- merge
- HELD
- awaiting a person
An agent that certifies its own work is not a teammate.
So you review all of it, every time, yourself — and when the argument is over, nothing on disk records what you agreed.
Agent coding tools have moved the leverage from the prompt to the loop. But a loop running unattended is also a loop making mistakes unattended — and it will self-certify its way out of every check you give it. The answer is not a tighter prompt. It is a supervised loop with mechanical gates the agent cannot bypass.
Four steps, and the last one is yours.
The agent does the reversible work, mechanical checks decide whether it is green, reviewers who did not write the code read the diff, and a person makes every decision that is hard to undo.
The agent writes
It works from a spec and a plan you approved before any code existed, and every step it takes is one you can throw away. Nothing it does on its own is hard to undo.
Mechanical checks decide
Lint, types and tests run on the change, and their result is a verdict rather than an opinion. The agent cannot talk its way past a red one, and it does not get to mark its own work green.
Reviewers who did not write the code read
The diff goes to reviewers that share no context with the author and none with each other. Each reads the repository’s own guidance, attacks the change along its own lens, and keeps reporting findings until it has none left.
You decide what is hard to undo
Merging, shipping, and accepting a plan are yours. The loop runs up to each of those and stops, with the reason in front of you. It never asks for permission it has already taken.
What lands is files you can read, diff and edit.
Installing writes into the layout your agent already looks in: .claude/, .agents/, .cursor/ and the rest, one per adapter. There is no hosted runtime between you and those files — nothing phones anywhere to run your loop, and nothing you install stops working because a service did.
- Skills
<name>/SKILL.md - A procedure your agent reads before it starts. Plain markdown, in your repository, in your diff.
- Subagents
<name>.md - The reviewers, each with its own lens and its own tool list. You can read exactly what one is told to look for.
- Commands and hooks
<name>.md, <name>.sh - The entry points you type, and the scripts that run around them. Ordinary files; ordinary review.
They are yours after they land. Edit one and the tooling treats your copy as yours — an upgrade drops its update rather than overwriting you, and uninstalling removes only what it put there. How edited copies are handled.
Use cases
Start with the outcome. Meet the packs second.
Packs are composable units, not departments. Choose the change you need and install only the workflows that help produce it.
Decide what to build
Product managers · strategists · founders
Move from strategy and evidence to a bounded decision brief a delivery team can act on.
Design the product and system
Designers · architects · frontend teams
Connect customer intent to journeys, architecture, interfaces, and an implementable surface.
Build and review software
Flagship systemSoftware teams · coding agents
Take a brief or spec through implementation, mechanical gates, independent review, and a human merge decision.
Provision and release safely
Platform · infrastructure · SRE
Make system decisions explicit, produce a reviewable infrastructure plan, validate the deployed whole, and stop before irreversible action.
Work with team systems and evidence
Researchers · delivery teams · analysts
Bring trackers, source material, design files, and credentials into agent work without hiding provenance or mutation.
Document what ships
Product teams · documentation owners
Create, restructure, audit, and verify documentation against the behavior your product actually ships.
Build and govern a catalogue
AI enablement · platform owners
Create an organization-owned catalogue, curate packs and profiles, validate contracts, and distribute one governed system.
One install. Every major agent.
| Agent | Skills | Subagents | Hooks | Commands |
|---|---|---|---|---|
| Claude Code | Yes | Yes | Yes | Yes |
| Codex | Yes | Yes | Yes | No |
| Cursor | Yes | Yes | Yes | No |
| Copilot | Yes | Yes | Yes | No |
| Gemini CLI | Yes | Yes | Yes | No |
| Kiro IDE | Yes | Yes | Yes | No |
| Kiro CLI | Yes | Yes | Yes | No |
Switch adapters with one flag. Your skills, subagents, and hooks project into the layout each agent expects.
Start in one command.
python -m pip install agentbundleagentbundle install --pack coreagentbundle install --pack coreagentbundle install --pack product-engineering --scope useragentbundle install --profile inceptionagentbundle install --profile solution-architectOne command lands the loop. Any agent that reads a skill file inherits it automatically. Follow the install-to-ship walkthrough.
Own the catalogue your team runs.
Initialize a clean managed scaffold with agentbundle catalogue init. Choose the packs and profiles your organization supports, encode your conventions and defaults, validate the contracts, and distribute one governed system across machines and agent adapters. No repository fork is required.