What the rebuilt work runs on

The Operating System

An organization that runs agents needs eight things it never had to write down while humans did the work, and one loop that makes those eight things compound. This is the theory behind steps five and six of the method: what gets captured, and what the rebuilt workflow runs on.

See the eight primitives

01 · The shift

From the file cabinet
to the task board.

For forty years, since the first Macintosh, we have used computers the same way: store, open, edit, save. With agents the primary object is no longer a file but a task. You do not open a document and edit it; you declare an outcome and something executes it.

1984 – 2024 · The file cycle The file cabinet StoreOpenEditSave Files are the primary object. Apps act on files. Storage is the central metaphor. You own data and manipulate it.
2025 → · The run cycle The task board DeclareDelegateMonitorConclude Tasks are the primary object. Agents act on tasks. Activity is the central metaphor. You declare intent and supervise execution.

This matters for a reason that is easy to miss. When computers were file cabinets, organizational intent never needed to be written anywhere: a human was in the loop at every step and applied judgment in real time. When computers become task boards, whose judgment the agent uses becomes the question. If the organization has not encoded its intent, the agent substitutes its own: whatever the optimization rewards, whatever the training data suggests, whatever moves the metric.


02 · The gap

Context answers "how."
It never answers "should I."

The industry has spent three years on context engineering: the right data, tools and instructions at the right time. That work matters. But context does not answer "what matters more when two good things conflict?"

Support The Klarna assistant It resolved tickets faster than any human team and damaged customer relationships while doing it. Not because it failed at its task: because it was never told what the company cared about, so it optimized for the one thing that was measured, resolution speed.
Procurement 12% or 4% A 12% saving with vendor lock-in, or a 4% saving that keeps optionality. Context gives the agent the price history. Which tradeoff the company prefers is a values problem the agent was never given.
Hiring The rules are all it has The candidate misses the stated criteria and brings exactly the unconventional background the company says it values. The agent follows the rules, because rules are all it has.

Companies have invested billions in making agents capable.
Almost nothing in making them wise.

The reflex, when agents misbehave, is more rules, more edge cases in the prompt, more checkpoints. That treats an architecture problem as an information problem. What is missing is not data. It is a place in the system where the organization's intent lives in a form agents can read, check and be held to.


03 · Eight primitives

The building blocks.

Eight things the system has, not features it offers. The test that makes them a set: if something the organization does cannot be expressed as a combination of these eight, the design is wrong, not the set. They fall into four layers.

User layer one primitive, because the user sees one thing
Task The atomic unit of work The object that replaces the file. Declared by humans and by agents, with provenance either way. Whether a human sees a task at all is a gate decision, not a screen: the board gets quieter as the mandate grows.
Knowledge layer three primitives; none produces aligned behavior alone
Playbook How · prompt engineering How work gets done: versioned, executable, with the reasoning behind each step. Everything operational is a projection compiled from it, never authored beside it.
Memory What · the heap, not folders Working memory is the thread and the task at hand: complete, unrefined, consumed. Retrieved memory is the gardened heap: flat blocks, indexed by meaning and entity, connected rather than filed. It compounds.
Foundation Why · intent engineering What the organization actually optimizes for, made machine-readable: tradeoff hierarchies, decision boundaries, value signals, red lines, escalation triggers. Changed only by leadership review.
Context engineeringIntent engineering
Vocabulary layer one primitive every other one references
Ontology The canonical vocabulary Entity types, instances with aliases, typed relationships, and the domain taxonomy that scopes everything else. Without it every primitive invents its own words.
System layer three primitives nobody sees and everything depends on
Dispatch Routing and the confidence ramp Queues, prioritizes and routes work to the right capability, human or agent, without ever losing a request. Per domain: declare, delegate or autonomous mode. Never one global dial.
Policy Gate Deterministic governance Every significant action gets one of four answers: allow, deny, review, confirm. This is where the Foundation becomes executable. There is no fast path around it.
Event Append-only truth Everything that happens is recorded once and never edited. The audit trail, the timeline, and the raw material for learning. Interpretation changes; the record does not.

