A control plane for agentic coding
Declare how your agents should work once.
Run it on any coding engine, with the guardrails built in. ALC keeps verification, focus and isolation outside the model, in plain deterministic code — so best practices stop being discipline you have to remember, and become defaults you can't skip.
Installs uv if you do not have it, then alc, and puts it on your PATH. The same command updates you later — read the script first if you would rather. Prefer not to pipe a script? There is a one-line alternative.
Python 3.12 and git. ALC ships no model — it drives a coding CLI you already have: Claude Code or Gemini. No CLI yet? A free Mock engine exercises everything without a model call.
Everyone converges on the same habits. Then forgets them.
One task at a time. Run the tests afterwards. Read the diff before you keep it. Those habits live in your head, and they die the moment you're tired, in a hurry, or asleep — silently, because the agent reports success either way. ALC moves them into code that refuses to report success instead. [The longer argument is in the introduction.](/docs/getting-started/introduction)
One condition, and it is the whole of the setup: the checks are yours. A fresh scaffold ships a single placeholder that always passes, so out of the box ALC enforces nothing. Wiring in your real test and lint commands is what makes the guarantee true of your code.
Below is a real run, pasted as text — it passed on its first attempt. When a check fails instead, the loop feeds the failure back to the engine and tries again, up to four turns by default. [How that works](/docs/concepts/assurance-loop)
Nothing is reported done until it actually is.
$ alc run bug "slugify() drops nothing and collapses nothing — three tests fail. Make them pass."
→ Act (attempt 1/4)…
→ claude-code working (model=claude-sonnet-4-6)…
• Bash: find . -type f | head -30 && echo "---" && ls -la
• Read: src/slugify.py
• Read: tests/test_slugify.py
• Bash: python -m pytest tests/ -v
• Edit: src/slugify.py
• Bash: python -m pytest tests/ -v
→ claude-code done (58s, $0.202)
→ Verify (1 check(s))…
· test… ✓ 0.2s
✓ all checks passed
Status: SUCCESS
Engine: claude-code
Attempts: 1
Scorecard: span=1 passes=1 streak=1 touch=0
good: span ↑ passes ↓ streak ↑ touch ↓ (touch 0 is the goal)
Changed files:
src/slugify.py
Two planes, one door between them
ALC splits every unit of work in two. The control plane is deterministic code: it loads your configuration, refuses to run a misconfigured one, composes the directive, runs your checks, records the result. The execution plane is one reasoning-and-editing turn by a model.
The rule that makes it work: push every practice that does not *require* the model into the control plane. The more a practice lives outside the model, the more portable and guaranteed it becomes — and the less it matters which engine you point at it.
- 01
Declare
A Blueprint is a template for a class of work — chore, bug, feature — carrying its own checks, compute tier and report schema. It lives in
.alc/, kept separate from your app code. - 02
Gate
Before anything runs, the Policy Gate lints the Operator Layer and refuses a configuration that can't deliver on what it claims. A Blueprint with no checks is not a guarantee, so it isn't allowed to pretend to be one. It cannot judge the checks themselves, though — a check that always passes passes the gate, which is why the scaffold's placeholder is the first thing to replace.
- 03
Act, Verify, Repair
The engine takes one turn. The control plane runs your checks. On failure it re-invokes the engine with the failure output, up to a bounded budget. Checks are law — and the law itself is guarded, so a run can't pass by quietly weakening a lint rule.
- 04
Review
ALC guarantees the change compiles and your checks pass. It doesn't guarantee the change is right. Reading the diff is the one step it deliberately leaves to you.
Act → Verify → Repair, until the checks pass or the repair budget runs out.
alc ui
Watch the loop instead of tailing a log
The same control plane, with a screen: the Scorecard and engine health on one panel, every run’s Act / Verify / Repair timeline as it happens, and the queue beside them. A local, single-user server — alc ui, no account, nothing leaves the machine.
What lives outside the model
Guarantees outside the model
The Assurance Loop runs your checks and repairs until they pass. A failed run is never committed and never auto-merged.
Engine-agnostic
Claude Code or Gemini, switched with a flag. The control plane doesn't change — only the quality of one step does.
One agent, one purpose
Every task is a focused Single Mandate in its own invocation. The engine never has to stay focused on its own, because it's never handed more than one thing.
Composable
Blueprints compose into Flows. A Conductor turns a goal into the right Flows, then runs or queues them.
Unattended
Drop tasks in a queue and let cron's alc tick drain them, isolated, while you're away. Land what survived the checks in the morning.
Isolated
--isolate runs the work in a throwaway git-worktree branch, so your working tree stays clean and nothing merges without you.
Specialists
Agents tied to one area, keeping a Knowledge File and getting better at it over time.
Measured
Span, Passes, Streak and Touch, per run. The north star is hands-off delivery: Touch to zero.
You don't start at the top. You climb.
ALC grows with you. Each rung is useful on its own, and each one earns the next — rung 1 works on the day you install it, and rungs 2 and 3 are what you grow into once your checks and Blueprints describe real work. A Conductor with one placeholder Blueprint has nothing to plan with.
- 1
Attended
You run it, watch the loop, read the diff. This is where the Operator Layer gets real — checks that mean something, Blueprints that describe your actual practice.
- 2
Detached
Flows run off a queue, triggered by cron or a webhook, isolated in worktrees. Touch drops, but you still decide what lands.
- 3
Conducted
You give a goal, not a task. A Conductor plans which Flows and Specialists it needs and drives them for you.
The human is on the loop, not in it. Touch → 0 means zero interventions — not zero judgement.
Three commands to a validated `.alc/`
With alc on your PATH from the command at the top of this page, this is the whole setup. A freshly scaffolded project defaults to the free Mock engine, so you can prove the control plane works before spending anything on it.
alc onboard is the step that replaces the scaffold's placeholder check: it reads the test and lint commands your project already declares — package.json scripts, Makefile targets, tox, pre-commit — and adopts them, so the guarantee is made of your checks rather than a stand-in.
Experimental, but real: every feature is covered by a hermetic test suite and validated live against Claude Code and Gemini. MIT licensed.