Browse the reference ⌄
Implementation Guide published

Prepare a Governed Landing Zone for AI Delivery

Design 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.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
28 min

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

Sources and details
Source works
Book 1 · Book 2 · Book 3 · ADD proposal · Supporting Tools
Source chapters
2, 8, 10, 12, 16, 21
Source appendices
02:B
Tool specifications
deployer_manifest@0.1.0, audit_evidence_schema@0.1.0
Refresh trigger
vendor release

Full source list ↓ Source index →

A landing zone is the governed environment where a product and its delivery workers, human and agent, build, test and run. It is more than an account or a network template: it binds identities to a scope, decides what each workload may reach, enforces policy at a boundary teams cannot step around, and emits evidence by construction. Give teams and agents access only after those boundaries exist and have been exercised.

This page covers the landing zone as a whole: how to lay out the hierarchy, how to enforce, what the paved workspace must contain, how the agent-platform components integrate, and how you prove the zone is finished. The companion cloud and hosting guide covers workload classification, the three planes and the classify–segment–constrain–emit sequence; the enterprise control plane covers the agent-governance services the zone hosts.

How to read the claims. Book 1 and Book 2 describe the hierarchy and deny-mode discipline from Azure practice, with AWS and GCP equivalents. Book 3 Chapter 12 describes a Claude-on-Azure landing zone for a composite bank (Bank A); its product settings are dated and marked where this page has not checked them against vendor documentation. Recommendations that are this page’s own synthesis are labelled as such. Regulatory dates and article-level statements live on the regulatory map.

Decide the boundary before provisioning

Start from the workload, not the template. Record, per workload:

  • business purpose, accountable product owner and service operator;
  • data classes, allowed processing locations, retention needs and external parties;
  • criticality, availability and recovery objectives, and whether it supports a critical or important function (route that question through the regulatory map);
  • the identities needed to build, deploy, operate and use it, kept as separate classes (runtime, deployment, agent);
  • approved ingress, egress, service-to-service routes, and model or tool endpoints;
  • environment stages, evidence readers, retention owners and support hours;
  • exit assumptions: what must be exportable, replaceable or independently recoverable.

These are design inputs, not a legal opinion. Residency alone does not settle access, transfer or third-party risk; route those questions to the accountable control owners.

Design the management-group hierarchy

The hierarchy is where policy and role assignments are inherited. Get it wrong and every later control is either duplicated per team or applied to the wrong set of workloads.

Rules that both source books agree on

  1. Never assign at the tenant root. Create one main node directly below the root and assign there and below. A merger, carve-out or tenant split can then be absorbed by re-parenting a branch instead of unpicking policy from the top (Book 2 Ch 10 §6, drawing on the author’s 2024 book; Book 1 Ch 8 §4.5 shows the same “top-level management group” below the root).
  2. Assign high, inherit everywhere. A new subscription, account or project must be compliant the moment it is created because it is born under the rules, not brought into line afterwards.
  3. Keep a separate platform branch. Connectivity, identity and management subscriptions, plus the platform-and-operations segment that holds build agents and estate tooling, belong to the platform team and are themselves governed. The machinery that changes the estate must not be a privileged back door outside the walls (Book 2 Ch 10 §4.5).
  4. Keep the tree shallow. If platform engineers cannot draw the hierarchy on a whiteboard from memory, neither can the agent that reads it. Too much structure is its own form of ungoverned estate (Book 2 Ch 10 §7).

Where the sources differ, and what this page follows

ModelBranching below the main nodeSource
Purpose-first (Microsoft CAF reference)Platform / Landing Zones / Decommissioned / Sandbox; “one management group per intent, not per business unit”Book 1 Ch 8 §4.5; Supporting Tools 02_azure_infrastructure.md §1
Environment-firstNon-production and production first, then domain, plus a platform-and-operations groupBook 2 Ch 10 §6 (composite Asset Manager X)

The Supporting Tools diagram also draws its purpose groups directly under the Tenant Root Group with no intermediate node; that contradicts rule 1 and this page does not follow it.

Book 1 draws the purpose-first shape for a financial institution. Its point is where the compliance baseline attaches: once, on the landing-zone branch, so that every production subscription below it inherits the baseline from the moment it is created.

The purpose-first landing-zone hierarchy from Book 1: Platform, Landing zones, Sandbox and Decommissioned under the tenant root, with the FSI compliance baseline attached on the landing-zone branch and inherited by production.

