Browse the reference ⌄
Implementation Guide published

Design the Cloud Production Line and Hosting Boundaries

Classify, 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.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
30 min

For Cto · Ai Architect · Platform Engineer · Security Engineer · Risk And Assurance

Sources and details
Source works
Book 1 · Book 2 · Book 3 · Research Series
Source chapters
2, 4, 5, 8, 10, 11, 12, 23
Refresh trigger
vendor release

Full source list ↓ Source index →

Cloud landing zones are the delivery floor: the classified, segmented and observable environments in which products, and the human and agent workers who build them, are provisioned. A hosting decision is more than choosing a provider or region. It fixes the identity, network, policy, data and evidence boundaries that every application inherits, and in the agent era it also fixes what an agent can physically reach.

This page covers four decisions in order: how to read the cloud as a control plane (the ten pillars), how to draw the production line (classify, segment, constrain, emit), how to choose a hosting route for AI workloads, and how to keep vendor maturity, contracts and exit equivalence honest. Landing-zone build detail (management-group hierarchy, IP address management, minimal deny sets) lives on Prepare a governed landing zone; data classes and their flags live on Data classes and processing lanes. Regulatory dates and article-level statements are on the regulatory map.

The production line carries policy and evidence through sandbox, development, test and production stations for both people and coding agents.

The cloud production line classifies workspaces, constrains them by inherited policy and emits evidence at each stage. Source: The AI Delivery Factory, Chapter 10, Figure 10.3.

Begin with the workload and its constraints

For each product or workload, document the decisions that drive hosting before selecting a service:

  • Data and processing: data classes and flags, client or personal data, records with retention duties, and where data may be processed or accessed.
  • Business impact: service criticality, whether it supports a critical or important function, recovery objectives and third-party dependencies.
  • Identity and access: human, workload and agent identities; data-plane permissions; privileged control-plane operations.
  • Network and integration: approved ingress, egress, private connectivity, service-to-service routes and external model or tool endpoints.
  • Operations: environment stages, monitoring, logging, backup, incident response, support ownership and change controls.
  • Evidence: policy decisions, access and deployment events, release manifests, retention, and the ability to reconstruct a material action.
  • Portability and exit: data export, configuration portability, model and service dependencies, and the effort to change region or provider.

Separate legal or contractual constraints from architecture choices and institutional policy. This guide does not make a regulatory determination. Record the rationale and the named owner of each decision in the product’s bill of material and architecture record.

Read the cloud as ten capability pillars

Book 1 (Chapter 5) argues that the cloud is the firm’s control plane, not a hosting department, and decomposes it into ten capability pillars. Nine predate the AI agenda; the tenth, AI platform control, exists only because agents exist. Pillars are capabilities to be owned and measured, not an organisation chart. FinOps is deliberately not a pillar: it cuts across several, and treating it as the only non-technical lens lets cost metrics crowd out identity hygiene, classification and policy coverage.

PillarWhat it enforcesWhat agents change (Book 1 Ch 5)Auditor’s question to be able to answer
IdentityWho or what may act, and on whose behalfAgent identities are many and short-lived; joiner-mover-leaver must work as an event streamEvery identity that touched system X this week, agents included
NetworkReachability, egress, private endpoints, DNSEgress allow-lists change daily rather than quarterlyNo agent in development can reach production data
SecurityPosture, detection, data protectionNew threat shapes: prompt injection, data poisoning, tool abuseHow quickly a prompt injection is detected
ComputeVMs, containers, serverless, agent runtimesHosted agent runtimes are consumed by API; the discipline becomes contract operations against a black boxWhat runs each critical or important function
DataState, catalogue, classification, lineage, residencyLabels must propagate into generated content; the data dictionary the agent reads becomes the first productWhere sensitive data is and who can read it
IntegrationAPIs, messaging, MCP gatewayA new supplier class (MCP-only); the MCP registry sits beside the API catalogueWhich APIs and MCP servers are exposed and who calls them
ObservabilityLogs, traces, metrics, evidenceThe log record becomes a reasoning trace that must answer the evidence schemaThe audit trail for action Y
GovernancePolicy-as-code, privileged access, exceptionsPolicy is evaluated against agent traffic in milliseconds; every initiative must be machine-evaluableWho approved this exception
AutomationPipelines and infrastructure as codeAgents generate infrastructure code at scale; the pipeline checks the content of the merge, not only the PRWhether this was deployed through an approved pipeline
AI platform controlAgent registration, guardrails, evaluation, agent policyNet-new pillarWhat this agent can actually do

