An agent that runs alone needs a prompt. A company of agents needs an order: who goes first, whose output feeds whom, and what stops a loop that will not end. We keep that order as data, so a guard can read it.
We write down which work depends on which, check the schedule against it, and put a bound on every loop.
Four words carry the page. A seat is one of the agent roles that run the company, such as Legal, Quality or the Chief of Staff; each is a workflow that starts on a schedule or on demand. A cron is the schedule line that starts a workflow, such as 13:00 UTC every Friday. A dependency edge is a written rule that one seat runs after another because it reads that seat's output. The clock check is a program that compares those rules with the seats' crons and reports any seat set to run before its input; an edge it cannot compare, because one end has no weekly cron, it calls unorderable.
This page has two parts. The first is what is built today: every line names its receipt, and says when a piece has been tested but not seen running. The second is design, what the method needs next, and every heading in it starts with the word Design. Each section of the second part first says what runs today, then what the design adds, and none of the design runs. Only its first section has a plan behind it.
What is graph engineering?
Deciding the shape work runs in: where it branches, where branches meet again, what may loop, and what ends it. The shape is written down as nodes and edges so a program can check it, instead of living in someone's memory of why one job runs three hours after another.
The method, in five rules:
- Write every dependency down as an edge in data, never as a gap between two start times.
- Check the schedule against the edges on every commit, and list any edge the check cannot compare instead of passing it.
- Join on an event when an output must exist. A join on a clock reads whatever is there; ours does today, and the design half of this page says what replaces it.
- Put every loop's stop in the script that runs it, never only in its prompt: a turn cap, a budget, a kill switch, a bound on retries.
- Judge a loop from outside it: a commit, a check or a second model.
An order that lives only in a schedule is an edge with its name erased. Move one job a day earlier and the job after it reads last week's output, with no error anywhere.
What can this page not see?
- Only declared edges. The checker never infers an edge, so a seat that starts reading another seat's report without declaring it is invisible here.
- The clock check compares cron schedules, never runs. A run that fails or lands late is not seen by it.
- The clock check compares only weekly crons; the section on the schedule below says what that leaves it today.
- No node in the seat graph dispatches branches, and nothing here measures whether two seats ran at the same time.
- Each import graph guard sees the graph it walks and nothing else.
- The second part of the page is design. It describes what does not run yet.
How did the order come to be written down?
It started with a question in July 2026: was the leadership team a loop or a graph? We measured instead of guessing. The answer, on July 24, was eleven independent loops and one aggregator. No workflow waited for another; each seat fired on its own clock whether or not anything upstream had moved.
But the clocks held a graph. Finance ran on Wednesday at 06:00 UTC, Legal at 09:00 and Product at 12:00; Engineering on Thursday at 09:00 and Quality at 15:00; the Chief of Staff's briefing, its report on every department, on Friday at 13:00; and the Inspector General's audit of the week on Saturday at 14:00. That is a topological sort, an order in which every job comes after the jobs it reads. Someone had ordered it so the briefing landed after its inputs and the audit after the briefing, and nothing enforced it. Move Quality to Wednesday and the briefing would summarize a report that did not exist yet, with no error anywhere.
The next day, July 25, the order became data in the seat registry, and a check began comparing it with the clock. Even that first day it could not compare four edges: the briefing reads Marketing, Innovation, Operations and Revenue, which reported monthly or quarterly, so the check listed those edges as unorderable instead of passing them.
What happened the first time someone tried to move the clock?
Four days after the order became data, a request from the founder put it to the test. On Jul 29, 2026 a check built that day, reading each seat's run history against its committed reports, found Product Weekly and Legal Weekly green while their report folders had sat untouched for eight days. That evening the founder asked to see the briefing more often:
I also want chief of Staff overview twice a week instead of just on fridays. I need to montitor this more closley.
The first attempt added a Tuesday run of the briefing, and the clock check went red on four declared edges. Engineering, Product, Legal and Quality reported later in the week, so a Tuesday briefing would have restated their previous week under that day's date, with nothing erroring anywhere. The check only reported, so nothing forced the revert. The Tuesday cron was reverted the same day, and the guard was left standing.
By Tuesday no department has reported again, so a second briefing has nothing new to brief. What could run every day was what was open and what was red, which depends on no department. The founder said yes to a daily pulse, and that evening it was built as its own workflow with no model in it: it cannot invent a number, and it cannot go green while writing nothing, the failure the day had found. It can run any day without reading a stale week.
On the same order separated when the briefing is written from when it is delivered. The founder's sprint list asked to set when each report runs and when its email goes out, and those had been one number: the briefing emailed itself from the run that wrote it, so a new send day meant moving the seat, which the guard had flagged once already. Delivery moved to a schedule file of its own, docs/org/delivery.json, which the pulse sends.
What order do the seats run in?
The order is declared in the seat registry, docs/org/departments.json.
Each department's depends_on list is empty. The two officers, seats that read the others' work, fill theirs. The Chief of Staff depends on every department with a report workflow, written in the registry as a wildcard, *, so it stays correct when a department is added. The Inspector General depends on the Chief of Staff, because its audit covers the week, the briefing included. Resolved, that is 11 edges: 10 departments fan into the briefing, and one edge runs from the briefing to the audit.
Which seat runs after which, as declared, and what the clock check can say about each edge
The registry declares 11 edges across 3 layers of seats: 0 ordered, 0 violated, 11 unorderable. The clock check passes today while it compares none of them.
- Ordered: the dependent's cron runs after its input's every week (0)
- Violated: the dependent can run before its input (0)
- Unorderable: one end is not on a weekly cron, so the clock is not compared (11)
- Blue: an officer, a seat the graph fans into
- Dot filled when the seat is on a weekly cron, hollow when it is not, so its edges are not compared. Filled today: 0 of 12.
- Only declared edges are drawn. The checker never infers an edge, so a seat that reads another seat's output without declaring it is not here.
- Unorderable is not a pass and not a failure. It means the clock was not compared for that edge, because one of its seats has no weekly cron.
- The diagram is a declaration read from the committed tree. Its date is the newest commit that touched the registry or a workflow it reads, and it changes only when such a commit lands.
Not shown. Edges nobody declared, and the order of work inside a seat's own run.
Built from graph-order.generated.json, written by scripts/research/method-figures/graph-engineering.ts from docs/org/departments.json and the cron lines of the workflows it names. The verdicts are held equal to the dependency checker's printed output by the generator's test.
Registry and schedules as of
The numbers as a table
| Output from | Runs after it | Clock check | Why |
|---|---|---|---|
| Engineering | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Finance | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Innovation | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Legal | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Marketing | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Operations | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Product | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Quality | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Revenue | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Security | Chief of Staff | Unorderable | Chief of Staff is not on a weekly cron (cron 0 13 */2 * *). |
| Chief of Staff | Inspector General | Unorderable | Inspector General is not on a weekly cron (cron 0 14 3-31/3 * *). |
Download the data: graph-engineering-order-graph.csv, graph-engineering-order-graph.json
The edges are what the registry says. Whether a seat actually reads only what it declares is not checked here.
Does the schedule keep that order?
A checker in the collective package, check-org-dependency-order.mjs, reads every declared edge and the cron lines of both seats' workflows. A dependent's earliest weekly firing must come after its input's latest, or some week consumes last week's output. It also fails on a cycle, a missing workflow and an edge to a seat that does not exist. It runs in the pre-commit hook and reports; a strict setting makes it block.
Today it prints OK and lists all 11 edges as unorderable. It prints one line per edge it could not compare, so an unchecked edge is listed, never passed in silence.
The schedules moved on the founder's word. On he put the Chief of Staff on a run every two days, because a weekly run was too slow to debug against while the Collective work was live. The check that had gone red on a Tuesday briefing in July passed this change: it could no longer place the briefing on a week, so it listed every edge into and out of it as unorderable and printed OK. On September 23 he asked for seven more seats on every three days, a change that landed the next day, because a seat that runs once a week gives one look a week at a harness that changes every day. Both are sprint cadences, and every changed cron carries a comment saying to revert it when the sprint closes.
Three programs that read the clock were taught the new schedules in that change: the liveness check, the run-truth check and the alert writer. The order check was not, and it still reads only weekly crons, so it can place neither end of any edge. The Chief of Staff's cron is now "0 13 */2 * *" and the Inspector General's is "0 14 3-31/3 * *". Finance and Security have no cron at all and run when dispatched.
On those schedules the order is not only unchecked; on some days it is inverted. Expanded over a 31-day month, Innovation and Quality start on the same UTC day as the briefing and after it on 6 days, so on each of those days the briefing reads their previous report while a new one lands later that day. The check prints OK through all of it.
An OK line with every edge unorderable reads like a pass. It is not one. On today's schedules the declared order rests on nothing a guard compares.
Where does work fan out and fan in today?
Fan-out is work splitting into parallel branches. Fan-in is those branches joining again into one step. In the seat graph, work only fans in: no seat sends work out to others.
Most departments start on schedules of their own. Operations and Revenue run together, in one workflow on one schedule, and Finance and Security have no schedule and run only when dispatched. They are independent branches: no seat starts another, and nothing waits for them.
The join is a clock. 10 departments fan into the briefing, and the briefing's workflow has no trigger on their runs: it starts on its own cron and reads whatever reports exist. Its prompt tells it to give a seat with no report one line, "Quiet this cycle.", and to name every seat so none is dropped in silence. That is an instruction to the agent, not a mechanism that checks it.
Outside the declared seat graph, two fan-outs wait for all their branches, and a third has not yet been exercised:
- The test suite. On every push to main, CI splits the unit tests into parallel batches, and one final job waits for all of them and fails the run if any batch failed or was cancelled.
- The adversarial showcase review. It is a design review a person starts. For each surface it reviews, several refuter agents attack that surface's findings in parallel, and the review waits for all of them before it grades the surface. Its recorded runs end .
- The swarm. The founder's console can send one command to several seats at once, a fan-out we call a swarm, planned by packages/collective/src/swarm-plan.mjs. One swarm command is on record, from . It went to one seat, so the fan-out has not been exercised on record, and its outcome is not recorded.
Between seats the join is a clock, and a missing input is named only because a prompt asks for it. Fan-in that waits for every branch is the design section below.
Which graphs does the code itself obey?
The code obeys graphs of its own, each with a guard in the repository's tests and hooks:
- The import graph of every deployed function. Vercel once refused a deploy at 1.15 GB against a 250 MB limit because a route reached a script whose command-line guard made the file tracer package the whole repository. A test now walks every route and page entry's imports and refuses a module that feeds a filesystem call a path from the process arguments or the module's own location.
- The cycle graph of the application code. scripts/check-boundaries.cjs freezes the count of circular imports as a baseline. A new cycle above it blocks the commit; the ones already there warn; a strict setting would drive the count to zero, and CI does not set it today.
A baseline stops growth. It keeps today's cycles, and the import test sees only the hazard it scans for.
Which cycles and self-correction loops does the graph allow?
The seat order is a DAG, a directed acyclic graph. The clock check fails on a cycle among the declared edges, though in the pre-commit hook it only reports; it would block under a strict setting nothing sets today. Among the agents, the only cycles are loops, and each self-correction loop we run has a bound and a judge outside it. A loop that grades its own work is the weak form; here the judge is a commit, a check or a second model.
- The handoff loop. An agent works a capped number of turns, writes a handoff, a note for the next session, and commits it. The next iteration starts from the newest committed handoff, so the cycle runs through the repository. Its gate is a new handoff commit, never the agent's word, and its turn cap and budget are in the next section.
- The repair loop. A failed check opens a repair order, and a repair worker runs it under a job timeout and a turn cap, both set in .github/workflows/org-repair.yml, and a cap on attempts inside that one order, set per detector in docs/org/repair/order-policy.json. Issuing a new order after a failed one is not automatic. One finding on record drew three orders: the pulse bot opened the first on , the worker itself failed twice, and each time a new order was issued by hand from a session working for the founder, and dispatched by hand. The third landed through a pull request on , every gate passing, with the check read red before the fix and green after it. The founder merged it, so a person closed that loop.
- Cross-model review. Codex writes and Claude grades: a cold review in a fresh context, then one rewrite round. One model drafts and another grades, which is an evaluator and optimizer loop. On a design, scripts/check-review-budget.cjs counts the cold reviews and holds them to the limit decision D-0062 set. On a code contract the one rewrite round is a written rule, and no program counts it. More on cross-model review.
A judge outside the loop is not proof the loop corrected the right thing. The one repair a separate check has credited was merged by a person, and nothing here measures whether a retry fixed the cause or only the symptom.
What stop conditions and budget caps end a loop?
The handoff loop, which runs unattended, has four stops that do not need the agent to agree: a turn cap (max turns), a weekly budget cap, the kill switch and a daily push cap. A seat run has a turn cap, a job timeout, the kill switch and bounded push retries. No seat has a budget cap yet: its budget is unset until plan row P1-15 measures per-seat spend. The scripts and workflows that run each loop enforce its stops; none is left to its prompt. Cross-model review, which a person runs, is bounded by a written rule instead. Each stop below is installed and has its own test. The last column says only what the record shows a stop doing, never that it runs now:
| Stop | Where it is set | What it ends | Seen firing on record |
|---|---|---|---|
| The turn cap | scripts/handoff-loop.sh, 48 turns per iteration by default (200 until ). The run is told its cap and asked to hand off first; that request is advice, and the cap is the stop. | The iteration in progress. Whenever an iteration leaves the tree dirty, at the cap or not, a short closer run with its own smaller turn cap commits the finished work that iteration wrote and records the rest in the handoff. If the closer leaves the tree dirty, the loop stops. | The snapshot holds 155 readable runs, 138 iterations and 17 closer runs (4 more run files could not be read), and 24 of them ran into the turn cap they were given instead of handing off first. The record does not say how many of those were closers. It spans , when the iteration default moved from 200 turns to 48, and does not say which cap each of the 24 hit. |
| The weekly budget cap | loop-budget.mjs, which adds up the loop's own run files against a number the founder sets, before every iteration. | The loop. A budget file that does not validate stops it rather than letting it run unmetered: the cap fails closed. | 1 budget stop, on Sep 25, 2026, when the budget file could not be read. No run went over budget. |
| The kill switch | docs/org/HALT stops every seat and the handoff loop; a department's file stops its seats, and a seat's own file stops that seat. A supervised re-run a person dispatches proceeds past a seat's file, never past the global one. More on the kill switch page. | A seat's launch and its landing: the org-agent action checks the files before the run starts and again before it pushes, so they do not interrupt work already in progress. The repair worker checks inside its run. The handoff loop checks before every iteration, on its tree and on a fresh fetch of main, and a failed read stops it. | No recorded loop run ended on a halt file. The one attended halt drill on record, on , stopped a repair run partway through, which the repair worker allows because it reads the files inside its run, and the resume was observed. |
| Bounded push retries | scripts/push-main.sh tries 3 times when main moves under it, and the bound holds even when its environment asks for more. A seat's own push step tries 3 times, with a rebase between. | The push. The script stops and says so, the seat's step fails loudly, and neither ever forces. | A weekly canary forces a real push collision against a canary ref, never main. On it logged a rejected push and landed on the second attempt. |
| The daily push cap | scripts/lib/loop-land.sh counts the pushes to main that UTC day by the account the loop pushes as, one per pushed head commit, the owner's own pushes included. | The landing, deferred once there are already 8 that day, its default. | Not on record. It was built after the snapshot's last run. |
| A seat's turn cap and job timeout | Each seat's spec. | That seat's run. | On the content seat ran out of turns with a publishable draft in its tree (lesson 80). |
What has been seen running: a snapshot of the unattended loop's record, cut on Nov 3, 2026, counts 138 iterations. The loop runs in stretches, each one start of the loop given a number of iterations to run; the last stretch in the snapshot ended Sep 26, 2026, and 1 stretch ended at the number it was given.
Installed and tested is not running. The loop's last recorded run ended Sep 26, 2026; whether it runs now is not observed here, and nothing here measures whether a stop fired at the right moment.
How does this map to the patterns agent builders use?
Three public descriptions of agent graphs, and where this one sits against each:
- Anthropic's Building effective agents () names five workflow patterns. The showcase review's refuters are its parallelization by voting: the same check run several times and the verdicts aggregated. The test batches in CI are parallelization by sectioning: one job split into parts that run at once. Cross-model review is its evaluator and optimizer loop, one model drafting and another grading. The seat graph is nearest its prompt chaining, where each step reads the one before it and a programmatic gate can check an intermediate step. Here the steps are seats joined by a clock rather than a handoff, no orchestrator dispatches them, and the clock check is a gate on the schedule, not on the outputs.
- Anthropic's How we built our multi-agent research system () describes a lead agent that waits for each set of subagents to finish before it goes on, and names that wait as a bottleneck. The join in the design half below would accept the same cost on purpose, because the briefing's failure today is reading too early, not waiting too long.
- LangGraph's graph API runs a graph in super-steps: nodes that run in parallel share one super-step, and the nodes they feed run in a later one. That is the join the design half asks for, applied between seats.
The mapping is ours. None of those authors has reviewed it.
Design: can the record become a graph the replay walks?
Each section below starts with what runs today. Everything after "The design" or "Being built" does not run yet.
- What runs
- Every day at 00:00 UTC, about 6:00 PM Central, a script with no AI in it replays a proposed rule over the committed run record and scores what the rule would have changed, without adopting it. It has written 51 receipts. It reads the run rows, the review series and the recorded corrections.
- Being built
- The Machine is being built to link each finding to its failure class and to the lesson proposed for it, so that a lesson counts as an improvement only when a replay of its original failure, plus a clean case, shows it. No lesson has been proposed yet, so that replay has not run. Joining the guards that mechanize those lessons, and the catches they make, into one graph a replay could walk from a failure to the guard that now stands in its way has no plan row behind it yet. That walk would belong to recursive self-improvement.
Design. No replay walks from a failure to its guard today; the receipts read run rows, reviews and corrections only.
Design: how should fan-in wait for every parallel branch?
- What runs
- The fan-in is a clock, as the fan-out and fan-in section above says. The briefing starts on its own cron and reads whatever reports exist.
- The design
- A join that starts the briefing when every declared input has landed, and that stops with the missing input named when one has not, so a partial failure is a named stop instead of a quieter briefing. The order becomes an event the graph waits for, not an offset it hopes for.
Design. No plan row commits to it yet. Today the briefing does not wait for its inputs.
Design: what would route a task to a seat?
- What runs
- No router by lane. The console's swarm sends each red item to the seat the console says owns it; otherwise each seat runs on its own trigger, and its spec declares the paths it may write.
- The design
- Routing by those declared lanes, so a task names the paths it touches and the graph sends it to the one seat whose lane holds them, or to the founder when none does.
Design. No plan row commits to it yet. Nothing routes work by lane today.
Design: how does a stopped graph resume?
- What runs
- A stopped loop resumes from the newest committed handoff file, and the loop's gate is a new handoff commit, never the agent's word. That is on long-horizon agents.
- The design
- A checkpoint per node, so a graph stopped halfway resumes at the first node that has not landed instead of rerunning from the top.
Design. No plan row commits to it yet. Today the checkpoint is one handoff per loop iteration, not one per node.
Where does graph engineering fail?
Where the graph is a declaration and the schedule is a habit. We have both written down and a checker that compares them, and the schedule has moved to a cadence the checker cannot read.
The fix is a check that reads the schedules the seats are actually on: expand every cron over a month and refuse any day a seat starts at or before an input it reads. This page's generator makes that expansion to count the inverted days; no guard does. Or make the order an event instead of an offset, which is the design half of this page. A rule that must be remembered is weaker than a check that refuses, which is the argument of harness engineering.
Graph engineering questions? Answers.
Related reading
- Long-horizon agents
How work keeps toward one goal across sessions, and why the loop's gate is a commit, never the agent's word.
- Recursive self-improvement
How the Machine recovers, replays one proposed rule over its record once a day, and has a judge report whether each guard held.
- The kill switch
How the Machine is stopped, with the dated record of its halts.
- Harness engineering
How agent mistakes become standing instructions, tests, checks and gates.
- All Orbyt Labs methods
Every method page, each with its dated public record.
Cite this page
Cite this page for the practice and follow its sources for the underlying records.
Bartak, J. (2026). Graph Engineering. Orbyt Labs Research. https://