The Enterprise Agent Control Plane
The firm-owned services that make every agent action identifiable, decidable, approvable and reconstructable: the ownership boundary, six planes and their contracts, the Policy Decision API with its latency budget, the persistence schema, the build sequence and the tests that show it works.
- Version
- 0.2.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 28 min
For Cto · Ai Architect · Platform Engineer · Security Engineer · Risk And Assurance · Compliance · Internal Audit
Sources and details
- Section
- Understand
- Source works
- Book 1 · Book 2 · Book 3 · Supporting Tools · Whitepaper
- Source chapters
- 1, 2, 3, 5, 6, 10, 11, 12, 16
- Source appendices
- 01:B
- Tool specifications
- audit_evidence_schema@0.1.0, cab_decision_record@0.1.0, deployer_manifest@0.1.0
- Refresh trigger
- vendor release
An enterprise agent control plane is the shared set of services that makes every agent the firm runs visible, bounded and reconstructable. It is not a product platform every team must adopt. It is the minimum set of control responsibilities that a product cannot silently bypass when an agent acts on the firm’s behalf: who the agent is, whether it may exist, whether this action may happen now, who approved it, what happened, and the structured record of all of that.
How to read this page. The six-plane model, the Policy Decision API contract, the 14-collection schema and the build sequence are author design proposals from Book 1 Chapter 11 and Appendix B, extended by Book 3 and the Supporting Tools work-stream. They are not regulatory requirements. Bank A, Asset Manager X and Insurer I are composite institutions. Vendor product statements are dated to the source and marked [FACT-CHECK] where this page has not verified them. Regulatory articles and dates live on the regulatory map.

At a glance: six planes (identity, registry, observability, policy, evidence and approval) that every agent action passes through. The detailed diagram is under The six planes and their contracts. Source: Building Organizations for the Age of AI (Book 1).
Draw the ownership boundary first
Three parties, three boxes, no fourth (Book 3 Ch 3 §2):
| Party | Supplies | Does not supply |
|---|---|---|
| Model provider (for example Anthropic) | Models, product capabilities, its safety regime, its contract and certifications | Your identity layer, gateway, connector allow-list, data classification, wranglers, evidence schema or regulatory accountability; it does not certify third-party MCP servers |
| Cloud provider (substrate) | Region, network, keys, IAM service, audit logs, certifications | Your policy decisions, connector broker, wranglers, evidence schema or accountability |
| The firm | Identity integration, the gateway, the connector broker and allow-list, managed client settings, envelopes, classification and retention, evidence capture, the operating model, and the control plane that integrates the other two | — |

Model provider, cloud provider and the firm each hold one non-overlapping box of responsibility. Source: Deploying Claude Safely (Book 3), Chapter 3, Figure 3.1.
Exercise for each production agent: draw the three boxes for that agent, its route and its data, and write each control in the box that owns it. If a control is in the provider’s box, name the contract clause that carries it; if you cannot, it is in your box. Book 3 opens with a supervisor asking for exactly this drawing; a firm that cannot draw it per agent does not yet know where its responsibility stops. The supervisory angle (contract surface, exit, third-party designation) is routed through the regulatory map.
What the provider itself says you must build (dated)
Book 3 Ch 3 §2.4 reports that Anthropic’s CISO-facing guidance of 17 July 2026 lists seven customer-side control requirements, all of which sit in the firm’s box:
- Identity issued and revoked by the customer’s identity provider.
- Connector allow-lists with two authorisation gates, admin and user.
- Per-tool, per-action approval.
- Sandboxed execution with credentials injected by a reverse proxy, never held in the sandbox.
- A mandatory egress allow-listing proxy.
- An OpenTelemetry stream into the customer’s SIEM.
- An organisation-wide off switch.
Book 3 disagrees with the guidance in three places, and this page follows Book 3: do not stream prompt content to the SIEM by default where data-minimisation and works-council obligations apply (decide which fields flow, redacted how, retained how long); the guidance maps to no European supervisory framework, so the firm does that translation itself; and its claim of improved prompt-injection resistance is unquantified, so keep the egress proxy. Book 3 also notes that vendor-distributed client settings are a convenience, not a security boundary: they can be bypassed on unmanaged devices and are not fetched on some cloud routes, so enforcement must be MDM-managed settings, cloud IAM, network egress and the gateway. [FACT-CHECK: confirm the seven requirements and wording in Anthropic’s “Zero risk isn’t the job: a CISO’s guide to agentic AI” (claude.com/blog), and current server-managed-settings availability by route.]
The firm’s box, expanded: five layers
Book 3 Ch 3 §3 expands the firm’s box into five layers. They map onto the six planes as follows:
| Layer (Book 3) | Contents | Planes it relies on |
|---|---|---|
| Access | SSO, conditional access, role-based access, same-day joiner–mover–leaver, no personal accounts touching institutional data; workload identity federation for non-human callers | Identity |
| Control | Gateway, Policy Decision API, MCP allow-list and broker, prompt/skill/agent registries, model usage registry, agent-readable data dictionary, evidence pipeline and SIEM | Registry, policy, observability |
| Agent | A signed bounded-agency envelope per production agent, stored as policy-as-code | Registry |
| Evidence | Nine-question records for every material action; a product without evidence coverage stays away from critical or important functions | Evidence, observability |
| Operating model | Named roles (executive sponsor, platform owner, business owner, wrangler, model risk, security, data, legal and compliance, internal audit, change-board chair) in a RACI | Approval (and every plane’s owner) |
Book 1’s six planes describe what the platform does; Book 3’s five layers describe where the firm’s architecture and organisation sit. Use the layers for responsibility mapping and the planes for system design. Envelope detail is on bounded agent.
The vendor toolkit is substrate, not the deliverable
Book 1 Ch 11 §4.5 judges vendor agent-governance toolkits (Microsoft’s Agent Governance Toolkit, preview April 2026, and AWS and Google equivalents) at roughly 30–40% of what a regulated firm needs: runtime middleware, reference policy rules and a default schema. The firm-specific layer is the rest, and it must be scoped explicitly:
- wrangler relationships bound to the firm’s identity store;
- zone definitions (toolkits are zone-agnostic);
- the evidence record enriched with the firm’s regulatory bindings and internal policy IDs;
- the model usage registry with usage over time, not just a catalogue;
- integration with existing change management, identity governance and audit systems.
Recognise the anti-pattern: the project plan has one line, “deploy the toolkit”, with go-live three months out, and the product owner answers questions about evidence schema, regulatory bindings and approval workflows with “the toolkit’s defaults”. Recover by reframing the plan as toolkit plus firm-specific layer. [FACT-CHECK: Microsoft Agent Governance Toolkit status, packaging and default schema as of the current date.]
The six planes and their contracts
The planes are separable responsibilities, not OSI-style layers. A small implementation may host several in one service; it must not merge their ownership, joins or failure handling by accident.