Ownership by size (Book 1 Ch 5 §7, author proposal). A very large firm can run each pillar as a capability group with one accountable director. A firm of around a thousand people should group the ten under no fewer than five named owners (for example Identity with Governance; Network with Security; Compute, Data and Integration; Observability with Automation; AI platform control on its own). One owner for all ten is a single point of failure for the whole control plane.

Two recurring failures. Cloud as the hosting team: quarterly metrics are dominated by unit cost and reserved-instance coverage; recover by commissioning a control-plane review reported against the ten pillars. AI as a separate pillar stack: an AI centre of excellence builds its own identity, classification and observability, then collides with the cloud organisation’s controls; recover by folding it back in as the AI platform control pillar. The pillar self-assessment (three dimensions scored 0–2 per pillar) and its 90-day plan are on Assess agent readiness across the estate.

Draw the production line: classify, segment, constrain, emit

Book 2 (Chapter 10) reads the estate as a production line with four moves. The order is the control: segmentation needs to know what a workspace is for; policy needs to know which identity and network boundary it protects; and a constraint that leaves no evidence is asserted, not proven. A line that skips a move has a break, and that break is where an agent lane will eventually push.

  1. Classify. Stamp tenant class, workspace purpose, stage and data sensitivity before any resource exists.
  2. Segment. Turn the classification into walls along identity, network and access.
  3. Constrain. Press inherited policy down on the classified, segmented workspace; deny what must not proceed and remediate what can be fixed automatically.
  4. Emit. Make the line write its own provisioning, policy, deployment and access records, organised the same way as the estate.

Both worker classes draw workspaces from the same line. A coding agent is provisioned into an identically classified and constrained workspace as a human engineer; that indifference is what lets a firm add agents without redesigning the floor.

Classify before provisioning

PropertyValues in the source taxonomyRule that comes with it
Tenant classNon-production / productionBuild and test policies and role definitions in non-production first, then promote them to production. Never debug a deny rule against a live regulated platform.
Workspace purpose (subscription, account or project type)Sandbox / managed / innovation / extensionSandbox: discovery, automatic eviction, nothing accumulates. Managed: fully governed, production-grade. Innovation: building landing zones and patterns themselves. Extension: lifted brownfield resources, labelled honestly as not yet fully governed.
Production-data permissionPermitted / neverNon-production may hold any number of environments but never production data: no copy, no reversible masked extract, no “just to reproduce a defect”. This is the line whose breach is reportable; enforce it first, as a deny on the non-production branch that refuses the copy at request time.
Staged development / t test / s staging / p productionDetermines gates, data restrictions and operating expectations.
Data sensitivityThe composite Asset Manager X uses four levels (public / internal / confidential / strictly confidential) with flags for personal data, client-identifying data, material non-public information and records under statutory retention (Book 2 Ch 10 §4.7)Selects policy and evidence obligations. Use the institution’s own ladder; see data classes for flags and their consequences.

Composite example (Book 2 Ch 10 §1, §6). A coding agent working in a non-production development instance understood its workspace was non-production and still wrote a copy of production data; the deny on the non-production management group refused it within minutes, emitted evidence and raised an exception, and the squad gave the agent a masked synthetic extract instead. The lesson is that an agent reading a rule is not the agent obeying it; the plane obeyed it. Recommendation: give teams a sanctioned synthetic or irreversibly masked data source, so the refused path has a governed alternative.

The classification is only worth drawing if an engine reads it. Make each property a tag, a hierarchy placement or resource metadata that policy evaluates continuously; a wiki page or CMDB field that only humans read is context an agent will note and route around. Do not copy the example values into production without mapping them to the institution’s approved terms. Missing classification should block high-impact provisioning rather than be guessed.

Name stages, environments and instances with one grammar

The source taxonomy (Book 2 Ch 10 §4.4, Figure 10.1, inherited from the author’s 2024 book) uses three levels, coarse to fine, kept deliberately terse because the codes appear in thousands of resource names:

  • Stage: one letter: d, t, s, p.
  • Environment: a numbered subdivision of a stage: d1, d2 for two squads; t1 functional test.
  • Instance: an environment pinned to a region, written <stage><number>-<region>; for example d1-weu is the first development environment in West Europe, and s1-weu with s1-neu is staging across two regions.
NeedGrammarWhy it is separate
Functional testt1-<region>Results are not polluted by load runs
Load testt2-<region>Scales independently of functional test
Compliance and security works1, s2Audit scans and patch-upgrade tests run in isolation
Productionp1-<region>, plus further regionsProduction carries the availability obligation, so it is multi-region by construction
Disaster recovery rehearsalp2-<region>A restore is rehearsed against a real target
Blue-green releasep1 and p2, one live, one stagedGeography-aware cutover between two production environments

