Browse the reference ⌄
Concept published

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

Full source list ↓ Source index →

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.

The enterprise agent control plane: six planes — identity, registry, observability, policy, evidence and approval — through which every agent action passes.

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):

PartySuppliesDoes not supply
Model provider (for example Anthropic)Models, product capabilities, its safety regime, its contract and certificationsYour 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, certificationsYour policy decisions, connector broker, wranglers, evidence schema or accountability
The firmIdentity 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—
Three parties, three non-overlapping responsibility boxes: model provider, cloud provider and the firm (the bank).

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:

  1. Identity issued and revoked by the customer’s identity provider.
  2. Connector allow-lists with two authorisation gates, admin and user.
  3. Per-tool, per-action approval.
  4. Sandboxed execution with credentials injected by a reverse proxy, never held in the sandbox.
  5. A mandatory egress allow-listing proxy.
  6. An OpenTelemetry stream into the customer’s SIEM.
  7. 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)ContentsPlanes it relies on
AccessSSO, conditional access, role-based access, same-day joiner–mover–leaver, no personal accounts touching institutional data; workload identity federation for non-human callersIdentity
ControlGateway, Policy Decision API, MCP allow-list and broker, prompt/skill/agent registries, model usage registry, agent-readable data dictionary, evidence pipeline and SIEMRegistry, policy, observability
AgentA signed bounded-agency envelope per production agent, stored as policy-as-codeRegistry
EvidenceNine-question records for every material action; a product without evidence coverage stays away from critical or important functionsEvidence, observability
Operating modelNamed roles (executive sponsor, platform owner, business owner, wrangler, model risk, security, data, legal and compliance, internal audit, change-board chair) in a RACIApproval (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.

Six logical planes of an enterprise agent control plane, with a Cosmos DB persistence mapping shown only as one implementation example.

The six-plane model. The Cosmos DB collections in the source diagram are Book 1’s implementation example, not a required technology.

PlaneAnswersMinimum durable recordFailure posture
IdentityWho is acting?Identity-to-agent binding, issuance, revocation, fingerprintRefuse a protected action if the identity cannot be resolved
RegistryIs this agent allowed to exist, here, owned by whom, under what envelope?Definition, versions, signed envelope, lifecycle state, permitted tools and modelsNo route or credential for an unregistered component
PolicyMay this action happen now?Rule versions; every decision with rationale and rules firedFail closed, or route to approval by action class
ObservabilityWhat is happening?Action traces keyed to agent, wrangler, decision and evidence recordPreserve local signals; raise a gap when central collection lags
ApprovalDid an accountable human say yes?Workflow definitions; every approval, refusal or timeout with rationaleExpire or escalate; timeout is never approval
EvidenceWhat is the structured record?One nine-question record per evidenced action with pointersQuarantine 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.

ContractBetweenCarries (minimum)Suggested ownerBreaks when
IssuanceIdentity → registryProvider identity ID, agent ID and version, issuance and revocation times, fingerprintIdentity engineering leadIdentity provider and registry disagree; no daily reconciliation
LookupRegistry → policyDefinition, lifecycle state, zone, wrangler, envelope at version, tool and model entriesRegistry product ownerPolicy decides against a stale or unversioned envelope
Decision capturePolicy → observabilityRequest, response, rules fired, latency, decision IDPolicy engine ownerDecisions are made but not recorded, or recorded without agent identity
EscalationObservability → approvalDecision ID, trigger class, resolved approver role, SLA clockApproval workflow ownerEscalations queue without an owner or SLA
Artefact handoverApproval → evidenceApproval record bound to the exact action or version, rationale, supersessionEvidence pipeline ownerApprovals 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

FieldContent
agent_id, agent_versionRegistry identity of the deployed version
wrangler_idAccountable human owner
intended_action.type, .tool, .parametersWhat the agent proposes, e.g. tool_call against an mcp:// tool
target_systemExecuting system and environment
target_data.classifications, .estimated_recordsData classes and volume
session.initiator_type, .initiator_id, .channel, .session_idWho or what started the chain
context.zone, .ticket_id, .request_timeOperating 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

FieldContent and rule
decisionOne of allow, allow_with_evidence, escalate_for_approval, deny
policy_decision_idStable ID that every downstream record references
rationaleA sentence an engineer can read, naming registry entry, tool catalogue entry, envelope clause and initiator authorisation
policy_rules_firedMachine-readable list of rule IDs
required_evidenceObligations the evidence plane must honour (e.g. evidence_record:full, apply a sensitivity label)
required_approvalsApprovals the approval plane must collect before execution
constraintsRuntime obligations, e.g. egress_redaction fields, max_records, ttl_seconds
expiryHard ceiling: execute before it or call again; prevents replay and long-lived authorisations
owasp_mappings, regulatory_bindingsBindings 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.

LayerRuleSource
Agent actionsEvery action with an external effect (tool call, write, model invocation with external effects, data read above a sensitivity threshold) goes through a decisionBook 1 Ch 11 §4.1, §5.2
Gateway-mediated model trafficTier 0–2 workloads typically do not call it; Tier 3 calls it on writes; Tier 4 on every consequential actionBook 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.

TargetValue (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:

  1. 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.
  2. 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.
  3. Keep decisions short-lived with expiry, so caching never becomes standing authorisation.
  4. Watch cost. policy_decisions is 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_data field 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:

FailureWhat was missingControl-plane rule
Undifferentiated authorityOne identity could both develop and modify production state; deployment approval did not bound runtime authoritySeparate development and production identities and means; production write is not in a development agent’s envelope
Irreversibility without a gateNo platform check before an irreversible deletionAny 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 recordThe agent’s own output was the only account of its actionsThe 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.

GroupCollectionOne record perKey rules
Registryagent_definitionsAgentMandate, wrangler, zone, business line, environment, lifecycle status (proposed, approved, in-development, in-production, deprecated, retired)
agent_versionsVersionChange description, deployer, deployment time, policy bundle, pinned model, prompt-template fingerprint, tool list, previous-version link
agent_envelopesVersionMandate (scope, prohibited scope, escalation triggers), Means, Memory, Monitoring; signed by the wrangler; read on every decision
lifecycle_eventsTransitionRegistration, version bump, zone/mandate/wrangler change, suspension, retirement; actor, rationale, linked approval
Identityidentity_linksAgent identity bindingProvider identity, issuance, revocation, fingerprint, credential lifecycle; reconciled daily against the identity provider
Policypolicy_rulesRuleVersion-pinned, named control owner, effective dates, supersession; activation needs recorded approval; retirement must evidence the replacement
policy_decisionsDecisionRequest, response, rules fired, latency, agent and version, outcome
Observabilityaction_tracesActionAuthorising decision, tool, redacted inputs/outputs, outcome, duration, downstream effects
sensitive_data_findingsFindingClassification, detector, trace, whether permitted/redacted/blocked, remediation
Approvalapproval_workflowsWorkflowAs above
approval_recordsInstanceAs above
Cataloguesmcp_tool_registryMCP 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
Evidenceevidence_recordsEvidenced actionNine 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

EngineFirst storeSecond storeWrite-consistency caution
Azure (reference)Cosmos DB for all fourteen—Session-level consistency; change feed
AWSDynamoDB 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
GCPFirestore 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.

PhaseLarge firm (≈50,000 staff)Planes and deliverable
1Months 1–3Identity + 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
2Months 3–6Policy + 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
3Months 6–9Approval + 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:

  1. 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.
  2. 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.
  3. The model is a named, substitutable component reached through the gateway; evidence format, workspace, toolchain and review gate are the durable structure.
  4. 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.

TierWhereDuties
LeafWherever an agent or operator works: runner, CI worker, agent runtime, vendor gatewayBuild the evidence record, bind identity, redact, sign, append locally; local store is the truth until the edge acknowledges; evaluate signed policy packs locally
EdgeOne per legal entity and jurisdictionPipeline: 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
CentreOnce 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 planeTypical rolesWho may hold them
Control (create, configure, assign policy, grant roles)Roles that stamp subscriptions, assign policy and manage who else may actA 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 sideEnforced by (Book 1 Ch 10)Plane (this page)
MandateThe identity-aware gateway intercepts every callPolicy, observability
MeansPer-agent identity binds the credential each call carriesIdentity
MemoryThe central registry knows what the agent may read and where the platform writesRegistry
MonitoringEvaluations and runtime guardrails leave evidencePolicy, 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):

  1. Score the current provider against the five primitives, one owner per primitive (identity, platform engineering, AI security, API platform, model governance).
  2. 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.
  3. 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.
  4. 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

FunctionOwnsSignsAnti-pattern if absent
CompliancePolicy-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 obligationsQuarterly attestation to the operational-risk committee that the rule corpus and evidence schema discharge standing obligationsA SIEM workspace with no rule-to-obligation mapping when the supervisor asks how logging duties are met
Internal auditAn 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 reportHalf-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

FailureRecognition testRecovery
Registry as inventoryCan the pipeline create an agent that is not in the registry? If yes, it is an inventoryMake registration a hard pipeline gate in Phase 1
Yes/no policy engineSample deny responses: do they say what to do?Every deny carries rationale and path-to-allow
Observability without identity attributionMetric: share of action_traces with null, generic or service-account agent_id. Target zero; alert on any non-zero daily countMake identity propagation a runtime contract; reject untraceable calls; cost grows with every week of null records
Evidence as logsIs 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 deliverableSingle “deploy the toolkit” line in the planScope 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_id in 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 allow alone.
  • 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_id alert 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

← All AI Delivery Factory guidance

On this page

  1. Draw the ownership boundary first
    1. What the provider itself says you must build (dated)
    2. The firm’s box, expanded: five layers
    3. The vendor toolkit is substrate, not the deliverable
  2. The six planes and their contracts
    1. The five inter-plane contracts
  3. Policy Decision API contract
    1. Request: POST /policy/v1/decide
    2. Response
    3. When the API is called: two layers
    4. Central PDP or distributed evaluation
  4. Latency budget and caching
  5. Every deny carries a path to allow
  6. Irreversible actions need separate authority
  7. Approval-plane routing and SLAs
  8. Persistence schema: 14 collections
    1. Registry reads must be point-in-time and signed
    2. Engine landings and write consistency
  9. Build sequence
  10. Govern agent execution by architecture
  11. Topology: leaf, edge, centre
  12. Place the control plane in the cloud estate
  13. Contract for portability and exit
  14. Compliance and internal-audit deliverables
  15. Failure modes and recognition tests
  16. Acceptance checks and recovery
  17. Provenance and review state

All pages in Understand →