What is not a primitive. A workflow is not a ninth primitive; it is a projection of a procedure playbook walked by dispatch. A schedule is a projection of a playbook. Connectors, channels and documents are ways into the eight. Every time one of them is promoted to a primitive, a second source of truth appears beside the playbook or the event log, and the property that made the system portable and auditable leaks out through it.

Append-only truth The record of what happened is never modified, only added to.
Governance by default No action bypasses the gate. Trust is earned per domain, never assumed.
Heap over hierarchy Knowledge and tasks are flat, tagged and viewed many ways. Structure emerges from connections, not from where something was filed.
Foundation as substrate Every procedure references it, every gate enforces it, every alignment metric measures against it.
04 · The Foundation, in detail

Values. Tradeoffs.
Decision boundaries.

If context engineering gives agents the right information, intent engineering gives them the right judgment. The Foundation is the answer to "what does this organization actually optimize for?", made machine-readable. Five components.

Tradeoff hierarchies When X conflicts with Y, prioritize Y under conditions Z. “For customers of more than three years, relationship beats resolution speed.”
Decision boundaries What agents decide alone, confirm, or hand over, scoped by domain and risk. Not one autonomy dial.
Value signals Real stories of how the organization behaved when it mattered. The training data for judgment.
Red lines What is never done, whatever the metric. “Never commit to pricing without a human.”
Escalation triggers Not only “when uncertain” but “when the decision touches who we are”: a board member, a precedent, a policy being reinterpreted.

The Foundation is captured deliberately, through dilemma workshops, decision autopsies and story collection, validated by leadership, and versioned. It changes only through explicit leadership review. Agents surface candidates. They never edit it, because an organization whose values are optimized by its agents becomes whatever its agents found works. That is the Klarna failure with extra steps.

05 · The learning loop

Two loops.
One inside the other.

The eight primitives are nouns. Two loops run over them. The run cycle is how work runs every day, and it changes no rule. The learning loop starts only where the run cycle hits an exception, and it is the only loop that changes the rules.

Two loops, one inside the other An inner ring, the run cycle: declare, delegate, monitor, conclude. An exception leaves it at monitor and enters an outer ring, the learning loop: exception, clarify, capture, prove, delegate, with a gate between prove and delegate. The run cycle how work runs every day Declare Delegate Monitor Conclude The learning loop the only loop that changes the rules Exception Clarify Capture Prove Delegate
The run cycle Declare, delegate, monitor, conclude. It moves across Task, Dispatch, Policy Gate and Event, and the event log records it without anyone doing anything. It consumes the rules; it never changes them.
01 Exception An agent meets a situation its playbook, memory or mandate does not cover, or a human overrides what it did. The event log records it without anyone doing anything. The loop starts for free.
02 Clarify A human answers, one of four ways, and the kind decides everything downstream: how (a step was missing), why (a tradeoff the Foundation had not spoken to), you may not (a boundary), or not knowledge (a capability or permission the agent does not have).
03 Capture The answer lands in the primitive it belongs to. A how becomes a playbook line. A why becomes a Foundation candidate for leadership to validate. A you-may-not becomes a gate rule. A not-knowledge becomes a task with a named owner.
04 Prove The change is measured against the old way before it is trusted: an evaluation replayed from the event log, a shadow run beside the human, an override rate that falls. Nothing moves on the strength of having been written down.
05 Delegate The mandate widens through the gate: one notch, in one domain. Route one percent of the work, then ten, then all. Seen from the human's side, fewer tasks surface. The board gets quieter as the mandate grows.

Learning is not a step.
It is what a cycle leaves behind.

One metric The override rate, per domain: how often does a human correct the rebuilt work? A falling rate is the proof that a capability is being learned rather than a demo being polished, and the only honest input to the delegate step. It is the same number the method's step six runs on.
Three things get learned Know-how lives in playbooks and memory. Can-do lives in tools and code. May-do lives in the mandate and the Foundation, and is gated by the owner alone, never by automation. What compounds is the third: the share of work that runs without a human touch.
The loop nests When the answer is "not knowledge", the capture is a task, and that task runs the same five steps one level down. An agent that says "to handle this I need a tool I do not have" has filed a requirement through the same primitive a human uses to ask for anything.