The promotion path, for example d1-weu → t1-weu → s1-weu → p1-weu, is where gates attach. At each move record: the artefact version, the test result, the policy verdict, the approval, the deploying identity and the runtime evidence. A generated change moves through the same stations as a hand-written one; plausibility hides defects, which is why the stations exist. Coding agents read the same grammar to know which instance they are standing in and what it permits.

Segment along three axes

Classification says what a workspace is for; segmentation makes that a boundary. Segregate along identity (who or what may act, including agent identities), network (what a workload may reach, with non-overlapping address ranges and egress boundaries) and access (least-privilege roles). Manage address space centrally with one authoritative assignment record (resource, IP, subnet, environment, owner) and a regular reclaim audit; the full discipline is on the landing zone page. Give the platform-and-operations segment, which holds build agents and the automation that provisions everything else, its own governed boundary: it holds the most real privilege and is the segment firms most often forget to draw. When a risk committee asks what an agent could reach if it went wrong, the honest answer must be “the segment its workspace was provisioned into”, which only exists if segmentation was drawn before the agent arrived.

Enforce at the plane where the action executes

Every resource is touched through three planes, and controls do not land evenly across them (Book 2 Ch 10 §4.6).

Control, data and management planes expose different control surfaces; check identity and policy coverage at the plane where each operation executes.

The control plane provisions and governs resources; the data plane handles workload data; the management plane operates and observes services. Source: The AI Delivery Factory, Chapter 10, Figure 10.2.

PlaneWhat happens thereControls that reach it (Azure reference)Typical rolesWho may hold them
ControlResources are created and configured; policy is assigned; roles are grantedAzure Policy, management-group inheritance, role assignmentsSubscription stamping, policy assignment, role administrationA small, audited set of human identities under just-in-time elevation. Never an agent as a standing grant.
DataThe workload runs and data moves: database reads, secret retrieval, object readsRBAC reaches deepest here, but only for services that integrate data-plane RBACCustom data roles: data engineer, data steward, read-only analystWorkloads and agents, scoped to named stores and operations
ManagementThe estate is operated and observed: CLI, SDKs, monitoring, service-specific consolesMostly policy and diagnostics; some services add their own sub-control plane (Databricks is the book’s example)Operator and monitoring roles; service-specific admin rolesOperations staff; agents only for read-only observation unless approved

Three practical rules follow:

  • Enumerate data-plane RBAC coverage. List which services in the estate actually enforce role-based access at the data plane and which only appear to. A control-plane identity that is well governed can still exfiltrate through an ungoverned data-plane path.
  • Treat broad data roles as privileged. A data-plane role granted “to get it working” is the most common over-grant in agent deployments, because it feels operational. Scope it to the store and the operation.
  • Build an operation-by-control matrix. For provision, configure, read, write, administer, monitor and revoke, name the enforcing mechanism and the plane, then test whether an alternate path bypasses it.

Constrain with inherited policy

Assign the policy that matters high in the hierarchy so every present and future workspace inherits it: a deny on the non-production branch forbidding production data; on the production branch, initiatives for encryption, diagnostics, allowed regions, no public exposure and required classification tags. On Azure, a deny effect refuses a non-compliant deployment at request time and deployIfNotExists remediates a missing setting rather than only reporting it (Book 2 Ch 10, citing Microsoft Learn, accessed August 2026). Hierarchy design (a single main node below the tenant root, environment-first branches, a platform-and-operations branch) is on the landing zone page.

Why this layer is worth funding (author synthesis, Book 2 Ch 10 §4.7; Research Paper 8). A policy pack assigned at scope is the only asset whose consumer count rises without any consumer acting: new workspaces inherit it by landing under it, and a changed interpretation lands once for the whole estate. It also carries no runtime availability obligation of its own.

Ownership of the boundary. The plane-level guardrail (hierarchy policy, segmentation, identity scoping) belongs to the platform team. The agent’s behaviour within that boundary belongs to its named wrangler. Both ownerships must be real: a wrangler on an unbounded estate owns a promise, and a platform team bounding agents nobody owns has built a cage with no keeper.

Policy-as-code per cloud, normalised into one exception queue

The policy, audit, actuals loop needs three things on every cloud: intent declared as code, continuous evaluation against real resource state, and a queryable compliance surface (Book 2 Ch 8 §4.9). The instruments differ:

CloudPreventiveDetective and actualsQueryable compliance surfaceNote from the source
AzureAzure Policy deny at management-group scopeAzure Policy compliance state; deployIfNotExists remediationAzure Resource Graph queries over policy stateOne engine for prevention and detection
AWSService control policies in AWS OrganizationsAWS Config rules and conformance packsConfig compliance stateCleaner split between detective (Config) and preventive (SCPs), at the cost of two instruments
Google CloudOrganization Policy Service constraints down the hierarchySecurity Command Center and config-validation toolingSCC findings and validation resultsConstraint library narrower than Azure Policy’s built-in set (Book 2 Ch 10 §4.10)

