The Intent Graph
Throughput Accounting and Critical Chain in a Structure Without a Future
Kenneth Tyler • three.horse
Part 1: What the Intent Graph Is
Most project management systems separate the work from the knowledge about the work. The task tracker holds what needs doing. The test suite holds what done means. The dependency graph holds what unblocks what. The financial model holds what the work is worth. And the history of decisions lives in documents, meeting notes, and people’s heads.
The intent graph unifies these into a single queryable structure. Every node carries its own completion criterion, its own dependency chain, its own history of what was produced, and its own throughput value. Nothing is reconstructed from memory. Context is structural.
Nodes
There are six node types:
Term
Meaning
Intent
A commitment: something that needs to exist. Carries a mandatory, verifiable test condition. The test condition IS the intent — name and description are human-readable labels, but the test is the operative claim.
Expression
A concrete artifact produced: code, a document, a decision output, a record. Connected to the intents it satisfies via satisfies edges. One expression can satisfy multiple intents; one intent can be satisfied by multiple expressions.
Gap
A detected blocker where the test condition cannot yet be articulated. The andon cord. Notes carry everything the actor does know: what was encountered, what makes the test unwritable, what resolving it requires.
Decision
An authored closure. Records what was chosen, what alternatives were considered, and what scope the choice governs. Closes gaps via closes edges.
Signal
An external event that has already happened or is structurally expected. The graph’s write surface for the environment. No test condition — the event is a fact, not a commitment.
Compose
A structural grouping satisfied automatically when all its children are green. No hand-written test condition needed.
Edges
There are seven edge types:
Term
Meaning
blocked-by
Dependency: this intent cannot be worked until its dependencies are green. Workability is derived at query time by checking whether all blocked-by dependencies have incoming satisfies edges.
satisfies
Completion: an expression node connects to the intents it satisfies. An intent with at least one incoming satisfies edge is green.
supersedes
History: a new node replaces an old one. The old node remains in the graph. Current state is derived from supersession structure — the non-superseded node is the current tip.
closes
Resolution: a decision node closes one or more gaps.
contains
Composition: a compose node groups children whose collective completion satisfies the parent.
tensions-with
Conflict: two nodes pull in different directions. Surfaces coordination needs.
refines
Specificity: one intent is a more detailed version of another.
The Red/Green Model
The graph is a test suite at the architecture level. Every intent is a test:
• Red: intent exists, no incoming satisfies edge. Work remains.
• Green: intent exists, at least one expression satisfies it.
“What to do next” = “what’s red.” The same red-green cycle as Test-Driven Development, lifted from the function level to the intent level. Whether a red intent is workable right now is a structural question: are all its blocked-by dependencies green? This is a query result, not a stored state. No status fields. No scheduling algorithms. The structure answers the question.
The foundational stance
There is no future state in the graph. A red intent is not a plan — it is a hole in the present. It says “this needs to exist and doesn’t yet.” The future state is simply “everything green.” The graph accumulates intention write-only: superseded intents remain as history, never deleted. Current is derived from supersession structure.
LLM Legibility as a Design Commitment
The intent graph is designed so an LLM can arrive at any node cold, read its projection — test condition, expression history, dependency chain, open gaps — and immediately know what the project needs and what done looks like. This is not incidental.
Organizational processes have always had structure: dependency ordering, completion criteria, decision records. But that structure has lived in formats designed for human reading — Gantt charts, Jira tickets, meeting notes — that LLMs can parse but cannot traverse structurally. The intent graph encodes process in a form LLMs can natively reason over: query what’s red, build a projection, identify the workable intents closest to the critical path, reason about constraint and throughput without a human assembling that picture first.
Every expressed intent leaves machine-readable organizational description behind. The knowledge that used to crystallize in people’s heads crystallizes instead in a graph that LLMs can traverse, query, and reason over directly. The graph is the organizational memory.
Part 2: Throughput Accounting in the Intent Graph
Goldratt’s Throughput Accounting collapses the financial world into three categories:
Term
Meaning
Throughput (T)
The rate at which the system generates money through sales. Revenue minus truly variable cost — not allocated overhead.
Investment (I)
Money tied up in the system: inventory, equipment, buildings.
Operating Expense (OE)
Money spent turning Investment into Throughput: salaries, rent, utilities. Flows whether or not any particular production run happens.
The intent graph represents all three, but the representation is structural rather than ledger-based. The financial picture falls out of traversal rather than from a separate accounting system.
Throughput on Intents
Every intent node carries an optional throughput value: expected revenue or value when this intent is satisfied. This value propagates through the dependency structure. The total downstream throughput of satisfying an intent is its own value plus the value of every intent it unblocks downstream.
This is Goldratt’s core question answered by the graph itself: which work generates the most throughput? No separate financial model. The same dependency edges that determine workability also carry the value signal. Project the constraint against throughput and you have throughput-per-constraint-unit without a spreadsheet.
Example
Intent A has throughput value $50K. It is blocked-by Intent B ($0 direct value) and Intent C ($30K). Satisfying B unblocks A which unblocks three downstream intents worth $200K total. B’s effective throughput contribution is $200K + $50K = $250K — visible in the projection before a single line of financial analysis is written.
Operating Expense as Recurring Obligation
OE doesn’t get “done” in the way a production intent does. Payroll for March satisfies an obligation that immediately resets for April. The graph handles this through the supersession chain with a period trigger.
“March payroll obligation” is an intent satisfied by the expression “payroll disbursed March 31.” Then “April payroll obligation” supersedes it. The non-superseded node at any moment is the current open obligation. The chain is the full disbursement history. The current tip is always red until payment, green briefly, then superseded and red again. The gap between green and the next red is the payment window.
OE as Constraint Capacity
The more important representation of OE is not the obligation chain but the capacity structure. In the graph, OE intents that are blocked-by production capacity intents are load-bearing: the salary of the machine operator, the lease on the production floor. Remove that OE and you remove production capacity, which reduces Throughput. These have real downstream dependency edges.
OE intents with no production dependency edges are pure overhead — they consume cash without being structurally connected to anything that produces Throughput. The dependency mapping is the graph doing automatically what Goldratt expected a human analyst to do manually with a Current Reality Tree: showing which expenses are load-bearing for Throughput and which are not.
Opportunity Cost: The Machine That Produces Three Products
This is where the graph is most distinctive. Consider a machine that can produce products A, B, and C. At any moment it is producing one and not the others.
In conventional operations, opportunity cost requires separate analysis: someone notices the machine is running B while A orders wait, calculates the throughput differential, and presents it as a finding. That analysis happens outside the system tracking production.
In the intent graph, the opportunity cost is already in the structure. Every product the machine could be producing but isn’t is a red intent with a throughput value, blocked by the machine capacity constraint. The machine is the agent scope. The queue of red intents in that scope, ordered by throughput value, is the opportunity cost register. It is not computed — it is read directly from the projection.
• When the machine runs B: A’s intent is red and workable but unscheduled. The throughput differential between A and B is visible in the graph at all times.
• When the machine is idle: every workable red intent in scope is pure opportunity cost, weighted by throughput value and visible immediately.
• When the machine runs the wrong product: the decision node that scheduled it should record the alternatives and their throughput values. If it doesn’t, that’s a governance gap — surfaced by the graph, not hidden inside a production schedule.
The idle machine case is the clearest expression of Goldratt’s core insight: the cost of the constraint is not its OE lease. It is its opportunity cost — the throughput of the highest-value product it could be running in any moment it is not running it. The lease is sunk. The opportunity cost is live and structural.
The Scheduling Decision as Decision Node
Every time a human or agent chooses which product runs next, that is a decision node. It records what was chosen, what the alternatives were, what the throughput differential was at decision time, and what governed the choice.
Conventional production systems record what ran. They do not record what didn’t run and what that cost. The intent graph records both: the expression on the chosen product and the continuing redness of the unchosen ones, with throughput values on both sides of the decision. This is the complete opportunity cost ledger — accumulated automatically, without a separate analysis step.
Speculative Production and the Revenue Gap
When production runs ahead of confirmed demand — the corn farmer planting in April against an assumed September price, the factory running a batch against a forecast — the graph forces an honest structural representation.
The production intents are real and present: planting, fermentation, QA, logistics — each with verifiable test conditions, each turning green when satisfied. The downstream intent “sold at target price” cannot carry a real test condition because the counterparty doesn’t exist yet. In the graph’s ontology, that is a gap, not an intent.
The gap’s notes carry the forecast: expected price, expected volume, expected timing, the reasoning behind the assumption. The assumed throughput value sits in the gap’s notes rather than on a green intent. The gap stays open until a real contract closes it via a decision node and a signal fires when the buyer commits.
The diagnostic value
Show me all production intents whose downstream revenue node is a gap rather than a contract-backed intent, and you have your speculative exposure register — derived from structure, not from a separate risk analysis.
Part 3: Critical Chain and Drum-Buffer-Rope
The intent graph does not implement CCPM and DBR as scheduling algorithms layered onto the structure. It makes them emergent properties of the structure itself. The drum, the buffer, and the rope are not imposed — they are read.
The Drum: Constraint as Queryable State
In classical CCPM, the constraint — the drum — must be identified by observation: where is the queue longest? The Five Focusing Steps are a sequential loop because you can only see one constraint at a time.
The graph makes the constraint queryable. queryIncomplete filtered to each agent scope, ordered by throughput-weighted queue depth, surfaces the constraint directly. The drum is the agent scope with the highest ratio of workable red intents to capacity. No observation required. No waiting for a bottleneck to manifest as a production problem.
More importantly, the graph makes constraint migration predictive rather than reactive. When the current constraint is elevated — its queue clears — the next constraint is already visible as topology: the agent scope with the next-highest queue depth. You see the emerging bottleneck in the projection before it becomes a queue. The Five Focusing Steps become a continuous read rather than a sequential loop.
The Buffer: Workable Red Intents Upstream of the Constraint
In classical CCPM, the buffer is a time buffer — work released early enough that the drum never starves even if upstream operations have problems. You size it by estimating variation in upstream lead times.
The graph’s equivalent is the set of workable red intents immediately upstream of the constraint scope — intents whose blocked-by dependencies are all green and which are therefore ready to enter the constraint but haven’t been assigned yet. Buffer depth is a count of those intents, weighted by throughput values.
The graph improves on time-buffer sizing in one specific way: instead of estimating upstream variation statistically, the gap accumulation rate on upstream intents IS the variation signal. Upstream operations producing gaps at high rates are unreliable feeders. The graph shows this directly rather than requiring a historical analysis of lead times.
Buffer health in CCPM terms is the rate at which the upstream queue is replenished versus consumed. In the graph: rate of red-to-green transitions in the buffer zone versus rate of gap creation in the same zone. No separate metrics system. The graph is the metrics.
The Rope: Blocked-By as Self-Enforcing Release
In classical CCPM, the rope is the release discipline: don’t start upstream work until the drum is ready for it. Someone enforces this by holding work orders.
In the graph, the rope is the blocked-by structure. An intent that is blocked-by a constraint-scope intent cannot become workable until the constraint processes its dependency. You need no separate release mechanism. Upstream agents running queryIncomplete on their scope only surface workable intents — intents whose blocked-by constraints are green. If the constraint is backed up, its downstream intents remain red, which means the intents blocked by those downstream intents are also not workable, which means upstream agents have nothing to pick up.
The rope is self-enforcing through the dependency structure. It does not require a scheduler to hold work orders or a manager to police release timing.
Throughput Ordering: Beyond FIFO
Classical DBR processes the buffer in first-in-first-out or due-date order. The drum processes whatever arrives first.
The graph adds throughput ordering. Workable red intents waiting at the constraint are ordered by downstream throughput value — the sum of the intent’s own value plus everything it unblocks. The constraint should process highest-throughput-first, not first-in-first-out. This is Goldratt’s throughput-per-constraint-unit question answered automatically by the projection, without a separate prioritization process.
Every moment the constraint runs a lower-throughput product while a higher-throughput product is workable in the buffer, the graph is recording that opportunity cost structurally via the continuing redness of the unchosen intents. The decision nodes capture when and why those tradeoffs were made.
Multi-Constraint Topology
DBR traditionally handles one constraint at a time. The graph handles multiple simultaneous constraints naturally because each agent scope has its own queue depth and throughput weighting. You can project across all scopes simultaneously and see the full constraint topology: where the primary drum is, where the next constraint will emerge when the current one is elevated, and what the interdependencies are between constraint scopes.
This is drum-buffer-rope extended from a scheduling discipline into a continuous structural read. You are not running the Five Focusing Steps. You are reading the constraint topology from the graph’s current state and making elevation decisions with full visibility of their downstream consequences before you make them.
What Still Requires Human Judgment
The graph does not replace judgment. It restructures where judgment is applied.
• Buffer sizing: The graph shows current buffer depth and replenishment rate, but the decision about how much buffer is enough is a decision node. It depends on risk tolerance, the consequences of constraint starvation, and the cost of holding work-in-progress. The graph records the decision and surfaces when actual depth deviates from the decided target. The monitoring is automatic. The sizing is deliberate.
• Rope tension: The blocked-by structure enforces the rope, but the decision about how tightly to couple upstream release to constraint consumption — whether to allow slack, whether to pre-release speculatively — is a decision node whose consequences live in the graph.
• Throughput elicitation: Throughput values on intents must be set by someone. The graph carries the values and propagates them structurally, but it does not solve the elicitation problem. QFD practitioners know how hard customer priority elicitation is. This system assumes someone supplies the values.
• Joint cost allocation: When a constraint serves multiple products, the graph shows the structural dependency clearly but doesn’t derive an allocation rule. The allocation is a decision node — a deliberate choice recorded with alternatives considered and scope governed, rather than a fact computed from structure.
Summary
The intent graph does not implement Throughput Accounting and Critical Chain as overlays on a project management system. It makes them structural properties of the same representation that tracks what needs to exist, what depends on what, and what has been produced.
Throughput propagates through the dependency edges that determine workability. The constraint is the agent scope with the most queued red workable intents. The buffer is those intents in priority order. The rope is the blocked-by structure that prevents upstream overproduction. The opportunity cost register is the set of red intents with throughput values that sit in a constrained scope while something else runs.
None of this requires a separate financial model, a scheduling algorithm, or a resource leveling spreadsheet. It requires a graph whose nodes carry test conditions and throughput values, whose edges carry dependency and satisfaction relationships, and whose current state is always queryable by any actor — human or LLM — who needs to know what to do next.
The deepest claim
What Goldratt always needed — and rarely had — was a live, queryable representation of the full constraint system that updates in real time as work moves through it. The intent graph is that representation. Throughput Accounting and CCPM are not imposed on it as methodology. They are what it looks like when you read what the graph already shows.
Kenneth Tyler