Skip to content
The AI Agent Factory

4.1 Six layers, six verbs

Approved by
Panaversity ·
13 min read

In everyday life. Think of a restaurant. The front door and phone line are its channels, and the cook is its runtime. What the cook remembers about the regulars, and which drawer holds the scales, is its memory. The recipe book is its KSoR, and it wins over what the cook remembers. The order tickets on the rail show what each table ordered and what is done, so they are its SSoR. The cashier who checks every order slip before opening the till, and keeps a copy of each one, is its DSoR. The owner sets the menu and reviews the night's takings, as the human principal does. The till, the pantry book and the supplier list are the restaurant's own systems, and they stay the authority on their numbers.

Six layers, explained with a restaurant. Six cards in a row. Channels: the front door and phone line, where customers reach the restaurant, with walk-ins, phone calls, online reservations and delivery apps. Runtime: the cook, who does the work, follows instructions, uses tools and ingredients, prepares the dishes and handles special requests within limits. Memory: what the cook remembers about regulars and where things are kept, customer preferences, where ingredients are, helpful past experiences. KSoR: the recipe book, the authoritative source that wins over memory, with official recipes, ingredient standards and food safety rules. SSoR: the order tickets on the rail, which track what each table ordered, what is being prepared and what is completed. DSoR: the cashier who checks the order slip before opening the till, handles payment, keeps a copy of the receipt and prevents errors. Above the cards, the restaurant owner or manager sets goals and standards, decides the menu and policies, steps in for exceptions and reviews the results. A banner says the cook's memory is helpful, but the recipe book is authoritative. Below, the company systems that remain authoritative: the till, pantry records, supplier records and payment systems.

The six layers, as a restaurant. The cook's memory helps, and the recipe book wins.

Every AI Worker in this book is drawn the same way: six layers, one job each.

LayerIts verbWhat it holds or doesBrightline example
ChannelsconnectWhere people and systems reach the worker: a chat app, team messaging, email, a web portal, an APIThe AP inbox, the team chat
RuntimeexecutesThe replaceable harness that reasons and actsA run of the AI vendor's app, started by a trigger
MemoryremembersContinuity: preferences, experience, where to look"Maria wants the register sorted by due date"
KSoRknowsThe governed, authoritative knowledge: policies, procedures, thresholds, definitionsAP policy, approval limits
SSoRtracksGoverned memory of the work: one case file for each matter, with where it stands, what was tried, who approved what, and whyThe case file for invoice 5120, step by step
DSoRactsThe governed door to real systems: it checks, acts, and keeps the evidenceRegister updates, payment status

Two things sit outside the six layers. Above them is the human principal, who owns the first 10 and the final 10 percent of every task (Chapter 3). For a worker that runs day and night, the first 10 is written in advance, in the worker's definition and its standing instructions, and the final 10 happens at times the person chooses: the flags, the approval queue and the spot checks. Below DSoR are the company's own systems: the accounting system, the bank and the vendor records. They stay the authority on their data.1 DSoR does not replace them. It governs the worker's access to them.

Where is the worker itself? It is not one box. The worker is the Role Contract from Chapter 2 and the records the contract names, and the contract ties the layers together. It names the knowledge sources, the memory rules, the operations the worker may request, the runtime it needs, the channels it serves, and the evaluations that prove it still does the job, each a case with inputs, an expected answer and what passes. Concept 4.9 says why the records are enough.

Six layers, six verbs, the canonical architecture. At the top, the human principal owns the first 10 and final 10 percent of every task. Below it, two rented layers. Channels connect, where people and systems reach the worker, with Brightline's AP inbox, team chat and web portal. Runtime executes, the replaceable harness that reasons and acts. On the dashed line between the rented layers and the company-owned layers, Memory remembers: continuity, preferences, experience, where to look, and Maria wants the register sorted by due date. Below the line, three owned layers. KSoR knows, the governed, authoritative knowledge, with the AP policy and approval limits. SSoR tracks, one case file for each matter, with the case file for invoice 5120. DSoR acts, the governed door to real systems, which checks, acts and keeps the evidence, with register updates and payment status. Under DSoR, the company systems: the accounting system, the bank and the vendor records. A band at the foot names the Role Contract, not a layer, the worker's definition, which ties the six layers together: knowledge sources, memory rules, operations, runtime needed, channels served, evaluations. The last line reads: channels connect, runtime executes, memory remembers, KSoR knows, SSoR tracks where the work stands, DSoR acts.

Figure 4.1. The canonical (standard) architecture. Channels connect, runtimes execute, memory remembers, KSoR knows, SSoR tracks where the work stands, and DSoR acts. Rented layers sit above the line and owned layers below it.

This is the only architecture diagram in the book. The overview shows it once more with its key ideas, and later chapters zoom into one layer at a time. When a chapter introduces a product or a technique, ask one question first: which layer is this?

One run, start to finish

Tuesday, 11 p.m. A vendor emails the AP inbox to ask when invoice 5102 will be paid. Nobody is awake. Here is the run, with its layer at each step.

  1. The email arrives in the AP inbox. That is a channel.
  2. The trigger starts a fresh session, which loads the Role Contract and the standing instructions for vendor emails. That is the runtime.
  3. The session opens the invoice's case file to see where the work stands. That is the SSoR.
  4. It reads the vendor's terms from the vendor record, through the governed door. That is DSoR, reading the company's systems.
  5. It checks what the policy says about payment terms, and notes the version to cite. That is the KSoR.
  6. A memory note says this vendor's terms changed in August. The session uses the note only to look harder at the record. That is memory, pointing and never deciding.
  7. It drafts the reply, adds a line to the case file, and puts the draft in the approval queue, because sending is outside its authority. The line is SSoR, and the queue is DSoR.
  8. The session ends. Nothing of the worker is running until the next trigger. The runtime is gone.
  9. Wednesday, 9 a.m. Dave reads the flags, opens the queue, checks the citation in ten seconds, and approves the reply from his own login. The evidence is kept. That is the human principal, with DSoR.

Every step read from or wrote to a place the company governs, except the session itself, which is gone. That is the picture in motion. The week of October 12 is what happens when those places are missing.

Follow one run through the six layers

Press Next step and watch which layer each step uses.

  1. Human principalowns the first and final 10
  2. ChannelsconnectNow
  3. Runtimeexecutes
  4. Memoryremembers
  5. KSoRknows
  6. SSoRtracks
  7. DSoRacts
  8. Company systemsthe authority on their data

Tuesday, 11 p.m. A vendor emails the AP inbox to ask when invoice 5102 will be paid. Nobody is awake.

Step 1 of 9 · Tuesday, 11 p.m.

The email arrives in the AP inbox.

Channels

Check yourself

Question 1 / 9

0 answered

Which layer of the canonical architecture executes the work?

Sources

  1. The System of Context, Panaversity, first edition.↑
Owner
Panaversity

On this page