Start weekly and by hand, then make it continuous (Book 2 Ch 8 §6, composite Asset Manager X example): wire the few most-breached rules into policy, run a scheduled query (Resource Graph on Azure) that pulls non-compliant rows into one table for risk and the platform lead, and drive the standing backlog down. Then move the comparison onto the evidence store as standing queries that run on every new record, raising departures into an exception queue with context attached:

  • which policy, which actual, and since when;
  • whether a declared exception already covers it (declared exceptions are marked known, not chased);
  • whether the departure was already remediated before anyone reached it (the loop records the remediation; in the source a production-data copy was deleted by an engineer before second line opened it).

Matches record silently; only departures enter the queue.

A multi-cloud firm should normalise the three providers’ compliance surfaces into one exception queue rather than three consoles nobody reads together. Second line adjudicates the queue; it does not reconcile the tables. See Close the policy, audit and actuals loop.

Emit evidence by construction

The fourth move decides where actuals are born. Do not default to one global log workspace: it collapses the boundaries the taxonomy drew.

Design decisionSource recommendation (Book 2 Ch 10 §4.8)Acceptance check
LayoutOne log workspace per region × stage; multiply again where data confidentiality is a third dimensionA query about production in one region reads a workspace holding only that region and stage
ProvisioningAutomation lays the workspaces down and applies the governing policy from the hierarchy aboveNo hand-created workspace exists outside the matrix
Metadata registerEach workspace’s purpose, region, stage, confidentiality and owner are recordedThe register reconciles with the deployed workspaces
RetentionSet per workspace and per table, where the data lands, from the applicable obligationProduction security telemetry and short-lived development logs carry different, documented retention
Onward flowRaw telemetry feeds the audit spine, whose signed, schema-validated records outlive the telemetry’s retentionA material action can be reconstructed after the raw logs have aged out
Illustrative matrix (two regions, two of the four stages)West EuropeNorth Europe
d developmentlaw-d-weu: short retention, broad engineering readlaw-d-neu
p productionlaw-p-weu: long security retention, restricted read, feeds audit spinelaw-p-neu

The workspace names are illustrative, not a source standard. Evidence produced as a by-product of the line running is more trustworthy than evidence assembled afterwards, because no interested party stood between the event and the record. Link records to the product’s audit evidence chain.

Choose the hosting route per request

For AI workloads the class of the data in a request decides where it may be processed, before anyone chooses a model (Book 2 Ch 23 §4.2). The book uses three hosting routes: vendor API (the model developer’s or aggregator’s endpoint under an enterprise agreement), private tenancy (a vendor model served inside the firm’s own cloud tenancy, approved region, private endpoints, customer-managed keys where supported) and controlled infrastructure (open-weight or licensed models on infrastructure the firm controls). Research Paper 9 calls these processing lanes A, B and C; the glossary crosswalk reconciles the vocabularies, and the per-class permission matrix and inheritance rules are on Data classes and processing lanes. The model gateway enforces the route per request (highest class present across all inputs), not per application.

How each cloud builds the three routes

As of September 2026, per Book 2 Ch 23 §4.4 (Microsoft Learn, AWS and Google Cloud documentation cited there). [FACT-CHECK: service names, region availability and key-management support per route against current Microsoft, AWS and Google documentation]

RouteAzure (book’s reference)AWSGoogle Cloud
Vendor APIModel providers under enterprise agreement, reached through the firm’s own gateway, never directly from applicationsSame patternSame pattern
Private tenancyAzure AI Foundry model deployments pinned to EU regions, private endpoints, customer-managed keys; API Management or an in-house gateway in front for per-client identity and classificationBedrock with region-pinned model access and customer-managed KMS keys; Bedrock Guardrails carries part of per-request classificationVertex AI region-pinned endpoints with VPC Service Controls and customer-managed keys
Controlled infrastructureOpen-weight models on AKS with managed identity and no egressSageMaker or EKS with open weightsGKE with open weights
What makes it stickAzure Policy at management-group scopeService control policiesOrganisation policy constraints

Deny the global deployment types on day one. Book 2 criticises Azure AI Foundry for presenting “global” and “data zone” deployment types as a throughput setting when their consequence is residency. Anyone who can create a deployment can make that choice without reading the classification policy. Deny those deployment types at management-group scope from the start and grant exceptions deliberately, with a named approver and an expiry. [FACT-CHECK: current Foundry deployment-type names and the policy aliases that can deny them, against Microsoft Learn]

