Skip to content

The agentic build loop that cannot approve its own work.

core takes a brief or spec through implementation, mechanical gates, and a cold independent review. It keeps going until the change is clean—or stops and tells you why. The wider catalogue brings the same discipline to product, design, infrastructure, release, research, and documentation work.

Try the supervised build loop Explore use cases

One command. Every major coding agent. Human merge gate. User-scope packs also ship through the Claude plugin marketplace.

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.

Browse the complete catalogue by outcome and role

An unattended loop makes unattended mistakes.

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.

Three supervised peer loops. One handoff chain.

  1. Discovery Loop

    product-engineering · discovery-lead

    Raw idea → ratified brief. Five candidate shapes explored in parallel, collapsed through product, UX, architecture, and safety lenses.

    Human gate. G3 — you approve a ratified decision brief, not a validated solution.

    Read the discovery journey

  2. Build Loop

    core · work-loop

    Spec → shipped code. Lint, typecheck, and tests must pass. Three specialist reviewers each read the diff cold, in a fresh session — adversarial by design.

    Human gate. G4 — you merge only when adversarial review is clean and all gates pass.

    Read the build journey

  3. Release Loop

    release-engineering · release-lead

    Built → production. Autonomous e2e convergence on ephemeral environments. Deployed findings feed back to the build loop automatically.

    Human gate. G5 — prod ship always surfaces to a human. Always.

    Read the release journey

Every loop surfaces to you at exactly the right moment.

Not as a workaround — as a design principle. The agent runs the loop; you control the gates. Here is what each handoff asks of you.

  • G0Discovery

    Go / No-go

    Is this idea worth exploring?

  • G1.5Discovery

    Shape sign-off

    Does the chosen shape fit the product strategy?

  • G2Discovery

    Brief ratification

    Is the decision brief complete enough to build from?

  • G3Discovery → Build

    Handoff to build

    Is this brief specific enough to spec?

  • PlanBuild

    Plan approval

    Is the plan's trio correct? Do the risk triggers fire?

  • G4Build

    PR merge

    Is adversarial review clean? Does the spec match the implementation?

  • G5Release

    Prod ship

    Is this safe to put in front of users?

Explore a full journey

One install. Every major agent.

AgentSkillsSubagentsHooksCommands
Claude Code
Codex
Cursor
Copilot
Gemini CLI
Kiro IDE
Kiro CLI

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 agentbundle
agentbundle install --pack core
agentbundle install --pack core
agentbundle install --pack product-engineering --scope user
agentbundle install --profile inception
agentbundle install --profile solution-architect

One command lands the loop. Any agent that reads a skill file inherits it automatically.

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.

Build your organization's catalogue