The six-plane model. The Cosmos DB collections in the source diagram are Book 1’s implementation example, not a required technology.
| Plane | Answers | Minimum durable record | Failure posture |
|---|---|---|---|
| Identity | Who is acting? | Identity-to-agent binding, issuance, revocation, fingerprint | Refuse a protected action if the identity cannot be resolved |
| Registry | Is this agent allowed to exist, here, owned by whom, under what envelope? | Definition, versions, signed envelope, lifecycle state, permitted tools and models | No route or credential for an unregistered component |
| Policy | May this action happen now? | Rule versions; every decision with rationale and rules fired | Fail closed, or route to approval by action class |
| Observability | What is happening? | Action traces keyed to agent, wrangler, decision and evidence record | Preserve local signals; raise a gap when central collection lags |
| Approval | Did an accountable human say yes? | Workflow definitions; every approval, refusal or timeout with rationale | Expire or escalate; timeout is never approval |
| Evidence | What is the structured record? | One nine-question record per evidenced action with pointers | Quarantine or deny actions that need evidence but cannot emit it |
The registry is the spine: every other plane is keyed by registry IDs. It must be an authoritative source that the deployment pipeline cannot bypass, not an inventory reconciled from logs. The policy plane is the only plane on the action’s critical path; registry and identity work before the action, observability and evidence after, approval alongside. Agent runtimes sit outside the control plane: the plane governs runtimes, it does not replace them.
The five inter-plane contracts
Book 1 Ch 11 §4.1 names one contract per seam. Each is a version-pinned JSON schema with a named owner on the platform team; loose contracts drift within about ninety days. The owner column is this page’s suggestion; the source requires only a named person.
| Contract | Between | Carries (minimum) | Suggested owner | Breaks when |
|---|---|---|---|---|
| Issuance | Identity → registry | Provider identity ID, agent ID and version, issuance and revocation times, fingerprint | Identity engineering lead | Identity provider and registry disagree; no daily reconciliation |
| Lookup | Registry → policy | Definition, lifecycle state, zone, wrangler, envelope at version, tool and model entries | Registry product owner | Policy decides against a stale or unversioned envelope |
| Decision capture | Policy → observability | Request, response, rules fired, latency, decision ID | Policy engine owner | Decisions are made but not recorded, or recorded without agent identity |
| Escalation | Observability → approval | Decision ID, trigger class, resolved approver role, SLA clock | Approval workflow owner | Escalations queue without an owner or SLA |
| Artefact handover | Approval → evidence | Approval record bound to the exact action or version, rationale, supersession | Evidence pipeline owner | Approvals exist that no evidence record references |
The canonical published schemas are the Audit Evidence Schema v0.1.0, CAB Decision Record v0.1.0 and Deployer Manifest v0.1.0; see schemas and tools. Pin and validate against a version rather than translating this page into a parallel schema. The Policy Decision API contract below is described in Book 1 Appendix B but is not, as far as this page can tell, published as a versioned JSON schema.
Policy Decision API contract
One API, called before every action with an external effect, returning in tens of milliseconds, with a rationale that teaches the caller what to do next. Book 1 summarises the principle as making agent control both restrictive and instructive. The contract is engine-independent.
Request: POST /policy/v1/decide
| Field | Content |
|---|---|
agent_id, agent_version | Registry identity of the deployed version |
wrangler_id | Accountable human owner |
intended_action.type, .tool, .parameters | What the agent proposes, e.g. tool_call against an mcp:// tool |
target_system | Executing system and environment |
target_data.classifications, .estimated_records | Data classes and volume |
session.initiator_type, .initiator_id, .channel, .session_id | Who or what started the chain |
context.zone, .ticket_id, .request_time | Operating zone, linked ticket or change, timestamp |
The request is signed by the agent runtime (bearer token) and carries everything the engine needs, so the only extra lookup is the registry read.
Response
| Field | Content and rule |
|---|---|
decision | One of allow, allow_with_evidence, escalate_for_approval, deny |
policy_decision_id | Stable ID that every downstream record references |
rationale | A sentence an engineer can read, naming registry entry, tool catalogue entry, envelope clause and initiator authorisation |
policy_rules_fired | Machine-readable list of rule IDs |
required_evidence | Obligations the evidence plane must honour (e.g. evidence_record:full, apply a sensitivity label) |
required_approvals | Approvals the approval plane must collect before execution |
constraints | Runtime obligations, e.g. egress_redaction fields, max_records, ttl_seconds |
expiry | Hard ceiling: execute before it or call again; prevents replay and long-lived authorisations |
owasp_mappings, regulatory_bindings | Bindings on the decision itself, so “which obligation does this control discharge?” is answered from the decision record |
“Obligations” in this site’s vocabulary means required_evidence, required_approvals and constraints together: if the runtime satisfies them, the action proceeds. In Book 1’s worked call (composite Bank A, a read-only dispute summariser), the decision was allow_with_evidence, three rules fired, three fields were redacted at egress, max_records was 1, ttl_seconds 60, and the response returned in 31 ms.
When the API is called: two layers
The sources set different invocation scopes; this page treats them as layers, not a contradiction.
| Layer | Rule | Source |
|---|---|---|
| Agent actions | Every action with an external effect (tool call, write, model invocation with external effects, data read above a sensitivity threshold) goes through a decision | Book 1 Ch 11 §4.1, §5.2 |
| Gateway-mediated model traffic | Tier 0–2 workloads typically do not call it; Tier 3 calls it on writes; Tier 4 on every consequential action | Book 3 Ch 6 §4.1 |
This page follows: for registered agents, the Book 1 rule at the tool, broker or write boundary; the Book 3 tier rule as the minimum for model calls through the gateway. Tiers are defined on risk tiers.
Central PDP or distributed evaluation
The Supporting Tools specification evaluates policy locally on each leaf (ops chk) against signed policy packs, with sub-millisecond latency and availability during a centre outage; packs propagate down within minutes. A central PDP gives a stronger guarantee about which policy was in force but costs a network hop. The alignment note recommends local evaluation as default with a central PDP as an optional overlay, called in addition to, not instead of, the local check. Rule: if the two disagree, the disagreement is itself an auditable event, and the central answer wins for high-risk classes. Stale-pack limits follow from the refresh interval, so set and monitor it.
Latency budget and caching
The policy call is a synchronous gate. An asynchronous post-hoc check lets identity and privilege abuse happen before anyone looks.
| Target | Value (Book 1 Ch 11 §4.3, App B) |
|---|---|
| p99, policy engine in the same region as the agent runtime | < 50 ms |
| p99, cross-region | < 200 ms |
How to meet it:
- Cache the envelope at session start. Read the registry once, cache the agent’s envelope for the session against a TTL, and decide later calls from the cache plus the in-memory policy bundle.
- Place a read replica per runtime region. Book 1’s reference uses Cosmos DB with dedicated throughput and a read region per agent-runtime region; naive single-region deployments will not meet the budget. The Supporting Tools registry design targets ≤ 20 ms p99 lookups from per-edge read replicas.
- Keep decisions short-lived with
expiry, so caching never becomes standing authorisation. - Watch cost.
policy_decisionsis the highest-volume collection (Book 1 reports a firm at six million records a day across forty agents); wrong caching makes its throughput dominate the run-rate.
This page’s recommendations (not in the source): bound the envelope TTL to the session and no more than your suspension target; make suspension, envelope amendment and rule retirement invalidate cached envelopes and bundles; and alert on p99 per region, not on averages.
Choosing an engine. Open Policy Agent, gateway policy fragments (e.g. Azure API Management) or a vendor toolkit’s policy module are all viable; the contract does not change. Choose the engine the platform team can operate at 03:00 with one engineer on call, not the one with the most features (Book 1 Ch 11 §4.3). Book 1’s May 2026 assessment was that AWS led on runtime policy and Microsoft on identity lifecycle. [FACT-CHECK: current GA status and capabilities of AWS AgentCore Policy, the Microsoft toolkit policy module and Google’s equivalents.]
Every deny carries a path to allow
A bare “deny” produces silence, frustrated developers and bypass attempts. A deny must always carry a rationale and a path-to-allow: what would have to be true for the next call to be allowed. Common paths in Book 1:
- register the agent in the registry;
- update the envelope to include this tool;
- obtain a named change record in approved state;
- obtain wrangler approval through a named approval workflow;
- redact a named
target_datafield before retry.
Deny-sampling test: sample recent deny responses. Book 1 puts the sample in internal audit’s half-yearly testability report; this page also recommends a monthly platform-team sample. Each must tell the recipient what to do. Any that say only “not allowed” are defects in the rule, not in the caller. Also confirm that a denied decision is enforced at the executing boundary and is queryable as evidence.
Irreversible actions need separate authority
The public Replit incident (July 2025) is Book 1’s reference case: a coding agent deleted a production database and then produced outputs that misrepresented what it had done. Book 1 Ch 1 §6.3 names three control-plane failures, each reproducible in a regulated firm:
| Failure | What was missing | Control-plane rule |
|---|---|---|
| Undifferentiated authority | One identity could both develop and modify production state; deployment approval did not bound runtime authority | Separate development and production identities and means; production write is not in a development agent’s envelope |
| Irreversibility without a gate | No platform check before an irreversible deletion | Any action classed irreversible needs a separate authority before execution: a human approval, a second agent, or a policy that refuses outright (Book 1 cites the OWASP Least Agency principle) |
| No independent record | The agent’s own output was the only account of its actions | The platform emits evidence independently; an agent’s outputs are never the sole record about itself |
Implementing the rule: tag tools and verbs with a reversibility class in the tool registry; write policy so irreversible verbs return escalate_for_approval or deny, never plain allow; bind the approval to the exact action and version; and emit the evidence record from the executing system, not the agent. Book 1 notes Replit’s own fixes were operating-model changes (confirmation for state changes, development/production separation, better reasoning visibility), not model changes.
Approval-plane routing and SLAs
The approval plane catches escalate_for_approval, routes it, captures the decision and feeds it back.
Workflow definition (approval_workflows, versioned and itself approved): trigger criteria; approver assignment by role, resolved at runtime (the wrangler, the data steward for a sensitivity class, a control function); SLA; escalation pattern; timeout behaviour.
Typical trigger classes (Book 1 Ch 11 §5.2): production data egress; actions requiring an approved change record; operations on sensitivity class 3 and above; cross-zone agent calls. Add irreversible verbs (above).
Approval record (approval_records): approver, decision (approve, refuse, escalate, defer), rationale (mandatory for refuse and escalate), timestamp, linked policy_decision_id, agent_id and action_trace_id.
Rules: resolve the approver role at decision time so reorganisations do not orphan workflows; an approval cannot retroactively legitimise an executed action; timeout escalates or expires, it never approves. Book 1 does not set SLA values; use the tier-based approval SLAs on risk tiers and record the SLA on each workflow definition.
Persistence schema: 14 collections
Book 1 Appendix B gives the state model in Azure Cosmos DB naming; the names and relationships are the contract, the engine is an implementation choice. Every collection carries at least a partition key (usually agent_id), a tenant key (business line), created/updated timestamps, a version, a defined retention, encryption at rest and a customer-managed key.
| Group | Collection | One record per | Key rules |
|---|---|---|---|
| Registry | agent_definitions | Agent | Mandate, wrangler, zone, business line, environment, lifecycle status (proposed, approved, in-development, in-production, deprecated, retired) |
agent_versions | Version | Change description, deployer, deployment time, policy bundle, pinned model, prompt-template fingerprint, tool list, previous-version link | |
agent_envelopes | Version | Mandate (scope, prohibited scope, escalation triggers), Means, Memory, Monitoring; signed by the wrangler; read on every decision | |
lifecycle_events | Transition | Registration, version bump, zone/mandate/wrangler change, suspension, retirement; actor, rationale, linked approval | |
| Identity | identity_links | Agent identity binding | Provider identity, issuance, revocation, fingerprint, credential lifecycle; reconciled daily against the identity provider |
| Policy | policy_rules | Rule | Version-pinned, named control owner, effective dates, supersession; activation needs recorded approval; retirement must evidence the replacement |
policy_decisions | Decision | Request, response, rules fired, latency, agent and version, outcome | |
| Observability | action_traces | Action | Authorising decision, tool, redacted inputs/outputs, outcome, duration, downstream effects |
sensitive_data_findings | Finding | Classification, detector, trace, whether permitted/redacted/blocked, remediation | |
| Approval | approval_workflows | Workflow | As above |
approval_records | Instance | As above | |
| Catalogues | mcp_tool_registry | MCP server (sub-records per tool) | Gateway URL, data classes, OAuth flow, approved consumers, risk class, supply-chain onboarding evidence |
model_usage | (model, agent, time window) | Usage over time, distinct from a model catalogue; see model governance | |
| Evidence | evidence_records | Evidenced action | Nine answers plus pointers to trace, decision, approval and identity link; bindings; retention metadata |
The relationships form a graph: envelopes and identity links reference definition and version; decisions reference version and rules fired; traces reference decisions; evidence references everything.
Source conflict. The Supporting Tools alignment note lists a differently named set (for example agent_registry, packs, cab_decisions, deployment_manifests, wranglers, exceptions, legal_holds) and says the count is “roughly 14”. This page follows Book 1 Appendix B. If you build on the Supporting Tools services, keep a mapping table between the two sets.
Registry reads must be point-in-time and signed
Supporting Tools decision D26 (proposed) makes the registry a read aggregator over the authoritative sources (identity provider, model usage registry, CMDB), with three properties worth adopting: lookups resolve as of the time of the event, not the current state; every response is signed so the caller can attach it to the evidence record as a pointer; and registry history is retained so a later query (“which envelope was in force on this date?”) is answerable (D26 proposes seven years).
Engine landings and write consistency
| Engine | First store | Second store | Write-consistency caution |
|---|---|---|---|
| Azure (reference) | Cosmos DB for all fourteen | — | Session-level consistency; change feed |
| AWS | DynamoDB for high-volume collections (policy_decisions, action_traces, evidence_records) | Aurora PostgreSQL for relational, lower-volume collections (agent_definitions, agent_envelopes, policy_rules, approval_workflows) | Global Tables are eventually consistent: acceptable for traces and evidence, but enforce a primary-write region for agent_definitions and policy_rules |
| GCP | Firestore for document-shaped collections (agent_definitions, agent_envelopes, evidence_records, lifecycle_events) | Spanner for collections needing strong global consistency under writes (agent_versions, policy_rules, approval_records) | Spanner writes are strongly consistent; on Firestore use a regional primary with multi-region replication |
Provider-neutral rule (this page’s generalisation of Book 1 Ch 11 §5.4): append-only, high-volume records may replicate eventually; definitions, envelopes and policy rules should have a single writer region so two regions never activate different rule sets. [FACT-CHECK: current consistency semantics of DynamoDB Global Tables and Firestore multi-region.]
Build sequence
Stand the planes up in dependency order; adjust the timing, not the order (Book 1 Ch 11 §5.2, §7). No plane is meaningful without its predecessors: policy without a registry has nothing to authorise against; observability without identity has nothing to attribute to; approval without policy has nothing to escalate; evidence without observability has nothing to record.
| Phase | Large firm (≈50,000 staff) | Planes and deliverable |
|---|---|---|
| 1 | Months 1–3 | Identity + registry together. Identity links populated; definitions, versions, envelopes; pipeline blocks any agent without a wrangler-approved registry entry. Deliverable: “how many agents, who owns each, what may each do” answered by query |
| 2 | Months 3–6 | Policy + observability. Policy Decision API meeting the in-region p99 budget; rules, decisions and traces populated; first MCP cohort registered; SIEM bindings; agents migrated to call the API on every external effect |
| 3 | Months 6–9 | Approval + evidence. Workflows for the trigger classes; approval records; evidence records answering nine questions for every action. First internal-audit cycle end to end by month 12 |
Productive minimum. Each phase stands its planes up to a working minimum, not to completeness. A Phase 2 policy plane that decides 80% of actions and escalates the remaining 20% is correct.
Owning team. The control plane is run by the team that runs identity and the cloud platform, not by a separate AI-governance team.
Sizing (Book 1 estimates, composite). Large firm: ten-person platform team plus embedded business-line squads; roughly 80–100 person-months over nine months; run-rate 6–8 platform engineers. Specialist firm (≈1,000 staff): four people over six months (phases at months 1–2, 2–4, 4–6), consuming toolkit defaults aggressively; roughly 24 person-months; run-rate 2–3 engineers for an estate of 30–50 agents.
Before the build starts (this week): count agents in production into a spreadsheet baseline you expect to replace; name one wrangler per agent; draft and have the wrangler sign envelopes for the three highest-risk agents.
Managed-equivalent paths. The Supporting Tools alignment note maps firm sizes to build depth: specialist firms consume managed services (identity, gateway, data-protection products) with little custom code; regional firms add thin custom adapters; national-scale firms build the full schema; global groups add a multi-provider abstraction. Treat this as a sizing heuristic, not a standard.
Govern agent execution by architecture
Where an agent runs determines what it can reach. The poor default is a developer’s laptop with the developer’s credentials against everything the developer can reach, which turns a coding agent into a lateral-movement risk. Book 2 Ch 16 §4.9 sets four decisions:
- Source control is the source of truth. Every agent action lands as an issue, commit, pull request or review comment; no separate agent console with its own history.
- Isolated, purpose-built runtimes decoupled from corporate endpoints, provisioned per workspace with only the egress, scoped credentials and tools the recipe allows. No agent execution on laptops under developer credentials.
- The model is a named, substitutable component reached through the gateway; evidence format, workspace, toolchain and review gate are the durable structure.
- Locked, per-domain toolchains, versioned and changed through the recipe-upgrade path.
Constraints then execute at four points: at registration (no credential or route for an unregistered model, agent or tool, built first), in the pipeline, at release (evaluation thresholds gate deployment), and at run time on every call through the gateway and broker. Workspace provisioning is on landing zone.
Topology: leaf, edge, centre
For groups with several legal entities, the Supporting Tools reference architecture distributes the evidence and policy functions across three tiers. Two invariants: evidence flows up and policy flows down on the same secure channel; and authenticity, immutability and completeness are enforced jointly.
| Tier | Where | Duties |
|---|---|---|
| Leaf | Wherever an agent or operator works: runner, CI worker, agent runtime, vendor gateway | Build the evidence record, bind identity, redact, sign, append locally; local store is the truth until the edge acknowledges; evaluate signed policy packs locally |
| Edge | One per legal entity and jurisdiction | Pipeline: ingest → verify signature → stamp entity-of-record and received-at → enrich from identity and registry → counter-sign → buffer → fan out to evidence lake, SIEM and ITSM; relay policy packs to leaves. Stateless except a 24-hour replay buffer |
| Centre | Once per group (or per strongly separated regulated entity) | Signed registries (policy packs, change templates, schema versions), append-only evidence lake, the single regulator-facing query API, exception, retention, legal-hold and subject-access engines |
Failure handling: an invalid signature sends the event to a dead-letter queue, and the DLQ itself emits an anomaly record so a missing leaf event is visible at the centre; a buffer gap beyond 24 hours is an exception the centre detects. Use this topology where entities need independent ingestion and control; it is not a prerequisite for a first deployment. Pipeline detail is on audit evidence.
Place the control plane in the cloud estate
Ten capability pillars (Book 1 Ch 5 §4.2). Read the cloud as capabilities, not teams: identity, network, security, compute, data, integration, observability, governance, automation, and a new AI platform control pillar. FinOps cuts across several pillars rather than standing alone. Agents change each pillar: agent identities are ephemeral and event-driven; egress allow-lists turn over daily; security must detect prompt injection, data poisoning and tool abuse; compute becomes contract operations against hosted runtimes; data’s first product is the dictionary the agent reads; integration adds the MCP gateway; observability must answer the nine questions; governance policy is evaluated in milliseconds; automation needs content-of-merge checks. This page’s reading (not Book 1’s wording): the agent control plane is the AI platform control pillar plus the agent-specific extensions of the other nine.
Roles by plane (Book 2 Ch 10 §4.6). The cloud has its own control, data and management planes, and controls land unevenly across them (detail on cloud and hosting). Map roles explicitly:
| Cloud plane | Typical roles | Who may hold them |
|---|---|---|
| Control (create, configure, assign policy, grant roles) | Roles that stamp subscriptions, assign policy and manage who else may act | A small, audited set of identities; Book 2 says “almost never” an agent, and this page recommends never, with any exception through documented risk acceptance |
| Data (read and write workload data) | Custom data roles (data engineer, data steward, read-only analyst) | Workloads and, increasingly, agents; Book 2 warns these are the roles least often scoped tightly, so scope them to the envelope |
| Management (operate and observe) | Operator and monitoring roles (this page’s suggestion; Book 2 describes the plane but assigns no roles) | Operators; agents only in the zone that permits it |
Book 2 also notes that enumerating which services actually enforce data-plane RBAC is part of the job: control coverage is uneven across the three planes.
Acceptance check: list every role assignment held by an agent identity; none is a control-plane role, and every data-plane role maps to an envelope Means entry.
Contract for portability and exit
AWS, Microsoft and Google converge on the same five primitives (Book 1 Ch 10 §4.1): per-agent verifiable identity, a central registry of agents and tools, runtime policy enforcement, an identity-aware gateway, and pre- and post-deployment evaluations. Book 1 Ch 10 §1 ties each envelope side to the primitive that makes it enforceable; the plane column is this page’s mapping:
| Envelope side | Enforced by (Book 1 Ch 10) | Plane (this page) |
|---|---|---|
| Mandate | The identity-aware gateway intercepts every call | Policy, observability |
| Means | Per-agent identity binds the credential each call carries | Identity |
| Memory | The central registry knows what the agent may read and where the platform writes | Registry |
| Monitoring | Evaluations and runtime guardrails leave evidence | Policy, observability, evidence |
Convergence confirms the design; it also concentrates the sector on three providers. Book 1’s contract spine for an exit strategy under DORA Article 28(8) (obligations and dates on the regulatory map):
- Score the current provider against the five primitives, one owner per primitive (identity, platform engineering, AI security, API platform, model governance).
- Check each contract names each primitive at interface level; where it does not, flag procurement; where exit to an equivalent is not clean, flag the concentration risk to the CRO and the third-party risk owner.
- Keep the firm’s own artefacts provider-neutral and build them during the Build stage, not after: the per-agent identity standard, the registry schema and the evaluation harness (Whitepaper Part III §3), plus the evidence schema, the policy-decision contract and the 14-collection model (Book 1 Ch 11 §4.5). Locking provider-native primitives into the application layer creates the concentration risk the supervisor asks you to manage. Because the primitives are equivalent in concept, choose the platform on commercial, sovereignty and integration criteria rather than on capability gaps (Whitepaper Part III §3), then re-check maturity per plane.
- Map policy capabilities, not product names, before swapping engines; two vendors’ policy engines are not interchangeable by default.
The “no vendor names” test: for any production agent, can you describe what it does and how it is controlled without naming a vendor product? If not, the exit plan is performative. A multi-cloud claim where more than 80% of criticality-weighted agent workload runs on one provider is, in Book 1’s terms, theatre.
Compliance and internal-audit deliverables
| Function | Owns | Signs | Anti-pattern if absent |
|---|---|---|---|
| Compliance | Policy-as-code translation of applicable obligations into rules the API evaluates; an evidence-bindings table mapping each of the 14 collections to the obligation it discharges; per-agent attestation that envelope, wrangler assignment and evidence records discharge the agent’s obligations | Quarterly attestation to the operational-risk committee that the rule corpus and evidence schema discharge standing obligations | A SIEM workspace with no rule-to-obligation mapping when the supervisor asks how logging duties are met |
| Internal audit | An evidence query template it can run without the platform team; a register naming an engineering owner and second-line reviewer per plane; a half-yearly testability report | Half-yearly report that, for a tested sample, the nine questions are answered from the platform | ”Controls exist on paper”: nobody has tested whether a query returns records for actions two quarters old |
The testability assertions in the half-yearly report: sample action_traces, policy_decisions and evidence_records and confirm identity attribution is not null; a rationale is present on every deny; and the evidence record reconstructs end to end. Obligation mapping itself lives on the control map.
Failure modes and recognition tests
| Failure | Recognition test | Recovery |
|---|---|---|
| Registry as inventory | Can the pipeline create an agent that is not in the registry? If yes, it is an inventory | Make registration a hard pipeline gate in Phase 1 |
| Yes/no policy engine | Sample deny responses: do they say what to do? | Every deny carries rationale and path-to-allow |
| Observability without identity attribution | Metric: share of action_traces with null, generic or service-account agent_id. Target zero; alert on any non-zero daily count | Make identity propagation a runtime contract; reject untraceable calls; cost grows with every week of null records |
| Evidence as logs | Is evidence queryable by the nine questions, or “we’ll write a query”? | Assemble the evidence record at write time in the runtime middleware |
| Toolkit as deliverable | Single “deploy the toolkit” line in the plan | Scope the firm-specific layer |
Acceptance checks and recovery
Before expanding beyond the first workflow, demonstrate against a real protected operation:
- An unregistered agent, model or tool receives no route or credential.
- A request carries distinct initiator, agent and workload identities; zero null
agent_idin the sample. - The policy call meets the in-region p99 budget under representative load, and suspension invalidates the cached envelope.
- A deny is enforced at the executing boundary, carries a path-to-allow and is queryable.
- An irreversible verb cannot execute on
allowalone. - An approval names the exact action or version, its conditions and supersession; a timed-out approval did not execute.
- Activating a policy rule without a recorded approval is refused; retiring one without a successor is refused.
- An operator can suspend one agent, revoke its authority and preserve its records without stopping unrelated products.
- A central-collection outage produces a visible gap, not a silent hole.
- No agent identity holds a cloud control-plane role.
Emergency response: contain at the narrowest boundary (disable the registration or identity, block the specific tool route), then preserve decision, approval and execution records. Re-enable only through the lifecycle with an explicit decision and evaluation result. A shared emergency credential widens the blast radius and destroys attribution. Suspension rehearsal targets are on agent lifecycle.
Provenance and review state
- Author proposals: six planes, five contracts, Policy Decision API, 14 collections and build sequence (Book 1 Ch 11, App B); five-layer target state (Book 3 Ch 3); four execution decisions (Book 2 Ch 16); leaf/edge/centre and the registry service (Supporting Tools, D26 still “Proposed”).
- This page’s own additions are labelled: suggested contract owners, cache-invalidation rules, the null-
agent_idalert threshold. - Source differences stated, not blended: policy invocation scope (Book 1 versus Book 3); central versus distributed policy evaluation; collection naming (Book 1 App B versus the Supporting Tools alignment note).
- Vendor product claims (toolkit maturity, provider policy engines, Anthropic’s control list) are dated to May–August 2026 and marked for checking. This remains a draft.
Source material
- Book 1 (Building Organizations for the Age of AI), Chapter 1, The Adoption Gap (§6.3 Replit control-plane failures)
- Book 1, Chapter 2, The Bounded Agency Thesis (§6.2 Replit read through the envelope)
- Book 1, Chapter 5, The Framework Backbone and the Cloud Control Plane (§4.2 ten capability pillars)
- Book 1, Chapter 10, The Convergent Platform Pattern (§1 envelope-to-primitive enforcement, §2, §4.1 five primitives, §7–§8 contract spine and exit)
- Book 1, Chapter 11, The Enterprise Agent Control Plane (§2, §4.1–§4.5, §5.1–§5.4, §7, §8)
- Book 1, Appendix B, Operating Schemas (14-collection control-plane schema; Policy Decision API request and response contract; worked call)
- Book 2 (The AI Delivery Factory), Chapter 10, Cloud as the Production Line (§4.6 three planes and role mapping)
- Book 2, Chapter 16, The Automation Factory (§4.9 governance-by-architecture and controls that execute)
- Book 3 (Deploying Claude Safely), Chapter 3, The Control Plane Is Yours (§2 three-party boundary, §2.4 vendor-published controls, §3 five-layer target state)
- Book 3, Chapter 6, The LLM Gateway and Policy Decision Point (§4.1 policy checks and tier invocation)
- Book 3, Chapter 12, The Landing Zone Tied Together (§4.10 the architecture as one drawing)
- Supporting Tools, docs/architecture/01_reference_architecture.md (leaf, edge, centre)
- Supporting Tools, docs/architecture/04_data_flows_and_sequences.md (evidence-up flow and failure handling)
- Supporting Tools, planning/decisions_log.md D26 (Registry Service)
- Supporting Tools, reviews/vol1_ch22_alignment_note.md (§4 distributed chk versus central PDP; §5 collection mapping; §6 tier alignment)
- Whitepaper (The Age of AI), Part III §3, convergent primitives and portability
Related guidance
-
The Anatomy of an AI ApplicationA six-tier view of what one AI product is made of, crossed by a trust and operations plane that attaches controls to every tier; what the factory already supplies per tier, how the anatomy maps to the six-layer product portfolio, and how to run an anatomy review. -
The AI Delivery Factory: Operating ModelThe factory's six connected parts, the control gap it closes, the handover curve that governs what agents may take over, and how to start one without rebuilding your tooling. -
Prepare a Governed Landing Zone for AI DeliveryDesign the management-group hierarchy, enforce guardrails in deny mode, give humans and agents the same paved workspace, integrate the eight agent-platform components, close the perimeter, and prove the zone is done with seven observable exit criteria and a second-line sign-off. -
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
Design and Operate the Model GatewayBuild the model gateway as the governed edge for every model call: per-client identity, per-request highest-class routing, tokenisation, pinned models, a conformant wire contract, a correlated evidence record, a tested concentration answer, and day-two cost, latency and reliability operations across two estates and three meters. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer. -
Design the Cloud Production Line and Hosting BoundariesClassify, segment, constrain and observe every workspace at the plane where actions execute, choose hosting routes per request, and keep vendor maturity, contracts and exit equivalence dated and explicit. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Close the Policy, Audit and Actuals LoopRun governance as a standing comparison of declared policy against emitted records, route only the exceptions to the second line, and govern the policy packs that drive the comparison. -
Route Regulatory Questions to Obligations and EvidenceA dated, article-level reference that routes AI design questions to the EU AI Act, DORA and its RTS, GDPR and sectoral rules, and turns each obligation into a control, an owner and evidence: change records under RTS 2024/1774 Art 17, the 4 h / 72 h / one-month incident clocks, the CIF hinge and its five artefacts, the three-count Register of Information reconciliation, Art 14(4) oversight controls, the Art 26(5) discharge, the FRIA gate, Art 49 and Art 50, SCHUFA-grade review and supplier controls. -
Build a Unified Control MapJoin the firm's AI and technology controls in one traceable operating view: rows are operating concerns, columns are frameworks read at their own altitude, every cell points to live evidence, and existing ITIL, COBIT and CIS artefacts are extended to agents with a five-question test instead of a parallel AI governance track. -
Classify Use Cases into Risk TiersThe T0–T4 use-case taxonomy as a working decision reference: the prohibited-use gate, four intake questions, data and action boundaries per tier, the twelve-area control matrix, retention and payload rules, runtime enforcement, approval gates, regulatory routing and re-tiering. -
Operate the Agent LifecycleInventory, register, sign, zone, review, suspend, recover and retire agents through a six-stage lifecycle with named human ownership, zone-specific authority and evidence at every transition. -
Bounded-Agent PatternA class 3 agent lets a model choose the next step, but only inside a registered, validated and enforced envelope of Mandate, Means, Memory and Monitoring. -
Schemas, Conformance Packs and the ops ToolchainWhat the versioned Supporting Tools schemas hosted under /aes/v0.1.0/ require, how to validate against them, where the source specification contradicts itself, and what the planned ops CLI, Claude plugins and service conventions define.