Purpose-first, as Book 1 draws it. Read it for where the baseline attaches, not for the top of the tree: like the Supporting Tools diagram, it hangs the purpose groups straight off the tenant root. The recommendation below adds a main node and splits landing zones into non-production and production. Source: Building Organizations for the Age of AI (Book 1), Chapter 8.

This page’s recommendation (synthesis): combine the two. Keep CAF’s purpose branches, and split the landing-zone branch into non-production and production so that the production-data deny has exactly one place to live:

Tenant root                (no assignments)
└── <firm> main node        baseline initiative: allowed regions, required tags, diagnostics
    ├── Platform            connectivity · identity · management · platform-and-operations
    ├── Landing zones
    │   ├── Non-production  DENY production data; sandbox-style freedoms per subscription type
    │   └── Production      encryption, diagnostics, private endpoints, no public exposure
    ├── Sandbox             auto-eviction, no production data, no regulated evidence
    └── Decommissioned      retention-only

Geo-aware or entity branches (for example per regulated legal entity) sit below “Landing zones” only where a jurisdictional boundary needs its own policy set; do not create them per business unit.

Production data never enters non-production

This is the single most consequential line in the estate because its violation is reportable (Book 2 Ch 10 §4.3).

  • Prohibit any production data in a non-production subscription: no copy, no masked-but-reversible extract, no one-off to reproduce a defect.
  • Enforce it as a deny assignment on the non-production management group, so a deployment that would cross the line is refused at provisioning, not flagged later. Use the data classification labels (for example Purview on Azure) to identify the sensitive stores the deny protects.
  • Offer the legitimate alternative at the same time: a synthetic or irreversibly masked extract produced through an owned process. In the Book 2 worked example, the composite firm’s coding agent tried to write a production data copy into a development workspace; the plane denied it, the evidence surfaced, and the squad was handed a masked synthetic extract instead.
  • Acceptance check: attempt a production-data copy into a non-production subscription with a deploying identity and with an agent identity. Both are refused, and the denial is queryable as evidence.

Find and fix orphans

A subscription outside the landing-zone branches, created before the hierarchy existed or under a “temporary” arrangement, is where an agent’s infrastructure escapes the rules (Book 1 Ch 8 §8, anti-pattern 4). Export the hierarchy and the initiatives assigned at each level from the platform’s inventory (Azure Resource Graph on Azure) rather than redrawing it, list every subscription not under a governed branch, and migrate or decommission each.

Provider mapping

ConceptAzureAWSGCP
Hierarchy containerManagement groupOrganizational unitFolder (under the organisation node)
Isolation unitSubscriptionAccount (harder default blast-radius wall)Project
Inherited preventive ruleAzure Policy denyService control policyOrganization Policy constraint / IAM deny
Deployable baselineCAF landing zone; Microsoft FSI Landing Zone for financial servicesControl Tower with Landing Zone AcceleratorCloud Foundation Toolkit, Assured Workloads

Provider mappings are from Book 1 Ch 8 and Book 2 Ch 10 (as of May 2026). Book 1 describes the Microsoft FSI Landing Zone as open-source, shipping geo-aware management groups and financial-services policy sets, and expects six to twelve months of institution-specific customisation. [FACT-CHECK: confirm the FSI Landing Zone repository location, its current maintenance status and policy-set inventory, and the current names of AWS and GCP landing-zone products.]

Segment along three axes

Classification states what a workspace is for; segmentation makes it a wall (Book 2 Ch 10 §4.5).

AxisControlFailure if missing
IdentitySeparate runtime, deployment and agent identities; agents have their own identity, never the invoking user’sAn agent inherits a user’s role; a deployment credential is used interactively
NetworkHub-and-spoke or equivalent: spokes reach the internet only via the hub firewall; spokes reach each other only via the hub; deny-by-default egress with allow-listed FQDNsAn agent picks its own route; a poisoned agent reaches an arbitrary endpoint
AccessRBAC at the least-privilege grain, including custom data-plane rolesA broad data-plane role granted “to get it working” becomes the exfiltration path

Manage address space centrally

Overlapping IP ranges cannot be routed or merged cleanly, and the remediation is manual and expensive. From the first subscription:

  1. Publish an allocation policy per environment (non-overlapping ranges per stage and region).
  2. Keep one authoritative record of every assignment with at least: resource, IP, subnet, environment, owner.
  3. Audit regularly and reclaim defunct allocations.
  4. Hand each workspace its segment at provisioning. An agent should never choose an address range; if it has to, segmentation has failed.

For an estate already carrying overlaps, classify the affected workloads honestly (Book 2 uses an “extension” subscription type for lifted on-premises estate) while you unpick them.

Enforce in deny mode, not audit mode

