Browse the reference ⌄
Implementation Guide published

Identity, Secrets and Configuration for Agent Workloads

Give every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
29 min

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

Sources and details
Source works
Book 1 · Book 2 · Book 3 · Book 09 · Research Series · Supporting Tools · ADD proposal
Source chapters
5, 6, 8, 9, 11
Source appendices
04:A, 04:B
Tool specifications
audit_evidence_schema@0.1.0
Refresh trigger
vendor release

Full source list ↓ Source index →

Identity is the enforceable link between an action and an accountable actor. A label in a prompt, a shared API key or a developer’s cached session is not that link. This page sets out how to give every actor one owned identity, how to size and separate its authority, how to keep durable secrets away from anything that can be compromised, how to treat configuration as change, and how to audit the estate until the gaps close.

Book 1 Ch 8 frames identity and network as one control surface: identity binds who, network binds where, and both are exercised, observed and evidenced at runtime. If either is negotiable, the other’s discipline does not hold. The network half is on Landing zone; this page is the identity half, with the joins made explicit.

Decisions this page supports

DecisionOwnerSection
Which identity classes the estate recognises and who owns eachHead of IAMIdentity classes
How much authority an agent may holdWrangler with platformWorst-case authority
Whose authority an action carriesWrangler, per actionDelegated or own
How pipelines change environmentsPlatform, pipeline ownersDeployment identities
How workloads authenticate to model providersPlatform, CISOFederation and sunset
Which configuration needs which reviewProduct owner with control ownersConfiguration classes
Where to start remediationCIO, Head of IAMGrade the spine

Name the identity classes

The sources slice the same estate differently. Read them as layers, not competing models:

  • Book 2 Ch 11 and Book 3 Ch 5 use three first-class rows: human, workload and agent. Book 2 adds delivery identities (pipeline, signing, deployment, release-time secret reader) as workload identities that “hold the keys to production”.
  • Book 1 Ch 8 §3 uses three classes for rule design: runtime, deployment and agent.
  • Book 1 Ch 8 §4.1 gives the IAM team a five-row inventory, used below.
Three identity classes — runtime, deployment and agent — resting on one identity governance fabric.

Three identity classes, runtime, deployment and agent, on one identity governance fabric. Source: Building Organizations for the Age of AI (Book 1).

Identity kindWhat it identifiesLifecycleOWASP agentic risk anchor
HumanA named individualHR-bound: onboard, change role, leaveASI09 Human-Agent Trust Exploitation
WorkloadA long-running service or daemonDeployment-bound; rotation cadenceASI03 Identity and Privilege Abuse
DeploymentA CI/CD pipeline writing to productionPipeline-bound; ephemeralASI03 Identity and Privilege Abuse
AgentAn AI agent acting under delegated authorityWrangler-bound; envelope-scopedASI03 Identity and Privilege Abuse
Vendor-agentAn external AI agent invoking the firm’s APIsContractual; allow-listedASI04 Agentic Supply Chain Vulnerabilities

Owners of record per class are named in the flagging exercise (question 4).

The vendor-agent row is the one most estates miss; its risk anchor is supply chain, not internal privilege abuse (Book 1 Ch 8 §4.1). Recommended handling (this page’s synthesis, not a source procedure): treat an inbound external agent as a distinct principal: allow-list it by contract, issue it its own client identity at your API or broker (never a shared partner key), scope it to the contracted operations, log it as principal_type agent with the supplier recorded, and include it in the access review.

For a single workload, keep four accountable principals distinct in the evidence record: the initiator (person, schedule or upstream agent requesting the work), the agent identity (registered behaviour and version), the workload identity (the runtime principal calling the API, tool, model route or store) and the deployment identity (the pipeline or operator that changed the environment). Each non-human identity resolves to exactly one human owner; for agents that is the wrangler, recorded as executing_agent.agent_id_claim on every emission (see Audit evidence).

Size authority for the worst case, not the expected case

An agent chooses its action at runtime: which repository, which file, which API. A role granted at deployment must therefore be narrow enough that the worst choice the agent can make is still recoverable (Book 1 Ch 8 §1–3). Worst-case authority, not expected authority, is the design unit.

