← The Agent Fleet
The Company · v3 · Architecture
One name. One lifecycle.
One card per agent.
The Agent Fleet chapter is the org chart — nine departments and what they own. This is the engineering constitution underneath it: the rules that make sixty components legible to one another and to the fleet itself. Every agent shares one systematic name, one run lifecycle, one card that defines it before it gets code, and a deterministic guardrail that holds the whole thing to its own doctrine.
Why split it out: v2's fleet worked but every agent carried its own historical build. v3's answer is a constitution — the naming convention, the harness lifecycle, the Agent Card, the typed connectors, the self-generated registers, and the standards guarantee. This page is that answer in full.
ONE NAME FOR EVERYTHINGthe naming convention
Every component carries one systematic name — resort, machinery, verb, object. Read it left to right and you know who owns it and what it does.
Resort_Layer_VerbObject
G_H1_Plan Week — Decide, scheduled mind: writes the weekly plan
Q_H2_Review Work — Quality, dispatched worker: gates every commit
Z_H3_Audit Standards — Control, scripted reflex: lints conformance
THREE HARNESSES · ONE LIFECYCLEhow every component runs
Behaviour is implemented once, as shared machinery — every component shrinks to the one part that is its own: its work. Three harnesses cover the fleet's execution classes.
H1 · scheduled mind
LLM cadence tasks
A thinking task that wakes on a clock — plans the week, reviews the skills, synthesises ideas. Runs through one shared task runner, never a hand-rolled invocation.
H2 · dispatched mind
Worker dispatch
The resident supervisor claims a work-item, gates it, dispatches a worker, reviews the diff, records and reports. Claim → gate → dispatch → review is the lifecycle.
H3 · scripted reflex
Pure-script loops
The health pulses, the reapers, the budget monitor — no LLM, just a reflex on a cadence. All converge onto one runtime library that wraps them in the standard lifecycle.
Whichever harness it runs on, every run passes the same six phases in order. Only one of them differs between components.
01
WAKE
Trigger fires. Single-instance lock, kill-switch check, budget pre-flight.
02
ORIENT
Load only card-declared knowledge. A stale source reads UNKNOWN, never a guess.
03
WORK
The component's own logic — the only phase that differs between components.
04
RECORD
One enveloped run event, KPIs appended, state written atomically.
05
REPORT
State-change-only alerts; follow-ups routed through the standard writers.
06
YIELD
Heartbeat, flag stamp, lock release, standard exit codes.
Why it matters: a component that isn't behaving standardly betrays itself by the absence of the standard evidence every harness emits — no heartbeat, no run event. The standard proves itself; silence is the finding.
THE AGENT CARDno component without one
Before an agent gets code, it gets a card — one markdown file, eight parts, defining it completely. The scaffolder builds from the card; the registers generate from the cards.
1 · identity
Who you are
Name, kind, exactly one department, version, lifecycle status.
2 · mission
Why you exist
One sentence, plus the loops you serve.
3 · knowledge
What you read
Your declared context diet — every source, with a freshness cap. Nothing undeclared.
4 · tools
What you may use
Runtime, tool surface, allowed actions, and the budget you cost.
5 · connections
What you write
Every edge you emit, each one naming its consumers.
6 · KPIs
What judges you
Each with a max staleness — past it, the metric reads UNKNOWN, never green.
7 · control
How to stop you
Trigger, the one kill switch, escalation path, failure signatures.
8 · improvement
Who may change you
Declared self-tuning knobs, each with a reversibility tier — and the duty that every self-change is logged with a baseline. Today these loops observe and record; they act only once their resort is armed.
SIX CONNECTORScomponents touch only through typed edges
Agents don't reach into each other — they interact only through six kinds of declared edge. An interaction that isn't one of these six is a finding.
queue
Work to be claimed
The work-item backlog, the Input Queue, the Solo Queue — admission-governed.
event
Append-and-tail
One enveloped event stream the fleet writes to and reads from.
state
Single-writer JSON
One owner, atomic writes, so a reader never sees a half-written file.
artifact
Vault documents
Plans, briefs, notes, the generated registers — versioned in git.
invocation
One calls another
A dispatch, a dot-source, a spawned child process.
surface
Reaching the operator
Slack, the cockpit, the evening brief — the edges that reach Michael.
THE REGISTERSthe fleet's self-model, generated
Because every agent has a card, the fleet generates its own map — and checks it against what actually runs. None of these pages is hand-maintained, so none can quietly go stale.
Agent Register
Every agent — name, department, cadence, body script, log, kill switch — on one page
Cadence Timetable
What runs when, 04:30 → 23:45, with a collision view
KPI Register
Every metric, its owner, its source, and how fresh it is right now
Event Register
Every event type → its schema version → who writes it → who reads it
Loop Graph
Every self-improvement loop, closed or observing, with its stop switch
Test Register
Every test, its rail, its tier, its coverage — one register, no orphans
A write edge no card declared is detected within the hour. The map and the machine are held to each other.
THE GUARANTEEstandards that hold at any time
A weekly audit alone catches drift up to seven days late — so the guarantee is deterministic script logic, not an LLM opinion, across six reinforcing layers.
The promise: new violations prevented at write time · existing debt frozen and only shrinking · any breach detected within one hour.
layer 0 · paved road
Conformance by construction
The standard is the cheapest path: shared helpers do the standard thing by default, and a scaffolder emits a conforming component from one command. An agent that uses the helpers can't drift.
layer 1 · admission gate
Prevented at write time
The commit hook lints naming, state placement, event envelope. A new non-conforming file is refused; the reviewer runs the same deterministic lint before any push.
layer 2 · continuous detection
Found within the hour
Live-system checks — a task registered outside the registrar, an unregistered event schema — ride a ~30-minute hygiene cadence, not the weekly pass.
layer 3 · weekly deep audit
Cross-file invariants
The contradiction detector holds the checks that need the whole picture, and a sealed auditor shows Michael any change to the standards themselves, unfiltered.
layer 4 · taught where it's used
Standards in the prompt path
Workers meet the standards as a skill invoked when they build a component, plus one line in the worker prompt and one in the reviewer's criteria — taught at the point of work, never shouted globally.
layer 5 · the ratchet
Debt only shrinks
Every currently non-conforming component is frozen onto one list. Anything not on it is new — a hard fail. The list may only shrink; the conformance curve, written each week per dimension, may only rise. A drop escalates itself.
This constitution is what the nine departments run on. It's also what lets the self-change machinery stay on a leash — the arming ladder and the twelve weekly tracks live back on the Agent Fleet page.