The shared weakness. None of the three clouds classifies the firm’s data, and each will route strictly confidential content to a permitted region along an unexamined path. The classification is the firm’s job; choose the cloud you already run on rather than choosing on route features.

Claude-specific routes (dated)

Book 3 (Chapter 4) records five procurable Claude routes plus one that arrives through an admin toggle, as of 3 August 2026. These are current product claims and change quickly. [FACT-CHECK: every row against current Anthropic, Microsoft, AWS and Google documentation before relying on it]

Route (as of Aug 2026, per Book 3 Ch 4)Data processorEU inference position recorded in the sourcePoints to check before use
Direct Anthropic APIAnthropicNo eu inference geography; workspace geography us; transfer handled by SCCs and a transfer impact assessmentZero-data-retention covers only named endpoints; many surfaces are outside it
Microsoft Foundry (GA 29 June 2026)Anthropic, per the GA statementOnly a US data zone named at GA; no EU commitment publishedBook 3 notes the GA processor statement is not qualified by hosting model (“hosted on Azure” or “hosted on Anthropic”), and Microsoft’s client documentation gave no region list or private-networking guidance; pin models explicitly because aliases resolve differently per route
Amazon BedrockAWSIn-region inference in several EU regionsSome features lag (Book 3 lists them); a regional endpoint premium applies
Claude Platform on AWS (GA 11 May 2026)AnthropicSeveral European regions listedProvisions a new Anthropic organisation; Bedrock IAM roles do not authorise it
Google Cloud Agent Platform (formerly Vertex AI)Googleeurope-west1 and the eu multi-regionPer-model region overrides; some models only on global at launch
Claude in Microsoft 365 Copilot (admin toggle)Anthropic, outside Microsoft-managed environments per AnthropicExcluded from the Microsoft EU Data Boundary per the sourceArrives without procurement or landing-zone review; needs its own register row and an owner who reads both Microsoft routes

Whether each processor is a designated critical ICT third-party provider, and what that means for diligence, is a regulatory question: see the regulatory map. Whatever the route, pin the model version in configuration under change control.

Map the concepts to cloud providers

The structure is portable; provider names and behaviour change. Validate exact capabilities, service names, limitations and region availability against current official documentation before implementation. [FACT-CHECK: all provider rows below against current documentation; they follow the books’ 2026 reference mapping]

Control concernAzureAWSGoogle Cloud
Isolation unit and hierarchySubscriptions under management groupsAccounts under organisational units in AWS Organizations. Book 2 rates account-per-workload as the harder default blast-radius wallProjects under folders and the organisation node. Book 2 calls the project the cleanest unit to explain to a risk committee
Preventive guardrailsAzure Policy deny at management-group scopeService control policies; Control Tower guardrailsOrganization Policy constraints
Detection and remediationAzure Policy compliance, deployIfNotExists, Defender for CloudAWS Config with remediationSecurity Command Center, config validation
Provisioned environmentLanding zones and governed subscriptionsControl Tower landing zone and account vendingFolder-and-project factory under the organisation hierarchy
Recipe infrastructure packagingBicep modules published as Template Specs or driven through Deployment StacksCloudFormation, CDK or TerraformTerraform (commonly the default)
Agent identity (2026)Entra Agent IDBedrock AgentCore with IAM session tagsGemini Enterprise Agent Platform agent identity

Keep provider components substitutable. The recipe’s job is to name components so they can be swapped (Book 2 Ch 5). Azure Blueprints is the standing example: Book 2 records that Microsoft is retiring it, with a phased wind-down from 31 July 2026 and full retirement on 31 January 2027, and directs customers to Template Specs (store and version definitions) and Deployment Stacks (assignment, lifecycle and deny-assignment locking) (Microsoft Learn, accessed August 2026, as cited in Book 2 Ch 5 and Ch 6). Recipes that still name Blueprints name a product with a retirement date. [FACT-CHECK: Blueprints retirement dates and replacement guidance against the current Microsoft Learn retirement page] Write each control objective first (“production data may not enter non-production”) and the provider mechanism second, with scope, bypass paths, owner, evidence and a refresh date.

Know the agent-platform primitives and their dated maturity

Book 1 (Chapter 10) observes that the three hyperscalers have converged on five primitives for governing agents. Design and contract to the primitives; let implementations differ.