Procedure for each agent before it is granted anything:

  1. List every path the agent can be invoked through (IDE, CI pipeline, scheduler, chat surface, another agent). Composite example (Book 1 Ch 8 §1, Bank A): a coding agent ran under the developer’s session from the IDE and under the pipeline’s service principal from CI. The developer’s session could write to three repositories wired to production deployment; the pipeline principal could not. The blast radius depended on who clicked the button.
  2. Make the authority invoker-independent. The agent runs under its own identity on every path, so its reach does not change with the caller. Where it must act for a person, use delegation with intersection semantics (next section), not the person’s session.
  3. Enumerate the worst reachable action for each grant (delete, deploy, exfiltrate, approve) and ask whether it is recoverable inside the agent’s zone. If not, remove the grant or move the action behind JIT elevation or an approval.
  4. Bind the network to the same scope. Even one repository and one role leak if egress on a shared subscription can reach a production deployment endpoint by URL. Deny-by-default egress with allow-listed destinations is part of the identity design.
  5. Record the result on the agent’s registry entry with its zone (see Agent lifecycle).

Acceptance check: re-run step 3 from each invocation path and get the same answer.

Decide whose authority each action carries

Giving the agent an identity settles who acted. It does not settle whose authority the action carried. Choose per action, not per agent (Book 2 Ch 11 §4).

Delegated authority is the intersection of what the person may do and what the agent's mandate allows, never the union.

Delegated authority is the intersection of the person’s rights and the agent’s mandate. Source: The AI Delivery Factory, Chapter 11, Figure 11.1.

ModeUse whenRules
On-behalf-of (delegated)Access depends on who is asking (an assistant drafting for one relationship manager)Exchange the user’s token at every hop for a downstream token carrying both parties; the resource decides on the person’s rights. Effective rights are the intersection of the person’s entitlements and the agent’s mandate, never the union. Needs a person present.
Dedicated agent identityNo user in the loop (overnight reconciliation, coding agent in a pipeline)The agent’s own least-privilege grants, answerable through its wrangler. Carries a lifecycle that drifts unless change control holds it.

The separating question: whose entitlement should bound this action? A person’s → delegate; a mandate’s → dedicate. Most agents need both inside one task (retrieve on behalf of the user, write under its own identity). The record always names the agent in executing_agent.agent_id_claim, with the person it acted for recorded beside it, never in its place.

Refuse impersonation by name

An agent running as the person who launched it, on that person’s credentials, is neither pattern. It is impersonation: the log cannot separate what the engineer did from what the agent did, and the agent can reach everything the person can (Book 2 Ch 11 §4; Book 09 Ch 5).

  • Interactive sessions default to the agent’s own identity. A pipeline run with no one at the keyboard obviously acts as the agent; Book 09 Ch 6 extends the rule to the engineer at a terminal running agent threads, because otherwise the log says the engineer changed forty files and cannot say whether they did. The source treats this as a harness and policy choice available on every platform; the directory only decides how much of the identity lifecycle the firm builds itself.
  • No approval rights for agents. The agent that produced a change has no route to approve it. Composite example (Book 09 Ch 5): an engineer’s agent running on his credentials could have opened and approved changes in two repositories where he was a named reviewer; the history would have shown one careful engineer doing both. Its registration gave it branch-only write, no main-line write, no approval rights, no client data, and a removal date only its owner could extend.
  • The wrangler approves; the agent acts. The wrangler signs the envelope and approves changes to it but never acts inside the agent’s identity (Book 3 Ch 5 §4.3).
  • Detection. An audit pattern where every agent action shares a principal with a human, or where the agent’s permissions exactly match a user’s, is this anti-pattern (Book 1 Ch 8 §8, anti-pattern 2). Recover by issuing a distinct agent principal with its own access packages and conditional access, and reviewing its tool list against what it needs.

Separate deployment identities by environment

A deployment identity creates or changes environments: provisioning, infrastructure deployment, image pushes, gateway configuration, DNS, platform secret rotation. Book 1 Ch 8 §4.3 gives the rule and reference design.

Rule: the identity that can deploy to development must not automatically deploy to production, and no identity carries both runtime and deployment authority on the same scope. The latter is enforced platform-side, not by convention.

Reference design:

ElementRequirement
PrincipalsOne per environment: dev, test, QA, pre-prod, prod. Each its own principal in its own subscription or account.
Runner bindingConditional access (or the cloud equivalent) accepts each identity only when presented from the pipeline runner that owns it.
Production elevationPIM (or equivalent JIT) elevation, a named approver, and the change-ticket reference in the elevation justification.
CredentialsFederated via OIDC; no static keys; rotation per environment cadence where anything remains to rotate.
Separate signing and publish identitiesThe identity that merges to a release branch, the one that signs the artefact and the one that publishes it are distinct, each with its own approval and evidence.
Namingdeploy-<pipeline>-<env>, environment never collapsed.

