Claude Agentic Framework
The Governed Swarm
A drop-in template for Claude Code that turns a single AI assistant into a coordinated engineering team — with the guardrails to trust what it ships.
Why govern an agent at all?
An unsupervised coding agent is a firehose: fast, confident, and indifferent to your standards. The interesting problem isn't getting AI to write code — it's making the output trustworthy. The framework's bet: treat the agent like an engineering organization, not an autocomplete.
Speed and stability reinforce each other
Quality gates aren't a tax on velocity — they're what makes sustained velocity possible. Every change passes tests, lint, types, and build before it lands, so the next change starts on solid ground.
AI amplifies existing discipline
An agent with no process amplifies chaos. Given golden paths, layered rules, and mandatory review, it amplifies engineering judgment instead. The framework supplies that structure as versioned files in your repo.
Small changesets, many reviewers
The failure mode of agentic coding is the 2,000-line pull request nobody actually read. Swarm orchestration decomposes work into focused tasks and puts every diff through multi-perspective review.
One agent thinks. Many agents build. Many agents review.
The full cycle runs in four moves, each owned by a different kind of agent.
/architect/swarm-planThink
One planning agent studies the goal, records decisions as durable artifacts — PRDs, ADRs, plans — and decomposes the work into small, parallelizable tasks.
/swarm-executeBuild
Focused workers implement in parallel. Each gets a self-contained prompt, a bounded turn budget, and a model tier matched to its job — and no worker can spawn workers of its own.
/swarm-reviewReview
Adversarial reviewers attack the diff from independent angles — correctness, security, architecture, tests. Run it more than once; it's cheaper than an incident.
git pushShip
Tests, linter, type checker, and build must pass before every commit — and the work is not done until the push succeeds.
What's in the box
12 commands
Six single-agent expert modes — architect, builder, QA engineer, security auditor, UI/UX designer, code auditor — four swarm orchestrators, plus v5's /tailor customization engine and /land-the-plane finish-line workflow.
5 worker types
Explorer, builder, reviewer, researcher, and architect workers. Model tiers are pinned in each agent’s frontmatter — premium reasoning where judgment matters, cheaper models for mechanical work.
21 skills
Nine library skills spanning architecture, engineering, operations, product, and security, plus 12 gated workflow skills. Every skill is eval-tested against the base model — anything the model already knows gets retired.
Layered rules
Golden-path tech strategy, code-quality standards, a debugging protocol, and security requirements — roughly 5k tokens, loaded into every session automatically.
Enforcing safety hooks
Secret detection, protected-file guards, push blocking on main, file locking for concurrent workers — and as of v5, hooks that detect your stack's quality gates and block any commit or task completion that fails them.
4 MCP servers
Sequential Thinking for hard trade-offs, Chrome DevTools for in-browser verification, Context7 for current library docs, and Filesystem for controlled file operations.
The enforcement ladder
Prose instructions are suggestions to a language model. The framework's sharpest idea is admitting that — and pushing anything that must be true down the ladder until a machine checks it.
1Prose rules
AdvisoryCLAUDE.md and the rules directory are read at the start of every session. They set direction — but nothing mechanically checks compliance.
2Skills
On demandWorkflow patterns surface automatically when a task matches their description, encoding accumulated practice without permanent context cost.
3Hooks
DeterministicPre-tool-use scripts catch secrets, protected files, and dangerous commands before they execute — and as of v5 they run your detected quality gates, blocking a commit that fails one. Still fail-open: a broken hook never blocks legitimate work.
4Permission denials + CI
Bindingpermissions.deny cannot be overridden by any allow rule at any scope, and CI runs entirely outside the agent’s control. This rung is a boundary, not a suggestion.
New in v5: the gates grew teeth
v5.0.0 moves the framework's biggest promise down the ladder. Quality gates stopped being advice the agent reads and became enforcement the agent cannot skip silently.
Commits verify themselves
The pre-commit hook detects your stack's gates — lint, tests, types — runs them, and blocks the commit if one fails. A passing run writes an evidence stamp bound to the exact tree hash, so stale proof never carries over.
Task completions are gated
Marking work done triggers the same detected gates. A failure blocks completion; a slow gate times out honestly, reporting that nothing was verified rather than pretending it passed.
Stack packs + /tailor
Working exemplar files for TypeScript, Python, Go, and Rust — a golden-path skill and CI gates with real dependency audits — and a /tailor command that fingerprints your repo from its lockfiles and instantiates only what it actually found.
This site is the lab
bidwell.info runs on the framework it's describing — v5.0.0, checked into this repository's .claude directory. The experiments hub you arrived from was specified in a PRD, architected in an ADR, and built and reviewed by the swarm.
So was the page you're reading.
Related reading: Agent Coordination Structure →Every merge to main must pass
- tsc --noEmit — strict type-check
- biome check — lint and format
- vitest run — unit tests with axe accessibility assertions
- next build — full static export
Run it on your own repo
The recommended install is a raw drop-in: clone the framework and run its init script against your project. It sets up the .claude directory — commands, skills, agents, rules, hooks — and leaves the rest of your repo alone.
git clone https://github.com/dralgorhythm/claude-agentic-framework.git
cd your-project
../claude-agentic-framework/scripts/init-framework.sh .Read the init script before you run it — the framework would tell you to do the same. Prefer a lighter footprint? Install it as a Claude Code plugin instead: /plugin install agentic-framework@agentic-framework Either way, /tailor is the first move after install: it fingerprints your stack and proposes the pieces that fit — you review, nothing writes silently.