The agents
Three agents build a pipeline, and each owns exactly one scope of decision. The discipline that makes the hierarchy work is the same one that governs the execution layers: a tier never writes the tier below it.
Together these agents are the part that proposes. One rule sits above the whole hierarchy:
A policy never adjudicates its own correctness.
An agent that both proposes a result and decides whether that result is good will, eventually and without meaning to, learn to satisfy its own judge. So the agents propose, and every check that decides whether work is acceptable lives outside them — in the harness that refuses what it cannot support, in the checks that run when a pipeline is built, and in the Keep gate that decides what is kept.
| Agent | Decides | Lifetime |
|---|---|---|
| Architect | the overall architecture — which components exist, how they connect, what each one is for | one pipeline |
| Coordinator | how one component meets its assigned objective | one node, long-lived |
| Executor | the code for one attempt at that component | one experiment, short-lived |
What each one does
The Architect designs the graph and writes each node's brief. The brief is the sub-objective — there is no separate assignment mechanism. It decides which knobs are run-level, seeds their defaults, and chooses how much data a build should run on. It wires components to real data it has discovered, rather than to identifiers it invented.
The Coordinator takes one node's brief and drives it to something worth keeping: dispatch an attempt, wait, judge the result, keep or iterate. When a node's objective is a metric rather than a working body, it runs a search over attempts. When it cannot make progress for a reason outside its control, it reports a blocker instead of burning its remaining budget.
The Executor writes the kernel for a single attempt and runs it. It authors domain logic and a declaration, and nothing else — no loop, no sharding, no IO, no credentials.
Where the loop runs
The Coordinator/Executor loop is not a separate service or a background job. It is a sub-phase of a single node.
When a pipeline is being built and the build reaches a node that needs code, it opens the loop for that node. The Coordinator briefs an Executor, the Executor writes a kernel and proves it on sample data, and on success the node pins the result. From that point the node is deterministic: later runs execute the pinned code, and a retry re-executes rather than re-writing.
The same kernel at four scales
Authoring climbs a ladder, and every rung runs the same kernel with more substrate beneath it.
| Tier | Data | What it establishes |
|---|---|---|
| author | none | the code exists, is well-formed, and declares a contract |
| smoke | one sample shard | the kernel runs a real unit and honours its declared contract |
| build | a sample flowing through the whole graph | the components fit together end to end |
| run | the full corpus | production |
The agent never knows which rung it is on. That is deliberate: code that behaved differently because it detected a test would defeat the entire ladder.
Why a build is a real pass over a sample
A node in the middle of a graph cannot be authored in isolation, because the sample it needs to write code against is its upstream node's output — which does not exist until upstream runs. So a build runs the whole graph over a sample: each node authors and proves itself against the sample that actually reaches it, and its output becomes the next node's authoring sample. One coherent pass authors a pipeline of any depth.
Because the code is proven on a fraction of the data, the authoring agents are told what fraction they are working with and instructed to design for the full corpus. Proving a body runs is not the same as proving it performs.
What the agents never do
- The Executor does not choose infrastructure, write plumbing, or see credentials.
- The Coordinator does not redesign the graph; structural change is the Architect's scope.
- The Architect does not write code; it decides what should exist and judges whether it does.
Each boundary is enforced somewhere concrete — by the tools an agent is given, by what static checks reject, and by what the platform simply never exposes.