Default risk model: assume the dev deployment identity accumulates production permissions (“just for the rollout”), persists as a cached credential on a workstation, and is exercised interactively. Detection signals: an interactive session under a service principal, or a pipeline-named identity acting outside a pipeline run. The inverse (an SRE using a runtime identity to change topology outside the pipeline) shows up as drift between infrastructure-as-code and the deployed state attributed to a human. Recover by binding every deployment identity to its runner, rotating any deployment credential ever exported to a workstation, replacing static credentials with OIDC federation, and enforcing platform policy (Azure Policy, AWS SCPs, GCP organisation policy) that blocks topology changes outside named deployment identities. Public case: Book 1 Ch 8 §6 traces the July 2025 Amazon Q extension incident through four gates this design would have provided; supply-chain gates are on Release engineering.

Federate workloads and sunset static keys

The rule for any non-human actor that can be compromised: reference, never hold. Humans authenticate; workloads federate; agents receive workspace-scoped, just-in-time, short-TTL credentials minted for the task (Book 2 Ch 11 §5). The mechanism is an identity-federation exchange: the workload presents its platform identity and receives a token for one resource, valid for minutes.

Workload identity without a key: a signed OIDC token is exchanged for a short-lived, scoped access token instead of a static API key.

Workload identity federation: a signed platform token is exchanged for a short-lived, scoped access token. Source: Deploying Claude Safely (Book 3), Chapter 5, Figure 5.1.

Per-route mechanics

As of August 2026, per Book 3 Ch 5 §4.2 and PR-1. [FACT-CHECK: each row against current provider documentation.]

RouteWorkload identityNotes
Microsoft FoundryManaged identity on the Azure workload, DefaultAzureCredential, Cognitive Services User role on the resourceNo key material; assign the identity in infrastructure-as-code, named in the deployment manifest. Research Paper 3 §4.1 notes the route also accepts an API key: do not issue one.
Anthropic API (preferred)Workload Identity Federation (announced 17 June 2026): a federation rule binds an external OIDC identity (Azure managed identity, AWS IAM role, GCP service account, Kubernetes service account, GitHub Actions, Okta, other OIDC issuers) to a Claude service account; the platform issues a short-lived scoped tokenOne service account per use-case class; issuers, service accounts and rules configured via the Admin API and held as code under change management, reconciled against the approved register. Export each exchange and the matching Entra issuance event to the SIEM. Book 3 records that token lifetime, scope catalogue, plan eligibility and exchange-endpoint residency were unpublished. [FACT-CHECK: WIF token lifetime, scope catalogue and endpoint residency.]
Anthropic API (legacy key)One service principal and one workspace key per use-case classVault paths such as claude/<usecase>/api-key/current and .../previous; rotate at 90 days with a one-week overlap; on the sunset register. Never a team-shared key.
Amazon BedrockIAM role with bedrock:InvokeModel on the model ARN via the credential chain (instance, task, pod, function role)PrivateLink for private workloads; CloudTrail to the log archive. Research Paper 3 §4.3 lists the actions Claude Code needs on Bedrock.
Google Cloud (Agent Platform)Service account via ADC or Workload Identity FederationCloud Audit Logs to the archive.

Sunset static keys on a date you set

Book 3 Ch 5 §4.2: API keys keep working alongside federation and the vendor has published no deprecation date. Coexistence without a sunset is how estates carry both mechanisms for years.

  1. Inventory every console key against a named individual owner and an IAM register entry.
  2. Publish an institutional sunset date in the ICT change register. Composite example (Book 3 Ch 5 §6, Asset Manager X): the two static keys inherited from the pilot were inventoried, given named owners and a sunset date recorded in the ICT change register, while three federated service accounts replaced them.
  3. Migrate each service to a federation rule bound to its platform identity; configure the rules as code.
  4. Treat survivors past the date as registered exceptions with an owner and an expiry.
  5. Track the count: a federation programme with no key count trending to zero is the anti-pattern.

The same register carries vendor-only keys held by the model gateway.

Never fall back silently to another identity

If a federated or managed-identity token cannot be obtained, the call fails with an audit record. It does not retry with a configured API key someone forgot to delete. The fallback path is the breach (Book 3 Ch 5 §4.2).

  • Design: remove fallback credentials from the runtime entirely; where a second mechanism must exist during migration, it requires an explicit re-authentication event and an alert, never an automatic retry.
  • Fail closed: identity errors surface as errors, not as latency.
  • Detection rule: alert when the principal changes inside a single correlation ID without an explicit re-authentication event. A second signal is sessions in cloud billing that do not appear in the vendor organisation (a developer exported a provider variable).
  • Test: revoke the primary credential mid-session in pre-production and confirm a denial event with the correlation ID, not a successful call under another principal.

Composite failure (Book 3 Ch 5 §7): a service principal’s token expired mid-conversation, the loop retried on a configured key, the audit trail recorded the call under a different principal, and the wrangler read it as a latency blip.

Credential precedence is a bypass surface