An agent issues a resource deployment in milliseconds. Change advisory, peer review and exception approval run on a human clock. Once an agent holds a deployment-capable credential, the only control that keeps pace is the policy engine evaluating the request (Book 1 Ch 8 §4.6). In audit mode the misconfiguration succeeds and is logged; in deny mode it is refused and the caller receives a structured error it can act on.

Rules:

  • Mandatory guardrails are deny at the management group. Use deployIfNotExists (or the provider equivalent) for gaps that can be remediated automatically, such as missing diagnostic settings. Audit-only is for genuinely informational checks.
  • Treat the landing zone as a product, not a one-time project: a named product owner, a backlog and a quarterly release cadence (Book 1 Ch 8 §8, anti-pattern 3).
  • For every audit-mode initiative, set a hard date for moving to deny, announce it six months in advance, and run a remediation programme against the violations the audit log already shows.
  • Exceptions carry a policy basis, approving owner, scope, expiry and evidence. Review the register and flag every exception older than 90 days (Book 1 Ch 8 §7). An exception must not quietly become the baseline.

Minimal deny set for a small firm (Book 2 Ch 10 §7): one main node below root, a non-production and a production branch, the subscription types actually in use, and four denies that fire: allowed regions, encryption, public exposure, and production-data egress into non-production. A few denies that fire beat hundreds that only report.

Acceptance check: list every policy assignment with its effect. Each mandatory guardrail is deny (or has a dated, communicated transition plan), and a test deployment that violates it is refused.

Choose current provisioning tooling (Azure, dated)

Azure Blueprints is being retired. As of November 2026, Microsoft Learn states the retirement date is 31 January 2027, with a phased wind-down that began 31 July 2026 (no new definitions or versions), continued on 31 October 2026 (no new assignments; definitions frozen), and reaches 31 December 2026 (assignments frozen). At retirement the API stops responding, blueprint locks stop working, and definitions and assignments that were not exported are deleted; resources created by blueprints remain. Book 2 Appendix B records the 31 January 2027 retirement and the 31 July 2026 start of the wind-down (not the intermediate phases), and scores its own 2024 choice of Blueprints as having “died”.

Blueprints jobSuccessor (Microsoft’s recommendation, November 2026)
Store and version the definitionTemplate specs, or templates kept in Git under pull-request review
Assign, deploy as a unit, manage lifecycle, lock resourcesDeployment Stacks, using deny settings for locking
Authoring languageBicep (Book 2 Appendix B: Bicep became the Azure IaC default, with recipes publishing Bicep modules as template specs or driving them through deployment stacks; Book 2 Ch 16 §4.10 also allows the firm’s Terraform modules)

Actions now: inventory blueprint definitions and assignments (including those saved at management groups but unassigned), export what you need before 31 January 2027, and re-express each as Bicep stored as a template spec or in Git, deployed through a deployment stack. Write landing-zone recipes so the provisioning mechanism is a named, replaceable component; a recipe that still names Blueprints names a dead product.

Close the citizen-development default. On Microsoft estates, Power Platform and Copilot Studio are where many business-built prototypes appear. Book 2 Ch 21 §4.5 (citing Microsoft Learn, November 2026) reports one default environment per tenant that every licensed user can build in and that cannot be deleted; managed-environment controls and data policies for it are opt-in. Its advice is to close or restrict the default environment early. [FACT-CHECK: confirm current Power Platform default-environment behaviour and the “Secure the default environment” guidance on Microsoft Learn.] Pair the restriction with a cheap governed prototype tier (sandboxed, time-limited, no production data, automatic eviction) so promotion is cheaper than evasion; on AWS the equivalent is a sandbox OU vended through Control Tower with SCPs denying production-data paths, on GCP a folder-and-project factory with organisation policy constraints.

