The brief — Oracle
The problem, the why, the definition of success.
Delegates and Surfaces
The model has exactly two kinds of thing. Keeping them apart is the load-bearing move.
Actors are humans, defined by motive. An actor wants something — to solve the right problem, to make the thing work, to keep the whole coherent. The motive is intrinsic; it is theirs. Accountability lives with the actor and never leaves: an actor is answerable for the outcome whether they did the work themselves or delegated it.
Delegates are agents that act on an actor’s behalf. A delegate has no intrinsic motive. It is given one — through artifacts the actor authors — and it executes that intent, filling the gap when the human is unavailable. Given good artifacts, a delegate often works faster and more thoroughly than the actor would alone. But it is never accountable. It is capacity, not a party.
Substrate becomes party
Section titled “Substrate becomes party”Each side is a raw substrate that becomes a party by entering the relationship:
flowchart LR H[a human] -->|"takes on a motive<br/>+ accountability"| A[<b>an actor</b>] AG[an agent] -->|"is given intent through<br/>a delegation surface"| D[<b>a delegate</b>] A -.->|wields| D class A actor class D delegate classDef actor stroke-width:2px classDef delegate stroke-dasharray:6 4
| Substrate | Becomes… | by… |
|---|---|---|
| a human | an actor | taking on a motive and the accountability for it |
| an agent | a delegate | being given that intent through a delegation surface |
So agent names the raw capacity — an AI system, apart from any task — while delegate names that same agent once an actor has wielded it. This is why delegate is first a verb: to delegate is the act an actor performs — authoring the governance and criteria that transmit responsibility to an agent, turning it into a delegate. The noun is just the agent caught mid-relation.
Why the AI delegate is the opposite of agency theory’s agent
Section titled “Why the AI delegate is the opposite of agency theory’s agent”The actor/delegate shape adapts a known idea — agency theory: “one party (the principal) delegates work to another (the agent), who performs that work on behalf of the principal.” But the classic theory assumes the agent is self-interested — it has its own goals, withholds information, may shirk. That is the “agency problem.”
Our delegate is the opposite, and deliberately so: it has no goals of its own, so the agency problem dissolves by construction. An AI is not a teammate the way a person is. It is a faithful extension of a person. The whole model is about how humans-in-roles extend themselves through delegates.
The delegation surfaces
Section titled “The delegation surfaces”Every actor extends itself through a delegation surface — the artifact by which it transmits intent across a gap: to a delegate now, to a teammate next week, or to its own future self.
The contract + exemplars — Builder
A behavioral spec for one angle, plus reference patterns to imitate.
The shape — Architect
Organizing principles, boundaries, conventions, and the constraints that protect them.
The corpus — Strategist
Distilled, reusable knowledge every other delegate reads from.
These are categories, not products. A team instantiates them in whatever form fits — a one-page brief or a chartered intent doc; convention files or decision records; checklists or executable acceptance tests. The model names the surface; the team picks the medium.
The Strategist’s surface is special: its output is the substrate every other delegate reads from. A team that invests in its corpus makes every other delegate faster and more faithful at once. A team that neglects it forces every delegate to start cold.
The bar — the backward face of every surface
Section titled “The bar — the backward face of every surface”Each surface has a backward face: its bar, the acceptance criteria the same expertise applies when judging. The bar is not a separate surface — it is the criteria face of every surface: the brief’s definition of success, the shape’s fitness rules, the contract’s behavioral checks. Stated as instruction it guides production; stated as criteria it gates acceptance. Two faces of one artifact.
Fidelity — checking the worker, not the work
Section titled “Fidelity — checking the worker, not the work”Delegating is only half the relationship. The other half is verifying the delegate is faithful — that it did what the actor would have done, and intended.
flowchart TB S[Delegation surface<br/>brief · contract · shape · corpus] S -->|criteria on the artifact| BAR["<b>the bar</b><br/>judges the work"] S -->|criteria on the delegate| FID["<b>fidelity</b><br/>judges the worker"] BAR --> WORK([the artifact]) FID --> WORKER([the delegate]) class S,WORK artifact class BAR gate class WORKER delegate classDef gate stroke:#d97706,stroke-width:2px classDef artifact stroke:#0d9488,stroke-width:1.75px classDef delegate stroke-dasharray:6 4
Fidelity is distinct from evaluation:
- A backward face (the bar) judges the work — the artifact.
- Fidelity judges the worker — the delegate that produced it.
Different objects, different levels. Fidelity is neither a fifth actor (it has no motive — it is a relation, not a party) nor a third face (a face points at the work; fidelity points at the worker). It is a delegate-directed check riding every delegation surface — the mirror of the bar. Given this brief, contract, shape, or corpus, does the delegate do what the actor would have done and intended?
This is also where the human–agent interface lives. The interface is the fidelity instrument — how an actor inspects, calibrates, and trusts the capacity it wields.