Where a client can authenticate several ways, the precedence order decides which identity, billing account and policy channel governs the session. One exported variable can move a session to a different identity.

Claude Code, as of August 2026 (Book 3 Ch 5 §4.2): a signed-in gateway session outranks everything; then cloud-provider variables (CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX, CLAUDE_CODE_USE_FOUNDRY) → ANTHROPIC_AUTH_TOKEN → ANTHROPIC_API_KEY → apiKeyHelper → CLAUDE_CODE_OAUTH_TOKEN → subscription OAuth. [FACT-CHECK: current authentication precedence in Claude Code documentation.]

Consequences and controls:

IssueControl
Organisation pin (forceLoginMethod, forceLoginOrgUUID) does not cover cloud-provider sessions, and claude setup-token checks the method but not the organisationRestrict cloud routes through cloud IAM; as of November 2026 (Research Paper 3 §4.2) the managed key allowedProviders refuses a session configured for any other provider at start-up (requires v2.1.285 or later). [FACT-CHECK: allowedProviders behaviour and minimum version.]
With the organisation pin set, ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN and apiKeyHelper sessions are blocked at start-upPin the organisation or use a vault helper, not both. Preferred: federation, the self-hosted Claude apps gateway, or cloud IAM. Interactive and CI profiles are separate.
Server-delivered settings reach only accounts already in the organisation and are skipped when a provider variable or non-default base URL is setDeliver the pin and provider restriction by device management (Intune, Jamf, Group Policy); on gateway and cloud routes the device-delivered policy is the policy.
Developer shell exports override intentSet provider and base URL in the managed-settings env block; enforce provider selection by endpoint management, not trust in the environment.

The full settings baseline is on Coding-agent workstation. Entra-side controls (tenant restriction blocking the consumer endpoint from corporate identities, DLP on upload) cover the browser path.

Wire human identity before rollout

Integration checklist, as of August 2026 (Book 3 Ch 5 PR-1, PR-2), co-signed by identity and second line:

BlockStepVerification
Plan and domains (procurement acts; do first)Confirm the plan tier carries SCIM and audit export (Book 3: Claude Enterprise is the floor; Team lacks SCIM, Compliance API and Analytics API)Both visible in admin console
Capture every corporate mail domainNo unmanaged tenant can claim a domain
SSORegister the enterprise application; exchange SAML metadata through the vendor’s SSO mediator (Anthropic uses WorkOS)Round-trip works; cert chain matches published metadata
Record the SSO mediator as a sub-processorRow present in the sub-processor register with attestation reference
SCIMGenerate the SCIM token; group-filter the scope; map attributes to the HR schemaOnly the intended population provisioned; test user carries name, email, manager, department
Set a same-business-day deprovisioning targetTest leaver removed within target
Conditional accessPublish the sensitive-workspace policy (compliant device, MFA, named locations) in report-only for seven days, then enforceDenials reviewed before enforcement
EvidenceForward vendor audit events and IdP sign-in logs to the SIEM; correlate on user object IDJoined query reconstructs a session
ReviewQuarterly access review including MCP connectors and personal-credential pathsEvidence retained per the evidence schedule

[FACT-CHECK: plan-tier feature matrix and SSO mediator.] Personal-account exclusion needs both halves: the tenant restriction for browsers and the device-delivered organisation pin for the coding client.

Agent identity: provider primitives

The factory needs one resolvable agent identity per actor, bound to a human owner and emitted on every action; which primitive supplies it is an implementation choice (Book 2 Ch 11 §4). Test first-class status by asking whether the agent is its own subject in the directory, with its own owner, lifecycle state, conditional access and audit events, rather than a borrowed service principal.

As of August–November 2026, per Book 2 Ch 11 notes and Book 3 Ch 5 §4.3. [FACT-CHECK: each row.]

ProviderAgent identity primitiveDelegation primitiveNotes
MicrosoftEntra Agent ID: first-class object in the same directory as humans and workloads; sponsor lifecycle maps to the wrangler; conditional access appliesOAuth 2.0 on-behalf-of, native (user principals only)Book 1 Ch 8 §4.4 (May 2026) recorded Agent 365 GA for on-behalf-of agents only, autonomous agents in preview. Book 3 Ch 5 dates Entra Agent ID GA to 1 May 2026.
AWSBedrock AgentCore Identity: agent identities as workload identities with agent attributes; session-tagged identifiers fit agent_id_claimTrusted identity propagation via IAM Identity Center (listed services; custom apps via a trusted token issuer)Mature authorisation; the agent abstraction is yours to assemble and keep consistent.
Google CloudGemini Enterprise Agent Platform agent identity (consolidated from Vertex AI agent tooling, April 2026)No single counterpart; assembled from STS token exchange and service-account impersonation, which bounds the call by the service account’s rightsTrust the governance surface only as far as your own tests confirm. On AWS and GCP, enforce entitlement at the capability being called.
Anthropic (Claude Tag)Service-account model for Claude in Slack (24 June 2026): workspace identity for public channels, distinct identities for private ones, credentials injected at request time, whole-identity revocation—Direct messages still run on the individual’s credentials: two regimes in one workspace. Test that its logs export to your SIEM before calling them evidence.