Build in dependency order

  1. Classify. Approved values for purpose, lifecycle stage, data sensitivity, owner and criticality, required at provisioning and machine-readable (a tag or placement policy evaluates, not a wiki). Unknown or contradictory values stop high-impact provisioning with an actionable exception.
  2. Partition. Place the subscription, account or project in the hierarchy above; make non-production data and production routes explicit; keep shared platform services in owned boundaries with a consumer contract.
  3. Establish identity. Separate human, workload, agent and deployment identities. Bind each to an owner, purpose, scope, expiry or review point, and revocation path. No identity holds runtime and deployment authority on the same scope; deployment identities are bound to the pipeline runner and federated (OIDC), not exported to workstations; machine identities sit inside privileged-access management (Book 1 Ch 8 §5, §8). Detail: identity and secrets.
  4. Constrain network and service access. Permitted ingress and egress, DNS, private endpoints, data stores, model gateways and administrative routes. Deny unneeded paths at the enforcement point and test alternate endpoints. A repository rule or a prompt is not a network control.
  5. Apply policy in deny mode as above, separating preventive checks from detection and remediation.
  6. Provision evidence and operations. Every subscription is vended with diagnostics forwarded to the central log workspace and SIEM and with security posture monitoring on. Configure deployment records, policy decisions, access events, alert routing, backup and recovery before workloads arrive. Raw telemetry is not durable action evidence; see audit evidence.
  7. Pave the delivery path. A versioned pipeline that builds from reviewed source, scans, tests, records artefact identity, checks policy, requests approvals, deploys to the intended stage and verifies health. Production credentials are unavailable to untrusted build steps; agentic and privileged pipeline stages are split (see release engineering).
  8. Assign operations. Name the platform owner, product owner, service operator, security contact and evidence owner; publish the support route, incident escalation and recovery procedure with the workspace.

Give humans and agents the same paved workspace

The factory provisions an agent’s workspace through the same path, with the same contents, as a human developer’s (Book 2 Ch 16 §4.3, §5). There is no separate, looser regime for agents.

Workspace elementHuman developerCoding agent
RepositoryBranch policies, protected branchesThe same branch policies; its pull requests pass the same gates
ToolchainPinned to approved versionsLocked, per-domain stack, changed only through the recipe-upgrade path
Standing contextArchitecture and convention docsMachine-readable context files committed to the repo (for coding agents, CLAUDE.md or AGENTS.md)
Environment accessThrough identity, never shared secretsIts own distinct, claimable identity scoped to the workspace’s segment
Policy checksScans and gates on every pushThe same scans and gates on its output
EvidenceA place to write evidenceOutput arrives pre-attributed: which agent, on whose behalf, under which wrangler

Three claims to test against your factory (Book 2 Ch 16 §5):

  1. One boundary. Scripts, people and agents work inside the same recipe and workspace constraints. The commonest design error is a disciplined factory for scripts with agents running beside it on laptops, with free tool choice.
  2. Provisioning precedes generation. Controls and evidence bindings exist before the first artefact.
  3. The human gate is on output, not effort. Wranglers review what merges and deploys; the bounded workspace shrinks what review has to cover.

Where agents run. Agents execute in isolated, purpose-built runtimes decoupled from corporate endpoints: provisioned per workspace, with exactly the egress, scoped credentials and tools the recipe allows, and off the corporate LAN by default. Never on a person’s laptop with that person’s credentials (Book 2 Ch 16 §4.9; ADD Strategic Brief §4a.4). The ADD proposal’s example locks one stack per department, for instance a solution-development stack and a separate service-management stack (shell, scripting, cloud CLI and Terraform), with shared utilities across both; treat the specific tools as an example, not a standard. Provider primitives differ in blast-radius guarantees (Azure Container Apps or VMs; AWS ECS/Fargate in an egress-controlled VPC or account-per-workload; GCP Cloud Run or GKE in a dedicated project), so write the recipe’s runtime module against the primitive and have security read it at provider level. The wider reference architecture for agent execution is on the enterprise control plane page; the developer-in-the-loop baseline is on coding-agent workstation.

Decide whether a landing zone may host an agent

Three hard preconditions

Before any other question, an account or subscription that will host an agent must pass all three (Book 1 Ch 8 §5). If any fails, it is not a landing zone in any meaningful sense.

  1. It sits inside a management hierarchy with policy inheritance enabled.
  2. Public IPs are denied by policy at the hierarchy above it, in deny mode.
  3. Egress is deny-by-default, with allow-listed FQDNs at the platform firewall.

The rest of the checklist

Book 1 describes a ten-question binary checklist assembled from its §4–§5 but names only the three preconditions. The seven questions below are this page’s proposal drawn from the same sections; adapt them, but keep them binary.

  1. Does the subscription belong to exactly one identity tenant, with conditional access scoped to agent identities?
  2. Is diagnostic data forwarded to the central log workspace, SIEM and posture service from creation?
  3. Does the agent have its own identity (not the invoking user’s), with a named owner (wrangler)?
  4. Is no identity on this scope able to both run and deploy?
  5. Are all machine identities on this scope inside privileged-access management?
  6. Is production data denied if the subscription is non-production?
  7. Are all exceptions on this scope inside their expiry, and none older than 90 days without review?

The agent-readiness one-pager

