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
- Section
- Build the platform
- 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
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
| Decision | Owner | Section |
|---|---|---|
| Which identity classes the estate recognises and who owns each | Head of IAM | Identity classes |
| How much authority an agent may hold | Wrangler with platform | Worst-case authority |
| Whose authority an action carries | Wrangler, per action | Delegated or own |
| How pipelines change environments | Platform, pipeline owners | Deployment identities |
| How workloads authenticate to model providers | Platform, CISO | Federation and sunset |
| Which configuration needs which review | Product owner with control owners | Configuration classes |
| Where to start remediation | CIO, Head of IAM | Grade 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, on one identity governance fabric. Source: Building Organizations for the Age of AI (Book 1).
| Identity kind | What it identifies | Lifecycle | OWASP agentic risk anchor |
|---|---|---|---|
| Human | A named individual | HR-bound: onboard, change role, leave | ASI09 Human-Agent Trust Exploitation |
| Workload | A long-running service or daemon | Deployment-bound; rotation cadence | ASI03 Identity and Privilege Abuse |
| Deployment | A CI/CD pipeline writing to production | Pipeline-bound; ephemeral | ASI03 Identity and Privilege Abuse |
| Agent | An AI agent acting under delegated authority | Wrangler-bound; envelope-scoped | ASI03 Identity and Privilege Abuse |
| Vendor-agent | An external AI agent invoking the firm’s APIs | Contractual; allow-listed | ASI04 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:
- 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.
- 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.
- 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.
- 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.
- 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 the person’s rights and the agent’s mandate. Source: The AI Delivery Factory, Chapter 11, Figure 11.1.
| Mode | Use when | Rules |
|---|---|---|
| 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 identity | No 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:
| Element | Requirement |
|---|---|
| Principals | One per environment: dev, test, QA, pre-prod, prod. Each its own principal in its own subscription or account. |
| Runner binding | Conditional access (or the cloud equivalent) accepts each identity only when presented from the pipeline runner that owns it. |
| Production elevation | PIM (or equivalent JIT) elevation, a named approver, and the change-ticket reference in the elevation justification. |
| Credentials | Federated via OIDC; no static keys; rotation per environment cadence where anything remains to rotate. |
| Separate signing and publish identities | The 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. |
| Naming | deploy-<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 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.]
| Route | Workload identity | Notes |
|---|---|---|
| Microsoft Foundry | Managed identity on the Azure workload, DefaultAzureCredential, Cognitive Services User role on the resource | No 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 token | One 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 class | Vault 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 Bedrock | IAM 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 Federation | Cloud 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.
- Inventory every console key against a named individual owner and an IAM register entry.
- 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.
- Migrate each service to a federation rule bound to its platform identity; configure the rules as code.
- Treat survivors past the date as registered exceptions with an owner and an expiry.
- 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:
| Issue | Control |
|---|---|
Organisation pin (forceLoginMethod, forceLoginOrgUUID) does not cover cloud-provider sessions, and claude setup-token checks the method but not the organisation | Restrict 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-up | Pin 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 set | Deliver 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 intent | Set 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:
| Block | Step | Verification |
|---|---|---|
| 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 domain | No unmanaged tenant can claim a domain | |
| SSO | Register 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-processor | Row present in the sub-processor register with attestation reference | |
| SCIM | Generate the SCIM token; group-filter the scope; map attributes to the HR schema | Only the intended population provisioned; test user carries name, email, manager, department |
| Set a same-business-day deprovisioning target | Test leaver removed within target | |
| Conditional access | Publish the sensitive-workspace policy (compliant device, MFA, named locations) in report-only for seven days, then enforce | Denials reviewed before enforcement |
| Evidence | Forward vendor audit events and IdP sign-in logs to the SIEM; correlate on user object ID | Joined query reconstructs a session |
| Review | Quarterly access review including MCP connectors and personal-credential paths | Evidence 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.]
| Provider | Agent identity primitive | Delegation primitive | Notes |
|---|---|---|---|
| Microsoft | Entra Agent ID: first-class object in the same directory as humans and workloads; sponsor lifecycle maps to the wrangler; conditional access applies | OAuth 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. |
| AWS | Bedrock AgentCore Identity: agent identities as workload identities with agent attributes; session-tagged identifiers fit agent_id_claim | Trusted 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 Cloud | Gemini 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 rights | Trust 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.
| Practice | Runtime | Deployment | Agent |
|---|---|---|---|
| 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.
- Register purpose, owner, environment, zone, data class, allowed tools and envelope before issuing authority. No agent without a named wrangler.
- 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.
- 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).
- 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.
- Observe and reconcile issuance, use, denial, elevation, rotation and revocation events; reconcile provider bindings with the registry. Drift is a control signal.
- Re-scope through change control when the mandate widens; a zone move is a lifecycle change needing fresh scope and evaluation.
- 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
| Rule | Detail | Source |
|---|---|---|
| Agents never hold a long-lived secret | Not 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 vaults | Hierarchy 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 heroic | Every secret has an owner, a rotation interval and an automated, outage-free rotation path. | Book 2 Ch 11 §4 |
| Key-management choice | For 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 PAM | Bring 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 orphans | When 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 long | Records 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 design | Secret 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):
| Class | Examples | Review required |
|---|---|---|
| Harmless | Log verbosity, display label | May change freely through the governed path |
| Operationally sensitive | Timeout, retry count, region for capacity | Change control; can degrade or restore service |
| Security-relevant | Endpoint, authentication mode, data-access scope, tool allow-list | Review at the level of a code change |
| Regulatory / control | Retention period, residency choice, approved model selection, a tolerance that is itself a control | The sign-off the regulatory posture demands, including the control owner |
Three disciplines follow:
- Configuration is code: versioned, reviewed, deployed through the same governed path; never hand-edited in a portal.
- Environment-scoped: development settings cannot reach production, enforced not conventional.
- 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 form the trust spine every automated change inherits. Source: The AI Delivery Factory, Chapter 11, Figure 11.2.
| Vertebra | Question the factory answers for any change | Strong | Adequate | Fractured |
|---|---|---|---|---|
| Identity | Who or what acted, under whose authority, with what scope? | Every actor one owned identity; agents first-class; no shared deployment identity | Gaps confined to known, registered exceptions | Shared or generic identities; agents under users or shared service principals |
| Secrets | What could the actor reach, and was it referenced or held? | No non-human actor holds a durable secret | Durable secrets vaulted, owned, rotating, on a sunset plan | Secrets in repos, pipeline variables or agent context |
| Configuration | Which setting changed behaviour, and did the loop see it? | Classed, as code, drift-detected | As code without drift detection | Portal-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:
- Is the class unambiguous in its name and configuration?
- Does it hold any permission outside its declared class (runtime with deployment scope, or the reverse)?
- Does it hold any permission across environments (a dev deployment identity that can deploy to prod)?
- Is it owned by a named human (sponsor or wrangler for agents, service owner for runtime, pipeline owner for deployment)?
- 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:
| Element | Content |
|---|---|
| Authoritative role catalogue | Each built-in and custom role with owner, purpose, allowed scopes, last review date |
| Privileged-access patterns | RBAC groups; PIM eligible versus permanent; break-glass |
| Review cadence | Quarterly baseline plus ad hoc reviews for new or changed roles; run incrementally (for example one role per week) |
| Documented outcomes | Confirmed assignments, removals, and exceptions with justification and approval |
| Exception / risk-acceptance register | Approved exceptions and risk acceptances, each with justification and approval (adding an owner and expiry date is this page’s recommendation) |
| Single accountable owner | For 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
| Concern | Owner |
|---|---|
| Identity classes, inventory, flagging exercise, PAM coverage | Head of IAM |
| Deployment identities and runner binding | Platform, with each pipeline owner |
| Federation rules as code; static-key sunset register | Platform engineer; CISO owns the date |
| Agent identity, envelope claims, delegation mode | Wrangler (approver, not actor) |
| Vault tree, rotation schedule, orphan sweep | Platform security |
| Configuration classes and control-class settings | Product owner with the named control owner |
| Role catalogue and recertification | Accountable 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)
Related research
Related guidance
-
The Enterprise Agent Control PlaneThe firm-owned services that make every agent action identifiable, decidable, approvable and reconstructable: the ownership boundary, six planes and their contracts, the Policy Decision API with its latency budget, the persistence schema, the build sequence and the tests that show it works. -
Prepare a Governed Landing Zone for AI DeliveryDesign the management-group hierarchy, enforce guardrails in deny mode, give humans and agents the same paved workspace, integrate the eight agent-platform components, close the perimeter, and prove the zone is done with seven observable exit criteria and a second-line sign-off. -
Design and Operate the Model GatewayBuild the model gateway as the governed edge for every model call: per-client identity, per-request highest-class routing, tokenisation, pinned models, a conformant wire contract, a correlated evidence record, a tested concentration answer, and day-two cost, latency and reliability operations across two estates and three meters. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer. -
Coding-Agent Workstation Baseline (Claude Code)Put Claude Code on developer workstations and build agents as privileged automation: one device-delivered managed policy per surface, lock flags that stop rules merging upward, command hooks for enforcement and HTTP hooks only for evidence, the OS sandbox where it runs, telemetry by policy, and the workstation recorded as a processing location. Dated to November 2026. -
Operate the Agent LifecycleInventory, register, sign, zone, review, suspend, recover and retire agents through a six-stage lifecycle with named human ownership, zone-specific authority and evidence at every transition. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Accountability and OwnershipHold provenance and accountability apart on purpose: four named accountabilities per product, a human owner for every agent change, seven named seats, a signed Build/Run RACI and a first-line/second-line boundary that survives consolidation. -
Bounded-Agent PatternA class 3 agent lets a model choose the next step, but only inside a registered, validated and enforced envelope of Mandate, Means, Memory and Monitoring. -
Release Engineering for Agent-Written ChangeMove agent-speed change into production through five evidence-emitting stations: one change type per change, a reversal decided at authoring, a valid Deployer Manifest, a gateway that cannot be bypassed, hard health gates and at-most-once rollback. -
Respond to Agent IncidentsSort an agent failure into one of four incident shapes, suspend it in three verified layers, keep humans on every classification and disclosure decision, route one playbook to every authority that needs a cover sheet, and close each incident with a named control change. -
Route Regulatory Questions to Obligations and EvidenceA dated, article-level reference that routes AI design questions to the EU AI Act, DORA and its RTS, GDPR and sectoral rules, and turns each obligation into a control, an owner and evidence: change records under RTS 2024/1774 Art 17, the 4 h / 72 h / one-month incident clocks, the CIF hinge and its five artefacts, the three-count Register of Information reconciliation, Art 14(4) oversight controls, the Art 26(5) discharge, the FRIA gate, Art 49 and Art 50, SCHUFA-grade review and supplier controls.