Enforce the envelope through the identity: Mandate as claims or group membership read by the gateway and policy decision point; Means as broker bindings and IAM permissions scoped to the agent (not inherited from the wrangler); Memory as RBAC on stores; Monitoring as the event stream under the agent’s own identity (Book 3 Ch 5 §4.3). The broker accepts only enrolled agent principals and exchanges tokens rather than passing them through; see MCP and connector broker. As of August 2026, IdP-managed MCP connector authorisation was beta and Okta-only; Entra-primary firms run a monthly manual connector review and carry the gap on the risk register. [FACT-CHECK: Entra support for enterprise-managed connector authorisation.]

Apply the practice table by class

Book 1 Ch 8 §5 applies five practices to each class, with different content per class. Tags show the source’s confidence: [REQ] required, [REC] recommended, [EXP] emerging, [PREF] author preference.

PracticeRuntimeDeploymentAgent
Inventory (one source of truth per class)[REC] Directory graph plus workload-identity catalogue; reconciled monthly[REC] Pipeline-bound principals by environment; reconciled per release[EXP] Agent registry; reconciled per agent-creation event
Naming[PREF] runtime-<service>-<env>-<purpose>[PREF] deploy-<pipeline>-<env>[PREF] agent-<wrangler-team>-<purpose>-<created-stamp>
Governance[REC] Conditional access; PIM for elevation; access reviews[REC] Runner-binding conditional access; PIM per environment[EXP] Sponsor lifecycle; access packages; conditional access on configuration drift
Rotation[REC] Token-based, sub-task scope; no long-lived secrets[REC] OIDC federation; no static keys[EXP] Ephemeral; token lifetime equals task lifetime; re-issue, do not rotate
Audit[REQ] Per-action log to the identity[REQ] Per-deployment log to pipeline run and human approver[REQ] Per-action record answering the evidence schema

Naming is the cheapest control: deploy-bronze-pipeline-prod is unambiguous at 22:00; pipeline-runner-1 is not. Bind each practice at a scope: inventory at the tenant, naming at the subscription, governance at the management group, rotation at the resource, audit at the central workspace. Where a long-lived secret exists in any class, ask why it exists before asking when to rotate it.

Lifecycle: register to retire

Run joiner-mover-leaver for agents with the same rigour as for people (Book 2 Ch 11 §4): register → approve and bind → issue narrowly → use → observe and reconcile → renew or revoke → retire.

  1. Register purpose, owner, environment, zone, data class, allowed tools and envelope before issuing authority. No agent without a named wrangler.
  2. Approve and bind the identity to the registered version and specific resource scopes; separate bindings per environment and action class; read and write separately reviewable.
  3. Issue narrowly: short-lived, workload-attested credentials. The attestation should cover the registered configuration (system prompt, tool list, mandate, model version, wrangler), so the identity certifies what kind of thing it is (Book 1 Ch 8 §4.4).
  4. Enforce at the target: the API, broker, store or deployment control authorises the presented identity; model instructions and client checks are never the only barrier.
  5. Observe and reconcile issuance, use, denial, elevation, rotation and revocation events; reconcile provider bindings with the registry. Drift is a control signal.
  6. Re-scope through change control when the mandate widens; a zone move is a lifecycle change needing fresh scope and evaluation.
  7. Retire the day the task ends: disable the execution path, preserve evidence, revoke credentials and grants, verify the credential is dead, and close or transfer the wrangler record. Suspension and credential-death verification are on Agent lifecycle.

Keep secrets out of reach