One row per landing zone hosting, or scheduled to host, an agent: ten columns for the checklist answers, plus a column for the agent’s wrangler and one for its intended zone (development, diagnostic, remediation, privileged-incident; see agent lifecycle). Update it monthly and take it to the AI steering committee. The question it changes is from “is the agent safe?” to “is the place it will run actually a landing zone?” (Book 1 Ch 8 §7).

Sequence delivery domains by exposure

Before widening agents in a delivery domain, ask three questions and treat a vague answer as the finding (Book 2 Ch 2 §7):

  1. How many application patterns does the domain actively support? “We don’t know” means industrialisation has not started.
  2. How long from an approved idea to repository, pipeline, environment, identity, logging and a first deployable skeleton? Weeks means the paved road is immature.
  3. What evidence does a standard deployment produce without manual effort? Screenshots or checklists mean the domain is not audit-ready.

Finish the road first where agents are widening fastest and where a critical or important function is touched. The scoring method is on agent readiness.

Integrate the eight agent-platform components

Book 3 Ch 12 treats the Claude landing zone as one integrated system of eight components. Without the integration points they are eight features, not a control plane. The table generalises the components; the Claude/Azure specifics in the right-hand column are Bank A’s composite implementation as of August 2026.

#ComponentIntegration point to the restProof artefactBook 3 example (Claude on Azure, Aug 2026)
1Deployment routeEvery route’s authentication resolves to one identity sourceRoute decision per use-case class, co-signed by procurement and second line; monthly billing reconciles to gateway recordsFoundry, direct API behind APIM, Bedrock eu-central-1; M365 Copilot surface tracked separately
2Identity and accessHuman, workload and agent principals reach the gateway validated; one principal-context block in the audit recordJWT validated at gateway inbound; no personal-account fallbackEntra ID, managed identity, Entra Agent ID
3Model gatewayGenerates the correlation ID; feeds the SIEM in the audit-schema shapeX-Correlation-ID propagated to every downstream callAzure API Management
4MCP / connector brokerOne registry, three enforcement points: workstation, agent envelope’s Means, gateway name validationUnregistered server names rejected at all threeallowManagedMcpServersOnly: true on workstations
5Workstation and endpoint estateBase-URL redirect forces client traffic through the gateway; allow-list reads the broker registry; hooks emit with the correlation IDDirect calls to the provider API blocked at network policy; MDM complianceANTHROPIC_BASE_URL → APIM; managed settings.json via Intune/GPO/Jamf
6Embedded agentsEnvelope’s Means lists identity first and only broker-registered tools; Memory and Means reference data-dictionary IDsRegistered envelope per production agentAgent SDK agents in four zones
7Data classification, retention, DLPClassification governs Means and Memory; tokenisation at the gateway keyed on correlation ID; zero-retention contracted at route levelWeekly registry × dictionary reconciliationPurview classifier; ZDR where contracted
8EvidenceEvery component emits to the same correlation ID; the evidence record is the joinImmutable storage, retention by tier, replay procedureAudit Evidence Schema v0.1.0 to Sentinel and immutable storage

Book 3’s integration checklist (PR-1) runs to 31 rows in six blocks. Its distinctive rows, worth copying into your own checklist: billing-to-gateway reconciliation per route; correlation ID propagated to every downstream call; MCP-name validation at the gateway reading the broker registry; the managed baseline reaching every client (desktop and collaboration clients as well as the CLI) with one policy intent and one version stamp; local conversation history named in the records-retention schedule with a DPO-signed endpoint retention policy; envelope fields referencing dictionary entries by ID rather than free text; and one version-controlled architecture diagram in the sign-off pack. Detailed component guidance: model gateway, MCP and connector broker, data classes and lanes, coding-agent workstation.

[FACT-CHECK: Book 3 states (August 2026) that desktop clients store conversation history locally on the device; confirm against current Anthropic desktop admin documentation whether history can be directed to a firm-controlled store.]

Close the perimeter

A landing zone governs the routes you provisioned. The model also arrives on routes nobody provisioned. Draw them on the architecture diagram, outside the perimeter, each with an arrow to the control that catches it.

Ungoverned arrival vectors (Book 3 Ch 12 §4.9, as of August 2026)

SurfaceHow it arrivesControl and owner
Claude models inside Microsoft 365 CopilotAn administrator toggle in the M365 admin centre; Book 3 reports these models are hosted outside Microsoft-managed environments under Anthropic’s terms, not the Microsoft DPATreat the toggle as a governed change: named approver, third-party register entry, transfer assessment
Apps using a raw provider API key (Book 3 cites Apple’s Foundation Models framework), including on BYODA key pasted into an app on any deviceMDM and BYOD DLP tuned to the provider key format; workspace-scoped key issuance with per-holder attribution so an unattributed key is anomalous
Consumer plans on web and mobileA personal subscription in a browser or phoneEgress policy distinguishing sanctioned endpoints from consumer sign-in, plus SSO enforcement so a corporate identity cannot land on a consumer plan