PrimitiveVendor-neutral definition (Book 1 Ch 10 §4.1)
Per-agent verifiable identityA centrally issued, cryptographically verifiable identifier per agent, distinct from human and service-principal identities, bound to authorisation at every invocation; revocable, time-bounded, auditable
Central registry of agents and toolsSingle source of truth for which agents exist, their named owner, mandate, permitted tools and data, and status
Runtime policy enforcementGuardrails configured centrally and enforced at every model invocation and tool call: content filters, denied topics, PII redaction, output schema validation, and where applicable formal-logic verification
Identity-aware gatewayEvery agent-to-tool, API or data call passes through one point that logs calling identity, called tool, policy decision and outcome
Quality and behavioural evaluationA pre-deployment scenario library and runtime monitoring against the same scenarios, with regressions alerted

Vendor maturity verdicts as of May 2026

These are the author’s verdicts from architecture-council sessions (Book 1 Ch 10 §5; Ch 11 §4.5; Ch 12 §4.4.1). The source says they will date and should be revisited every quarter. Replace them with the firm’s own implementation status before use. [FACT-CHECK: every verdict and GA status below against current Microsoft, AWS and Google documentation; several were preview or announcement-stage in May 2026]

Primitive or planeMicrosoftAWSGoogleSource verdict
Per-agent identityEntra Agent ID (preview at Agent 365 GA; delegated agents first)IAM roles with session tags plus AgentCore identity extensionsAgent Identity (announced April 2026)Microsoft and Google for greenfield; AWS where heavy IAM investment exists; none has solved revocation cleanly
RegistryAgent 365 Registry with sponsor lifecycleAgentCore Registry (Strands integration)Agent Registry with partner marketplaceRead each against the DORA ICT inventory duty; Microsoft smoothest, Google needs most integration
Runtime policyCopilot Studio guardrails plus Purview DLP; Agent Governance Toolkit policy module in previewBedrock Guardrails, AgentCore Policy (GA 3 March 2026), Automated Reasoning checksSemantic governance policies, Agentic Defense (announcement-led)AWS materially ahead; benchmark against its pattern even if not on AWS
Identity-aware gatewayEntra, SASE for agents, API ManagementAgentCore, Organizations Bedrock policies, API GatewayAgent Gateway plus ApigeeAll credible; choose on existing API gateway investment
EvaluationFoundry evaluations, Agent 365 quality flags, Defender signalsAgentCore Evaluations (GA 31 March 2026)Vertex-derived evaluation servicesAll usable; design against the AWS pattern
Observability planeMost integrated (Application Insights, Defender, Sentinel, Purview)CloudTrail with AgentCore audit extensions, CloudWatch via AthenaCloud Audit Logs with Vertex integrationMicrosoft leads on cross-environment visibility
Approval plane and wrangler lifecycleEntra ID Governance sponsor lifecycle workflow: assignment at creation, periodic review, revocation cascade on departureNo productised equivalent; build with IAM Identity Center events, Step Functions and EventBridgeNo productised equivalent; build with Cloud Identity, Workflows and the evaluation surfaceMicrosoft roughly six to twelve months ahead
Evidence planePurview SDK (from late June 2026) closest to a productised evidence planeFirm builds itFirm builds itThe evidence schema is the firm’s own on any cloud; one to two engineer-quarters to build on a non-Microsoft cloud

Two cautions from the source. The Microsoft Agent Governance Toolkit (preview from 15 April 2026) supplies middleware, roughly 30–40 per cent of what a regulated firm needs; wrangler relationships, zones, enriched evidence records, the model-usage registry and integration with change and identity governance remain the firm’s work. And policy engines are not interchangeable: swapping one vendor’s guardrails for another’s without re-running the capability map can silently drop a control (for example formal-logic verification). The control-plane architecture these primitives feed is on The enterprise control plane.

The bounded-agency envelope on each cloud

As of May 2026, per Book 1 Ch 2 §5.5 (citing each vendor’s documentation accessed May 2026). [FACT-CHECK: service names and roles against current documentation]

Envelope elementAzureAWSGoogle Cloud
MandateAgent registration in Foundry Agent Service plus Azure Policy assignmentsAgent definition in Bedrock AgentCore with IAM and AgentCore PolicyAgent definition in Gemini Enterprise Agent Platform
MeansEntra Agent ID plus Foundry tool registrationsIAM role (action, resource, condition) gated by AgentCore IdentityAgent Identity bound to IAM, Apigee as the MCP gateway
MemoryCosmos DB, Azure AI Search, Foundry-managed memory; Purview as classification referenceAgentCore Memory plus connected stores under Lake FormationAgent Registry plus connected stores
MonitoringAzure Monitor, Application Insights, Foundry tracing; Sentinel for securityCloudWatch, X-Ray, AgentCore ObservabilityCloud Logging, Cloud Trace, Gemini Enterprise observability

Read the envelope before the platform; the terminology differs, the pattern does not. The envelope itself is defined on The bounded agent.

Write the contract spine and prove exit equivalence