RuleDetailSource
Agents never hold a long-lived secretNot in context, not in a readable config file, not in an environment variable that outlives the task. A leaked reference is inert; a leaked secret is an incident.Book 2 Ch 11 §4
Tree of vaultsHierarchy scoped by environment and sensitivity; production hard-separated from development; high-sensitivity material apart from routine credentials; access granted at the branch, not the leaf. A flat store defeats least privilege and audit.Book 2 Ch 11 §4
Rotation is planned, not heroicEvery secret has an owner, a rotation interval and an automated, outage-free rotation path.Book 2 Ch 11 §4
Key-management choiceFor confidential financial data at rest the author prefers platform-managed over customer-managed keys, because customer-managed key operations rarely buy assurance a regulator credits. Author preference; take it to your own risk function. Note Research Paper 9 treats customer-managed keys as a condition for some lane exceptions; see Data classes and lanes.Book 2 Ch 11 §4
Machine identities in PAMBring non-human identities inside the privileged-access perimeter, starting with production deployment identities and privileged agent identities; report in-PAM machine-identity coverage to the board.Book 1 Ch 8 §5, §8
Rotation-as-deletion for orphansWhen a secret’s owner cannot be found, rotate it to a value nobody holds; whatever breaks has declared its dependency and gets an owner. Run the sweep at least annually.Book 1 Ch 8 §8
Signing claims short, verification keys longRecords are signed with a short-lived agent claim (in the Supporting Tools design, issued by Entra Agent ID with a 60-minute default) referencing a long-lived verification key; verification checks the record’s issued-at time, so late verification of a validly signed record still passes. Key rotation is itself a signed event (identity.key_rotated) with a default 24-hour overlap before the old key retires.Supporting Tools resilience playbook §5
Scanning is a net, not the designSecret scanning finds a key after it exists; the stronger design removes the paths by which one is created or accepted. Scan every generated artefact before it becomes operational.Book 2 Ch 11 §8

Detect standing privileged grants

A broad, permanent grant made “to unblock the pipeline” becomes the widest door in the estate. Replace standing grants with JIT, short-TTL access, and alert on any grant that has been broad and unused for a set period (Book 2 Ch 11 §8). The source does not fix the period; set one in policy (for example aligned to your access-review cadence) and record it. The weekly comparison of active PIM assignments against the zone map is on Agent lifecycle.

Govern configuration by class

Configuration changes behaviour without code changing, and an agent proposes a config change as easily as a code change. Classify every setting into one of four classes (Book 2 Ch 11 §4; Book 09 Ch 5):

ClassExamplesReview required
HarmlessLog verbosity, display labelMay change freely through the governed path
Operationally sensitiveTimeout, retry count, region for capacityChange control; can degrade or restore service
Security-relevantEndpoint, authentication mode, data-access scope, tool allow-listReview at the level of a code change
Regulatory / controlRetention period, residency choice, approved model selection, a tolerance that is itself a controlThe sign-off the regulatory posture demands, including the control owner

Three disciplines follow:

  1. Configuration is code: versioned, reviewed, deployed through the same governed path; never hand-edited in a portal.
  2. Environment-scoped: development settings cannot reach production, enforced not conventional.
  3. Agent-readable, not agent-writable without the loop seeing it. An agent may read the config it needs and propose changes; it cannot silently rewrite settings that govern its own blast radius.

Classify by meaning, not by file name. Composite example (Book 09 Ch 5): squads classed settings by file; a statement-retention period on the control list sat in a file classed operational, so one squad approval could shorten it in a two-line agent change with every test green. A second pass against the control list routed it to the control owner. Feature flags that change who sees what, data access or regulatory behaviour are changes, not preferences.

Detect configuration drift

Configuration-as-code guarantees the declared state is reviewed, not that the running state matches it. Without drift detection it is “a filing cabinet, not a control” (Book 2 Ch 11 §4).

  • Compare declared and running configuration on a schedule and on every deployment, per environment.
  • Treat any security-relevant or regulatory difference as an incident-grade finding, attributed to the identity that made it.
  • Drift attributed to a human outside the pipeline is the runtime-identity-used-for-deployment signature (above).
  • Reconcile identity bindings the same way: provider bindings against the registry.

Grade the trust spine and fix from the bottom

Book 2 Ch 11 §5 stacks identity, secrets and configuration as a spine: every pipeline, agent and application hangs off it, and a fracture low down caps everything above.

Identity, secrets and configuration are the trust spine every automated change inherits.

Identity, secrets and configuration form the trust spine every automated change inherits. Source: The AI Delivery Factory, Chapter 11, Figure 11.2.

VertebraQuestion the factory answers for any changeStrongAdequateFractured
IdentityWho or what acted, under whose authority, with what scope?Every actor one owned identity; agents first-class; no shared deployment identityGaps confined to known, registered exceptionsShared or generic identities; agents under users or shared service principals
SecretsWhat could the actor reach, and was it referenced or held?No non-human actor holds a durable secretDurable secrets vaulted, owned, rotating, on a sunset planSecrets in repos, pipeline variables or agent context
ConfigurationWhich setting changed behaviour, and did the loop see it?Classed, as code, drift-detectedAs code without drift detectionPortal-edited; config reviewed as lower risk than code