[FACT-CHECK: confirm current hosting and contractual terms for Anthropic models in Microsoft 365 Copilot, and current consumer-plan availability, against Microsoft and Anthropic documentation.]

The sweep test (part of exit criterion 1): the M365 setting matches its change record; DLP reports zero provider API keys outside the issuance process; egress logs show no corporate identity on a consumer plan.

Egress profile for sanctioned clients

Book 3 (citing Anthropic’s enterprise network configuration page, accessed August 2026) lists the hosts a Claude Code client contacts by purpose, and notes that WebFetch’s domain safety check and version checks still reach Anthropic whichever cloud route is used. A closed-perimeter profile sets CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1, skipWebFetchPreflight: true and DISABLE_UPDATES in the managed baseline. Disabling updates switches off the security-fix channel, so you then owe an internal binary distribution channel; record that trade in the resilience register. Put proxy, custom-CA and mTLS settings in the managed env block, not a shell profile. processWrapper forces launched processes through a corporate launcher on macOS, Linux and WSL but is ignored on Windows; on Windows estates use AppLocker or WDAC plus HKLM-delivered managed settings and record the residual as an accepted risk. [FACT-CHECK: confirm host list, setting names and Windows behaviour at code.claude.com/docs/en/network-config and the managed-settings documentation.]

Prove it is done: the seven exit criteria

Each criterion is a present-tense observation tested in the prior 30 days (criterion 2 looks back 90 days), not a promise. Aspirations belong on the roadmap. Use one row per criterion in the attestation template: criterion, observable signal, data source, date of last test, result (Pass / Fail / Pass with exception), signatory.

#CriterionObservable signal and testData sourceAnti-pattern it catches
1Every model interaction flows through the gatewayGateway record count reconciles to every provider invoice within an agreed tolerance; unmatched events resolved before sign-off; perimeter sweep cleanGateway logs in SIEM; provider invoices per route; M365 change record; DLP and egress reportsA team calling the provider API directly without the base-URL redirect
2Every MCP call is allow-listedDistinct MCP server identifiers seen by gateway, workstation hooks and agent runtimes in the prior 90 days all map to registered servers; zero unregistered namesBroker registry; SIEM query across the three sourcesA workstation running an unregistered local stdio server
3Every endpoint runs the managed baseline100% deployment of the current managed-config version on every device class running a client, cross-checked against licensed and engineering groups; closed-perimeter and transcript-retention settings present in the deployed versionMDM compliance reports per channel (Intune, GPO, Jamf)Baseline covers the CLI but not the desktop client
4Every embedded agent has a registered envelopeRegistry enumeration equals the distinct agent IDs (X-Agent-ID in Book 3) seen in the prior 30 days; envelope-less calls rejected with a documented errorAgent registry; gateway rejection logsEnvelope kept on a wiki the gateway cannot read
5Every material action has audit evidenceQuarterly replay passes: a random correlation ID is reconstructed within target time with all nine questions answered, with a named second-line witnessReplay report (see audit evidence)Correlation ID dropped at the broker hand-off
6The data dictionary governs what each agent seesClassification × envelope cross-check shows no mismatch in the prior quarter; weekly automated reconciliation, drift escalated to the wranglerRegistry and dictionary reconciliationA dictionary that exists but is not enforced
7The second line has signed the designSigned pack on file with named signatories and named exceptions carrying owners and datesThe sign-off packSign-off given to meet a deadline

A mismatch in criterion 4 means either a new agent missed registration or a deprecated agent is still calling; both are findings.

Get the second-line design sign-off

Sign-off turns the landing zone from an engineering artefact into a governed institutional asset. It is performed once, then repeated every twelve months and on every material change (Book 3 Ch 12 §3, §6.1, PR-2).

The pack is one version-controlled document in the policy repository: page one the single-page reference architecture (with ungoverned surfaces drawn outside the perimeter); one page per exit criterion stating criterion, signal and last test result; then one appendix per criterion holding the test artefact (for example the MDM compliance report by cohort; the replay report with correlation ID, reconstruction, elapsed time and witness signature). Circulate it before the meeting. The pre-go-live suspension rehearsal report is filed in the pack; the runbook and targets are on agent lifecycle. Sign-off depends on the rehearsal producing artefacts, not on zero gaps.