Convergence is what the architect designs to; concentration is what the firm contracts and exits against (Book 1 Ch 10). An exit plan is operational only if the firm can map what it runs on the incumbent to what it would receive elsewhere. The DORA exit-strategy obligation for critical or important functions is stated on the regulatory map; this section is the engineering artefact behind it.

The “no vendor names” test. For any agent in production, ask whether its function, means and controls can be described without the vendor’s product names. If not, exit is performative.

Build the spine (author’s procedure, Book 1 Ch 10 §7). In a large firm this is about five weeks; a firm on one hyperscaler can compress it to a one-week sprint led by one platform lead.

WeekStepOwner proposed by the sourceOutput
1Copy the five-primitive table into the firm’s template; replace the vendor verdicts with the firm’s own implementation statusPlatform architectureFirm-specific primitive table
2Assign an owner and a maturity score against target per primitiveIdentity head (identity); platform engineering head (registry); AI security head (runtime policy); API platform head (gateway); model governance head (evaluation)Five owners, five scores
3Gap analysis: where the firm is below target, where the vendor isPrimitive ownersGap list
4Review contracts against the primitives. Where a contract does not name a primitive, flag procurement. Where exit to an equivalent is unclean, flag the CRO and the third-party risk ownerProcurement, third-party riskContract gap and concentration flags
5One page to the architecture council: five primitives, owners, scores, gaps, contract statusPlatform architectureSpine artefact, reused for supervisor and internal audit

Specify capabilities, not products, in the contract. For runtime policy, list the required capabilities (content filtering across the agentic threat categories; denied topics; PII redaction; output schema validation; formal-logic verification where the use case needs it) and map each vendor implementation against the list.

Draw the primitive equivalence map in advance. For each agent on a critical or important function, record per primitive: the incumbent implementation, the equivalent on the alternative, what does not port (configuration mechanics usually do not), and the estimated effort. The source’s worked example (a hypothetical contract-clause review agent deployed on all three clouds) shows “read access to the repository” and “PII redaction” expressed three different ways; functional equivalence is real, configuration portability is not. Retrofitting the interface layer after vendor specifics have leaked in costs, by the author’s estimate, three to twelve person-months per primitive.

Acceptance check. Internal audit can trace each agent to its values in the primitive scoring; if it cannot, the artefact is not finished.

Test whether multi-cloud is real

A multi-cloud declaration that leaves workload on one provider adds cost without reducing concentration. Book 1 Ch 10 §8 gives thresholds (author proposals, not regulatory figures):

TestThresholdReading
Criticality-weighted share of agent workload on the dominant hyperscalerAbove 80 per centThe multi-cloud declaration is theatre
Material workload on a second hyperscalerRoughly 20–30 per cent by criticality-weighted volumeA credible second platform
Stress shiftA documented runbook able to move at least 10 per cent within four weeksThe second platform can carry load under stress

Choose one honest position: either commit to the second-platform thresholds and rehearse the shift, or declare single-hyperscaler dependency and design the exit plan, contract spine and resilience around it. Book 2 (Ch 10 §8) adds that a firm is not obliged to be multi-cloud; it is obliged to explain its controls independently of the provider. Assign a named owner (typically regulatory affairs, with CIO and CRO input) to follow the supervisory dialogue on AI-platform concentration; see the regulatory map.

Bring the brownfield estate onto the line

Most estates predate the taxonomy. Draw the target line; classify existing work honestly (the extension type exists so nothing is mislabelled as governed, which would mislead both policy engine and agent); migrate in priority order, critical or important functions first. The agent lane runs on the governed part of the estate from day one and is kept off the rest by policy. Where address spaces already overlap, the extension classification lets the firm label the problem accurately while it unpicks it.

Monday move (Book 2 Ch 10 §7). Pick one product’s path to production and list every cloud control it touches (account, identity, network, secrets, policy, deployment path, logging, monitoring, cost, evidence). Mark each as inherited from the landing zone or improvised by the team; the improvised column is the platform backlog. Then run two tests: is the classification a resource property that policy evaluates, and would deny- and remediation-class policy catch a non-compliant version of a real generated infrastructure change before it lands? If either answer is no, the line is not ready for AI-assisted infrastructure. Keep hierarchies shallow enough that platform engineers can draw them from memory.

Failure modes and recovery