The grading criteria in the three right-hand columns are this page’s synthesis of the chapter’s rules; the source gives the three grades and the propagation rule. Fix the lowest fracture first: identity, then secrets, then configuration, because you cannot scope a secret or attribute a configuration change to an actor you cannot name. A world-class pipeline on a shared deployment credential is a fractured spine with a green dashboard. Let the recipe carry each fix so every product inherits it (see BOM and recipes).

Monday trace (Book 2 Ch 11 §7): pick one production product. List every identity touching its deployment (developer, reviewer, pipeline, artefact store, deployment identity, runtime workload, database connection, monitoring, emergency path, every agent) and ask: one identity or shared, owned by a named human, minimum scope, and for agents whose authority the action carried. Trace where its secrets are created, read and rotated, and whether any non-human actor holds a durable one; check it authenticates to the model gateway as itself. Sort its settings into the four classes.

Audit the estate: the flagging exercise

Book 1 Ch 8 §7 gives five questions for every identity in every class:

  1. Is the class unambiguous in its name and configuration?
  2. Does it hold any permission outside its declared class (runtime with deployment scope, or the reverse)?
  3. Does it hold any permission across environments (a dev deployment identity that can deploy to prod)?
  4. Is it owned by a named human (sponsor or wrangler for agents, service owner for runtime, pipeline owner for deployment)?
  5. Is every action it took in the last 90 days attributable in the form the evidence schema requires?

Any “no” (or “yes” on 2–3) flags the identity. Put flagged identities on a remediation backlog and set a target rate of decline for the count. If the count is flat or rising three months in, the discipline has not taken hold; a decline that keeps speeding up shows it has. Run it in three passes (runtime, deployment, agent); in a large estate this is a six-month programme owned by the Head of IAM, in a small firm eight to twelve weeks. Expect the agent pass to find agents running under developer principals: that finding is the answer.

Role-governance control for privileged roles

The ADD proposal’s cloud governance decision paper (§4.2) describes a lightweight, auditable control that gives “show me the state of privileged-role governance” a current answer:

ElementContent
Authoritative role catalogueEach built-in and custom role with owner, purpose, allowed scopes, last review date
Privileged-access patternsRBAC groups; PIM eligible versus permanent; break-glass
Review cadenceQuarterly baseline plus ad hoc reviews for new or changed roles; run incrementally (for example one role per week)
Documented outcomesConfirmed assignments, removals, and exceptions with justification and approval
Exception / risk-acceptance registerApproved exceptions and risk acceptances, each with justification and approval (adding an owner and expiry date is this page’s recommendation)
Single accountable ownerFor the cloud control plane (identity, network, guardrails)

Evidence of maturity: an approved RACI, the maintained catalogue, recertification records and the exception register.

Test the bypass surface

Test the running route, not the intended configuration. At a minimum attempt to:

  • use an expired, revoked, wrong-environment or over-scoped credential;
  • obtain a token after the federated identity is disabled and confirm no fallback credential answers;
  • switch provider or credential by exporting an environment variable on a managed workstation;
  • invoke a tool or model directly rather than through the broker or gateway;
  • make a child process inherit a broader credential or alternate network path;
  • use a deployment identity outside its runner, or at runtime, and a runtime identity to deploy;
  • have an agent approve its own change;
  • call an unregistered tool or agent version;
  • continue a task after its grant, approval or time budget has expired.

For each, retain the enforced denial with its correlation ID. A denial that never reaches the evidence trail does not demonstrate a control.

Stop, contain, recover

Suspension works at several levels: disable an agent registration, revoke one workload binding, block one tool route, or stop a deployment path. Choose the narrowest control that contains the event, preserve evidence and data-access history, assess impact, then require owner-approved reactivation with a recorded evaluation. Rotation is not revocation; verify the credential is dead and sessions are terminated (see Agent lifecycle and Incident response).

Break-glass is an exception mechanism, not a global credential: predefine the named owner, narrow privilege, duration, reason, independent monitoring and retrospective review, and exercise it outside an incident.

Ownership

ConcernOwner
Identity classes, inventory, flagging exercise, PAM coverageHead of IAM
Deployment identities and runner bindingPlatform, with each pipeline owner
Federation rules as code; static-key sunset registerPlatform engineer; CISO owns the date
Agent identity, envelope claims, delegation modeWrangler (approver, not actor)
Vault tree, rotation schedule, orphan sweepPlatform security
Configuration classes and control-class settingsProduct owner with the named control owner
Role catalogue and recertificationAccountable cloud control-plane owner