Signatories (Book 3’s composite Bank A): Head of Model Risk, CISO, the Data Office signatory, and the DPO, with the CRO countersigning. Internal audit is copied, not a signatory: the second line signs design effectiveness; the third line later tests operating effectiveness. Keep that split visible to supervisors.

Named exceptions each carry a remediation owner, a date and a review cadence. Bank A’s four (composite): a hosting-route residency gap with a named alternative route and a migration trigger; a contractor laptop cohort with a remediation date inside the next quarter; a provisional replay target (four hours for lower tiers, one hour for Tier 3 and above, pending six months of data); and the Windows launcher gap with compensating controls accepted in writing by the CISO. Blanket approvals do not survive a supervisor’s follow-up.

Validity: twelve months from the latest signature, unless a material change occurs first: a new deployment route; a new use-case class entering Tier 3 or above (see risk tiers); a major model upgrade; an incident that triggers supervisory notification; or a change to the Audit Evidence Schema. Route material changes through change governance.

Rules: the date on the signature is the date the criteria were tested; if they cannot be met by an announced go-live date, the date moves. Do not sign the Build complete until named wranglers, the agent control board and the first product team exist; a control plane nobody runs is not done.

Own the tenant-level control plane

Fragmented ownership of tenant roles shows up as inconsistent role assignments across management groups, recurring audit observations on privileged-access reviews, and changes stalled because no approver is identified (ADD Cloud Governance decision paper §1). The paper recommends, and this page adopts:

  • One accountable owner (the head of cloud or equivalent) for the tenant-level control plane: role definitions and assignments (built-in and custom), identity-provider governance, the management-group hierarchy and policy baselines, network, logging and security-configuration baselines, privileged-access patterns (group-based RBAC, eligible versus permanent, PIM, break-glass), and evidence of control operation.
  • End-user access governance (joiner–mover–leaver, requests, approvals, recertification) stays in the firm’s identity-governance system of record. The two are complementary: one owns the control plane, the other owns the access workflow and its evidence.
  • A lightweight role-governance control: an authoritative role catalogue (owner, purpose, allowed scopes, last review date); a quarterly baseline review with ad-hoc review of new or changed roles, run incrementally (for example one role a week); recorded outcomes (confirmed assignments, removals, exceptions with justification and approval).
  • Multi-cloud: one accountable owner per provider, under a single policy model, so parallel inconsistent control models do not emerge. Exceptions go through documented risk acceptance.
  • Record the decision in the RACI (see accountability) and route control-plane changes as platform guardrail changes in change governance.

Acceptance checks

Before a product or agent enters the zone, demonstrate with a representative deployment:

  • The hierarchy has no assignments at the tenant root; every subscription sits under a governed branch; the orphan list is empty or each orphan has an owner and date.
  • Mandatory guardrails are in deny mode; a violating deployment is refused with a structured error.
  • A production-data copy into non-production is refused for human, pipeline and agent identities, and the denial is queryable.
  • Required classification, owner, region and stage are present and machine-readable; invalid values fail closed where impact warrants.
  • Production and non-production identities, data and routes are isolated under attempted cross-boundary access. A build identity can perform only its documented deployment actions; a runtime identity cannot provision infrastructure.
  • An unapproved egress destination and an unregistered workload or agent are denied through an owned, tested control path.
  • An agent workspace and a human workspace provisioned from the same recipe are identical except for the identity.
  • Policy decisions, approvals, identity, artefact digest, target environment and deployment outcome correlate into one evidence record.
  • A failed health check blocks promotion or invokes the selected recovery path; recovery is verified and recorded.
  • For an agent platform: the seven exit criteria pass in the prior 30-day window and the sign-off pack is current.
  • The team can restore or disable the workload and explain how it would exit the platform dependencies it has accepted.

The Deployer Manifest v0.1.0 describes a gated artefact-to-target workflow (artefact, target, backend, preflight, apply, verify and rollback sections; one artefact per manifest). Its validity rules belong to release engineering. Schema presence does not prove a backend is safe or a deployment authorised.

Brownfield, theatre and failure handling

Map inherited versus improvised. Pick one product’s path from idea to production and list every cloud control it touches: subscription, 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, in priority order (Book 2 Ch 10 §7).

Two line-readiness tests before the agent lane: (1) is the classification a resource property that policy evaluates, or only a naming convention and a wiki page? (2) would a deny or deployIfNotExists-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.

Landing-zone theatre. A beautiful reference architecture with low adoption means teams provision around it, and agents will follow the teams. Measure the lead time from request to a governed workspace and drive it below the time it takes to provision around the zone (Book 2 Ch 10 §8).