FailureRecognise itRecover
Cloud as a faster data centre”Where does this policy live?” is answered with a runbookMove the highest-risk control (production-data egress) from runbook to a deny at hierarchy scope
Landing-zone theatreA fine reference architecture with low adoption; teams provision around itMeasure request-to-governed-workspace time and drive it below the time to provision around it
Classification the engine cannot readTaxonomy lives in a wiki or CMDB field onlyMake it a tag, placement or metadata that policy evaluates
Guardrail at the document, not the planeThe control for agent-provisioned change is “the reviewer will catch it”Move the boundary to policy, egress rule and identity scope
Lock-in without exit thinkingControls described only as provider assignments, never as objectivesWrite the objective first; build the primitive equivalence map
Single-hyperscaler dependency with a paper exit planAgents cannot be described without vendor product namesRetrofit the interface layer primitive by primitive
Multi-cloud theatreOver 80 per cent of criticality-weighted workload on one providerMeet the second-platform thresholds or declare single-cloud honestly
Treating policy engines as interchangeableProcurement compares two “policy engines” as equalRe-run the capability map before any swap

Review and acceptance checklist

  • The workload has an approved classification (tenant class, purpose, stage, sensitivity), hosting rationale, named owner and recorded dependencies, and policy evaluates the classification as a resource property.
  • Policies and role definitions were developed in non-production and promoted; none was first tested in production.
  • Instance names follow the stage-environment-region grammar, and every promotion step records artefact version, test result, policy verdict, approval, deploying identity and runtime evidence.
  • No agent holds a standing control-plane role; data-plane roles are scoped per store and operation; the data-plane RBAC coverage list is current.
  • Production and non-production paths have tested separation, including data access and outbound routes.
  • Policy compliance from every cloud feeds one exception queue with policy, actual, duration and declared-exception context.
  • Log workspaces follow the region × stage matrix, are in the metadata register, and carry per-workspace and per-table retention.
  • The hosting route is enforced per request at the gateway; global and data-zone model deployment types are denied at scope unless an approved exception exists.
  • The five-primitive table carries the firm’s own dated status, owners and contract gaps; each agent on a critical or important function has a primitive equivalence map.
  • The multi-cloud position is stated against the thresholds, or single-cloud dependency is declared with a matching exit design.
  • Provider mappings have current official references and a review date; vendor verdicts are re-dated at least quarterly.

Source status. Classify, segment, constrain, emit; the ten pillars; the five primitives; the contract spine and the multi-cloud thresholds are author proposals and syntheses from Books 1 and 2. Vendor verdicts and Claude route facts are dated product claims from Books 1 and 3 that have not been re-verified against current vendor documentation for this page. Asset Manager X and Bank A are composites; the contract-clause agent is a hypothetical example. Keep this page in draft until the FACT-CHECK markers are resolved.

Source material

  • Book 1, Chapter 2, The Bounded Agency Thesis (§5.5 cloud-platform equivalents)
  • Book 1, Chapter 5, The Framework Backbone and the Cloud Control Plane (§4.2 ten capability pillars, §7 practical application)
  • Book 1, Chapter 10, The Convergent Platform Pattern (five primitives, vendor maturity, contract spine, anti-patterns)
  • Book 1, Chapter 11, The Enterprise Agent Control Plane (§4.5 six planes across Microsoft, AWS and Google)
  • Book 1, Chapter 12, The Agent Wrangler and the Agent Lifecycle (§4.4.1 Microsoft, AWS, GCP equivalents)
  • Book 2, Chapter 5, Bills of Material and Recipes (provider components, Blueprints retirement)
  • Book 2, Chapter 8, The Policy, Audit, Actuals Loop (§4.9 policy-as-code on Azure, AWS and GCP; §6 worked example)
  • Book 2, Chapter 10, Cloud as the Production Line
  • Book 2, Chapter 23, The Ten Recipe Families (§4.2 classification decides the route; §4.4 the three routes on AWS and Google Cloud)
  • Book 3, Chapter 4, The Deployment Decision (Claude routes as of August 2026)
  • DEIXEI Research Series, Working Papers 07 and 09

← All AI Delivery Factory guidance

On this page

  1. Begin with the workload and its constraints
  2. Read the cloud as ten capability pillars
  3. Draw the production line: classify, segment, constrain, emit
    1. Classify before provisioning
    2. Name stages, environments and instances with one grammar
    3. Segment along three axes
    4. Enforce at the plane where the action executes
    5. Constrain with inherited policy
    6. Emit evidence by construction
  4. Choose the hosting route per request
    1. How each cloud builds the three routes
    2. Claude-specific routes (dated)
  5. Map the concepts to cloud providers
  6. Know the agent-platform primitives and their dated maturity
    1. Vendor maturity verdicts as of May 2026
    2. The bounded-agency envelope on each cloud
  7. Write the contract spine and prove exit equivalence
  8. Test whether multi-cloud is real
  9. Bring the brownfield estate onto the line
  10. Failure modes and recovery
  11. Review and acceptance checklist

All pages in Build the platform →