Acceptance checks

  • Every identity in the inventory has a class, a conforming name and a named human owner; flagged identities trend down month on month.
  • No identity holds both runtime and deployment authority on one scope; each environment has its own deployment principal; production elevation shows approver and change ticket.
  • Each agent has its own principal on every invocation path, including interactive sessions; no agent holds approval rights; no agent action is recorded under a human principal.
  • Delegated calls exchange tokens at every hop and yield the intersection of person and mandate; the record names the agent and the person separately.
  • No non-human actor holds a durable secret; every surviving static key has an owner, a sunset date and an exception record.
  • Revoking a federated identity produces a denial with an audit record, never a call under another principal; the principal-change detection rule has fired in a test.
  • Managed settings fix the provider and organisation on coding workstations; an exported variable cannot move a session to another identity.
  • Every setting carries one of four classes; control-class settings route to their control owner; declared-versus-running drift is checked per deployment.
  • Machine identities are inside PAM coverage reporting; the orphan-secret sweep ran in the last year.
  • The bypass tests above have been run against the live route, and each denial is in the evidence store with its correlation ID.

Source status and differences

  • Identity taxonomies differ by book (three rows, three classes, five kinds, four accountable principals). This page uses all four as layers, as stated above.
  • Vendor facts (Workload Identity Federation, Entra Agent ID, AgentCore, Gemini Enterprise Agent Platform, Claude Tag, credential precedence, organisation pin, allowedProviders) are dated to their sources and marked for verification. Research Paper 3 (November 2026) is newer than Book 3 (August 2026) on managed settings; where they differ, the workstation detail on Coding-agent workstation governs.
  • Composites. Bank A, Asset Manager X and their scenes are composite examples. The Amazon Q incident is a public case as read by Book 1.
  • Regulatory anchors (DORA ICT risk management, GDPR) cited by the sources are mapped on Regulatory map; this page does not restate them.

Source material

  • Book 1, Chapter 8, Identity and Network: The First Two Control Planes (§3 thesis; §4.1 five identity kinds; §4.2–4.4 runtime, deployment and agent identities; §5 practice table, PAM rule; §7 flagging exercise; §8 anti-patterns including rotation-as-deletion)
  • Book 1, Chapter 9, Agents Inside Network Boundaries (four-zone model, as referenced)
  • Book 2, Chapter 11, Identity, Secrets and Configuration (§4 three identity rows and delivery identities; on-behalf-of versus dedicated identity; provider primitives; secrets; four configuration classes; §5 trust spine and grading; §7 Monday trace; §8 anti-patterns)
  • Book 3, Chapter 5, Identity and Access (§4.1 human identity, Enterprise floor, organisation pin; §4.2 Workload Identity Federation, static-key sunset, credential precedence, no silent fallback; §4.3 agent identity; §7 anti-patterns; PR-1 decision tree; PR-2 SSO, SCIM and federation checklist; PR-3 configuration starting points)
  • Book 3, Appendix A, Anthropic Deployment Options Matrix (§3 per-route authentication and identity: API credential variables, Foundry Entra ID and resource keys, Bedrock and Agent Platform IAM)
  • Book 3, Appendix B, Claude Code Enterprise Settings Baseline (as referenced)
  • Book 09 (Everything Is Green), Chapter 5, Whose Name Goes Here (impersonation is not delegation; four configuration classes in practice)
  • Book 09 (Everything Is Green), Chapter 6, Two Speeds (agent identity in interactive sessions; no approval route for the authoring agent)
  • Research Paper 3, Securing Claude Code in the Enterprise (§4.1 approved routes; §4.2 rules including provider restriction and where server-managed settings stop)
  • Supporting Tools, Resilience Patterns Playbook §5 (short-lived signing claims; key rotation as a signed event)
  • ADD proposal, Cloud Governance Accountability decision paper (§4.1–4.2 role-governance control; §7 standards and evidence map)

← All AI Delivery Factory guidance

On this page

  1. Decisions this page supports
  2. Name the identity classes
  3. Size authority for the worst case, not the expected case
  4. Decide whose authority each action carries
    1. Refuse impersonation by name
  5. Separate deployment identities by environment
  6. Federate workloads and sunset static keys
    1. Per-route mechanics
    2. Sunset static keys on a date you set
  7. Never fall back silently to another identity
  8. Credential precedence is a bypass surface
  9. Wire human identity before rollout
  10. Agent identity: provider primitives
  11. Apply the practice table by class
  12. Lifecycle: register to retire
  13. Keep secrets out of reach
    1. Detect standing privileged grants
  14. Govern configuration by class
    1. Detect configuration drift
  15. Grade the trust spine and fix from the bottom
  16. Audit the estate: the flagging exercise
    1. Role-governance control for privileged roles
  17. Test the bypass surface
  18. Stop, contain, recover
  19. Ownership
  20. Acceptance checks
  21. Source status and differences

All pages in Build the platform →