Brownfield migration. Do not relabel an inherited environment as governed. Classify it honestly, record compensating controls and an owner, and migrate by priority, critical or important functions first. Agents run only on the governed portion until the missing controls are closed. For an overlapping network or unknown identity, isolate first, preserve evidence and route remediation to the platform owner; never widen a shared route to fix it.

Failure handling. If a deployment partially succeeds, stop promotion, capture the manifest and actual state, and run the agreed verify or rollback procedure. If identity or egress control fails, revoke or suspend the affected credential and route, preserve the event trail and restore from a known state. Recovery authority must be separate from the identity whose failure triggered recovery. Orphaned long-lived secrets with no owner: rotate them to a value nobody holds and let whatever breaks declare its dependency (Book 1 Ch 8 §8).

Provenance and review state

  • The hierarchy recommendation combining purpose-first and environment-first branching is this page’s synthesis; the sources differ as stated above.
  • The seven checklist questions beyond Book 1’s three preconditions are this page’s proposal.
  • Bank A and Asset Manager X are composites. Book 3’s Claude/Azure settings and surfaces are dated August 2026 and marked for checking.
  • The Azure Blueprints timeline and successors were checked against Microsoft Learn (“Azure Blueprints retirement”, page dated 30 October 2026) on 14 November 2026.
  • The ADD proposal’s accountability recommendation is generalised here; firm-specific names and internal standards are omitted.
  • The Supporting Tools Azure reference for the audit spine (centre and per-entity edge subscriptions under the landing-zones group, shared services in platform subscriptions) is consistent with this layout, apart from its root placement noted above.

This page remains a draft.

Source material

  • Book 1 (Building Organizations for the Age of AI), Chapter 8, Identity and Network: The First Two Control Planes (§4.5 landing-zone hierarchy, §4.6 machine clock, §5 checklist preconditions, §7 agent-readiness one-pager, §8 anti-patterns)
  • Book 2 (The AI Delivery Factory), Chapter 2, Software Delivery Was Already Industrialising (§7 three questions per delivery domain)
  • Book 2, Chapter 10, Cloud as the Production Line (§4.3 production-data line, §4.5 segmentation and address space, §4.9 brownfield, §6 management-group hierarchy, §7 line-readiness tests, §8 landing-zone theatre)
  • Book 2, Chapter 16, The Automation Factory (§4.3 same paved road for human and agent, §4.9 agent execution architecture, §5 three claims)
  • Book 2, Chapter 21, Product Development at Agent Speed (§4.5 prototype tier and the Power Platform default environment)
  • Book 2, Appendix B, Technology Choices Revisited (entries 'Azure Blueprints' and 'Bicep over ARM')
  • Book 3 (Deploying Claude Safely), Chapter 12, The Landing Zone Tied Together (§3–§7, PR-1 integration checklist, PR-2 exit-criterion attestation template)
  • ADD proposal, Cloud Governance Accountability decision paper (§3 position, §4.2 role-governance control, §6 multi-cloud consistency)
  • ADD proposal, Strategic Brief, §4a.4 Trusted Agent Execution Architecture
  • Supporting Tools, docs/architecture/02_azure_infrastructure.md (CAF landing-zone shape for the audit spine)
  • Supporting Tools, Deployer Manifest v0.1.0 and spec/conformance/

← All AI Delivery Factory guidance

On this page

  1. Decide the boundary before provisioning
  2. Design the management-group hierarchy
    1. Rules that both source books agree on
    2. Where the sources differ, and what this page follows
    3. Production data never enters non-production
    4. Find and fix orphans
    5. Provider mapping
  3. Segment along three axes
    1. Manage address space centrally
  4. Enforce in deny mode, not audit mode
  5. Choose current provisioning tooling (Azure, dated)
  6. Build in dependency order
  7. Give humans and agents the same paved workspace
  8. Decide whether a landing zone may host an agent
    1. Three hard preconditions
    2. The rest of the checklist
    3. The agent-readiness one-pager
    4. Sequence delivery domains by exposure
  9. Integrate the eight agent-platform components
  10. Close the perimeter
    1. Ungoverned arrival vectors (Book 3 Ch 12 §4.9, as of August 2026)
    2. Egress profile for sanctioned clients
  11. Prove it is done: the seven exit criteria
  12. Get the second-line design sign-off
  13. Own the tenant-level control plane
  14. Acceptance checks
  15. Brownfield, theatre and failure handling
  16. Provenance and review state

All pages in Build the platform →