06 · The same eight, everywhere

One theory. Three vocabularies.

None of this requires software. A well-run company already has all eight, unwritten. The moment an agent carries part of the work, whatever it needs of the eight must exist outside a head. That is the whole claim, and it is why the same set describes a company of one and a company of a hundred thousand.

Primitive In a company, unwritten In a code repository In one workflow, rebuilt
Foundation How senior people decide when two goods conflict; the lines never crossed The vision file; the constitution's laws The firm's real tradeoffs, written down in the capture step
Playbook How work is actually done, held by whoever has been there longest The agent file, the delivery procedure, the style file, skills Your senior people's judgment, captured as playbooks
Memory Who knows what; the shared drive; the CRM Project memory; the heap the agent reads What the workflow learns each time it runs, kept inside the firm
Ontology The shared meaning of “a client”, “an account”, “done” The glossary The shared meaning of every part on the map
Task Whoever's list the work is on The product file, goals, pull requests The mandate, and each unit of work the agent takes
Dispatch Whoever assigns work The orchestrator; the read order and review roles The ramp: one percent of the work, then ten, then all
Policy Gate Signatures; “check with me first” Machine checks in CI; human gates on merge What the agent decides alone, confirms, or hands over
Event Email; minutes Git history; decision records; traces The shadow run's record, against benchmarks set before the run
The learning loop A retrospective that changes a procedure Failures fed back as cited rules Every override: a deletion candidate first, training data second

A tool harness is fifteen tools plugged into a chat. A business harness is one model of how your business works, exposed once: the eight above, with the loop running over them. The same eight are also the data model of the software I build on. That is a product; this page is the theory it depends on, and the theory stands without it.


Where this sits in the method

Steps five and six.

05
Capture what survives

Your senior people's judgment captured as playbooks, the firm's real tradeoffs written down as a Foundation, each remaining task scored for what an agent can take. This is where the primitives get written down for one workflow.

06
Build at the edge and prove

The rebuilt workflow runs in the shadow of the old one, against benchmarks set before the run, and earns the work one percent at a time. This is the learning loop, with the override rate as its pulse.

The full sequence

Questions

Straight answers.

Do I need software to have an operating system?

No. A well-run company already has all eight primitives, unwritten: its Foundation is how senior people decide when two good things conflict, its playbooks are how work is actually done, its memory is who knows what, its gates are the signatures and the “check with me first”, its event log is email. Humans carried all eight in their heads, which is why nobody had to write them down. The moment an agent carries part of the work, whatever it needs of the eight must exist outside a head. That is the whole claim.

Is this the same as context engineering?

No. Context engineering gives agents the right data, tools and instructions at the right time, and it answers “how do I do this?”. It does not answer “should I?” or “what matters more when two good things conflict?”. That is the Foundation's job, and it is a separate primitive because a thousand-word system prompt about company values does not stop an agent from optimizing for whatever is most measurable.

Why can't the agents update the Foundation themselves?

Because an organization whose values are optimized by its agents becomes whatever its agents found works, which is the Klarna failure with extra steps. Agents and automated learning surface candidates; leadership validates or rejects them. The Foundation and the mandate are the two things the loop is forbidden to change by itself.

What is the one number to watch?

The override rate, per domain: how often a human corrects the rebuilt work. A falling override rate is the proof that a real capability is being learned rather than a demo being polished, and it is the only honest input to the decision to widen an agent's mandate. It is the same number the method's step six runs on.

Is a workflow a ninth primitive?

No. A workflow is a projection of a procedure playbook walked by dispatch, and a schedule is a projection of a playbook. Connectors, channels and documents are ways into the eight. Every time one of them is promoted to a primitive, a second source of truth appears beside the playbook or the event log, and the property that made the system portable and auditable leaks out through it.


Does your company need this yet?

Five minutes, twelve antibodies, your score. The diagnostic is free and asks for no email. It tells you whether the method, and what it installs, are warranted.

Run the Diagnostic

Sure already? Book Awake.

Why the pilot worked and the company didn't

Field notes on stalled AI transformation, executive judgment, and the specification economy — the weekly letter behind Book 2. About once a week. No spam. Unsubscribe anytime.