Lead Agent
Holds the rules. Dispatches the work. Reviews every diff.
- Encodes your project + company rules
- Receives tasks from the annotated product
- Spawns and assigns Workers
- Reads the diff before anything ships
Back to Agentationthe system
A factory, not a chat
One Lead Agent holds your rules. It dispatches isolated Workers, reviews their diffs, and moves the work through five columns — every step gated by deterministic checks, every commit landing on your own GitHub. Agentation never sees your code.
the architecture
One Lead. Many Workers. One source of truth.
Agentation isn't one model answering prompts. It's a small org chart that never sleeps — a Lead Agent that owns the rules and a swarm of Workers that each own one task, in isolation.
Worker
Implements a single task inside a git worktree.
- Own branch, own worktree — zero collisions
- A 4-field contract: objective, output, tools, limits
- Conventional commits — feat(scope): …
- Reads CLAUDE.md before touching a file
Decisions, not vibes.
The Lead never edits the board by hand. It emits decisions — spawn, assign, complete — appended to a log, never rewritten. The board is a consequence of the rules, not a whiteboard anyone can drag.
the pipeline
Five columns. No human drag.
Every task travels the same track — Todo to Done. Humans can't move a card; only the Lead advances it, and only once the gates are green. The board is honest because nobody can fake it.
- Todointent captured
An annotation lands as a task — bug, design or feature. Raw intent, nothing built yet.
- Specshaped into a plan
The Lead turns the intent into a concrete plan inside your rules — scope, files, boundaries.
- Workinga Worker builds it
A Worker is spawned in its own worktree and implements the task — alone, isolated, committing as it goes.
- Reviewthe Lead reads the diff
Gates run first; the Lead reads the diff against your rules and only then calls it complete.
- Donemerged, live
Pushed through your GitHub — branch, commit, PR, merge. What was pointed at is now in production.
humans annotate · the Lead drives · agents buildCards move left to right only — and never by hand.
the gates
Nothing advances on faith.
Between Working and Done sit two deterministic gates — pure code, zero AI tokens, no opinions. They either pass or they block. The Lead can't argue with them, and neither can a Worker.
CheckGatebefore review
Runs lint, types, tests and security on the Worker's output. The Lead only marks a task complete when this reads green.
LintTypesTestsSecurity
PrePushGatebefore any push or PR
Re-runs the checks, plus commit-convention, a secrets scan and lock-file drift — the last fence before your repo.
LintTypesTestsSecurityConventionSecretsLocks clean
deterministic · 0 AI tokens
github-native
Your GitHub. Your code. Never ours.
Agentation works through the GitHub you already trust — real branches, real commits, real pull requests. The code lives in your repo from the first line. We orchestrate the work; we never hold the source.
$ git checkout -b agentation/task-9f3a2c
$ git commit -m "feat(todo): match brand orange"
$ gh pr create → #214 opened
$ gh pr merge --squash ✓ merged to main
github-native
We see the task, never the source.
Real branchesagentation/task-<id> off your default branch
Conventional commitsfeat(scope): description — never “WIP”
Pull requestsopened on your repo, reviewable by your team
Your pipelineyour CI, your protections, your merge rules
what it permits
Create without ever touching the code.
The structure isn't bureaucracy — it's what lets you stop coding and start creating. The rails carry the quality so you don't have to.
Create without seeing code
Point at the live product, describe the change. The pipeline turns intent into shipped software.
Ship with confidence
Two gates and a diff review stand between any change and prod. Green or it doesn't move.
Scale in parallel
One Lead, many Workers, each in its own worktree. Tasks run side by side without stepping on each other.
Keep production quality
Your rules, your stack, your GitHub flow — encoded once and applied to every change, automatically.
the vibe
Bring your product and your GitHub. The Lead holds the rules, the Workers do the work, the gates keep it honest — and you stay in creation, not in code.