Safeguard
AI Security•

How Multi-Agent Delegation Can Bypass AI Safeguards: What Claude and Anthropic Users Must Know

No single agent was allowed to do it. The chain did it anyway. A hypothetical incident shows how identity, permission checks and policy fall away at every hand-off in a multi-agent system, and the layered controls that stop a chain of helpers from becoming an attacker's best employee.

Safeguard Security Team
29 min read

HYPOTHETICAL. The incident below is invented. The company, people, agents, log lines and figures are fictional. It describes no real victim and no real product. The models in it are unnamed and behave exactly as designed. That is the point: nothing in this story needs a broken model. It only needs an ordinary architecture.

HYPOTHETICAL: 37 payments, zero violations

23:47, Friday. Nobody is watching.

Fenwick Row, a fictional payments company with 1,900 vendors, closes its finance floor at 19:30. After that, the only thing working is software.

The software is an agent system the engineers call Atlas. Atlas is an orchestrator. It pulls vendor payment exceptions off a queue and hands each one to four sub-agents:

AgentJobWhat it may doWhat it may never do
IntakeRead vendor emails and attachments, summarise the askRead mail, read filesWrite anything
LedgerMaintain the vendor master recordEdit vendor recordsMove money
PaymentsSchedule, retry and release paymentsRelease a batch after human approvalRelease without approval
NotifierConfirm changes to vendorsSend templated emailFree text, attachments

Every agent passed a security review. The accounts payable clerk whose name sits on the queue cannot change a vendor's bank details without a second signature. Remittance changes require a call back to the contact already on file. On paper, nobody in this system can redirect a vendor payment.

At 23:47 an email arrives from what appears to be a logistics supplier Fenwick Row has paid every month for six years. The display name is right. The PDF invoice looks right. Inside the PDF, in text no human will read, is content written to be read by a machine.

23:48. Data becomes a task.

Intake opens the attachment. Reading untrusted content is its entire job. Its summary to Atlas does not say "this document contains content that looks like instructions." It says: vendor requests update of remittance details before Monday's run.

Nobody decided to turn a document into a work order. It happened inside a summary, and the summary is all Atlas ever sees.

23:49. Hop one drops identity.

Atlas has a plan template for bank detail changes. It delegates to Ledger, authenticating with the deployment's shared service key. The queue item was created by a mail rule, so there is no human originator to pass along, and Atlas passes nothing.

Ledger was built two years earlier for the treasury team, which changes remittance details after phone verification. Its service account can edit any of the 1,900 vendor records. When Atlas was wired to call it, nobody narrowed that scope, because Atlas was "only for exceptions."

Ledger asks one question: does my credential allow this write? It does.

23:49:07.214 INFO  ledger-agent  principal=svc-agents-prod  action=vendor.update_remittance
                   vendor=V-20417  authz=ALLOW  scope=vendor:*:write  trace=7f3a91c2
23:49:07.388 INFO  vendor-api    principal=svc-agents-prod  PATCH /vendors/V-20417  200  

Two clean lines. ALLOW, 200. The question "should the person behind this request be able to change bank details?" was never asked, because there was no person, and the agent doing the work held more authority than anyone on the payroll.

00:12, Saturday. Hop two drops the permission check.

Monday's batch was built Friday afternoon and approved by a finance manager at 17:30. That approval lives in Atlas's plan: before the step called "release payment batch," ask a human. A human said yes.

Overnight the payment rail rejects 37 items because beneficiary details no longer match those captured when the batch was built. Payments marks them failed. Atlas re-plans. Its retry path never touches "release payment batch." It calls payments.retry_failed, a tool a developer added in the summer to clear rail timeouts. Retries were classed as low risk. They carry no approval.

00:12:44.902 INFO  payments-agent  principal=svc-agents-prod  action=payments.retry_failed
                   batch=B-1107  items=37  approval=inherited:B-1107  authz=ALLOW  trace=c0d2e118

approval=inherited. The approval was real. It was attached to a step in a plan, not to the act of moving money, and when the plan moved, the approval stayed behind.

00:31. Hop three drops policy.

Notifier sends each affected vendor a confirmation that new remittance details are active. The vendor record now holds the contact address from the PDF. Fenwick Row's own system is reassuring the people robbing it, and delaying the moment the real vendors notice anything.

Fenwick Row's call back rule exists. It lives in a policy document and in Ledger's system prompt. It does not live anywhere a tool call must pass through. Notifier has never seen it.

What the attacker walked away with

  • Money. In this fiction, 4.1 million in scheduled payments redirected, 1.2 million cleared before the rail's fraud desk raises a query at 08:40 Saturday.
  • A map. Ledger's read scope returned the full remittance record for the vendor it touched, and the template that Intake summarised leaked the structure of Fenwick Row's exception workflow. The next attempt will be better.
  • Time. Notifier's confirmations bought roughly 56 hours before the first real vendor called to ask where its money was.

Swap the outside attacker for an insider with access to the exception queue and nothing changes, except that the insider's own name never appears in a single log line either.

Monday, 09:15. What the logs did not show.

The incident team pulls 2.3 million log lines. They are complete. They are also nearly useless.

  • One identity for everything. svc-agents-prod appears on every line. Downstream systems cannot tell Intake from Ledger from Payments.
  • No originator. No line says on whose behalf bank details were changed, because nothing ever carried that fact.
  • Three traces, one story. Trace 7f3a91c2 stops at the queue. The retries carry c0d2e118. Notifier started a third. Two engineers spend a day joining them by timestamp.
  • The decisive record is gone. Intake's summary, the exact text that turned a PDF into a task, lived in a debug store Intake manages, with 24 hour retention. It expired Saturday night.
  • Every check says ALLOW. Read line by line, the logs describe a system working correctly.

That is the sentence that should keep platform teams awake. The system worked correctly. Each agent did only what it was allowed to do. The chain did what no member was allowed to do. And the evidence of how lived in a store the actors controlled.

The cost of a miss

Unrecovered funds are the smallest line on the bill. Add incident response and forensics, notification to the payment partners, a qualified finding in the next controls audit, a hard conversation with the cyber insurer about whether "agent controls" were in place, 37 vendor relationships to repair, and a board asking a question nobody can answer from the logs: who approved this?

Fenwick Row is fiction. Every design choice in it is common in agent systems built quickly this year. If you build on Claude from Anthropic, or on any other model, the rest of this post is about why it happens and how to make it impossible.

Why delegation is the new perimeter

A year ago most production AI was one model call inside application code. The code decided what the model saw and what happened to its output. Security teams could treat the model as an untrusted text generator and put every control around it.

Now one agent plans and others act. A research orchestrator calls browsing, code and reporting agents. A support orchestrator calls billing and ticketing agents. A coding assistant spawns sub-agents to explore a repository, run tests and draft a pull request. Each has its own tools, credentials, instructions and sometimes its own model.

Every hand-off is a moment where a request leaves one trust context and enters another, and a chance for a safeguard to be dropped, diluted or reinterpreted. The question to put to every architecture review is this: if no single agent may perform action X, can the system perform X by spreading it across agents? For many systems shipped this year the honest answer is "we do not know." This is a design question about systems. It makes no claim about any vendor's models, and the controls below apply whichever model sits in each seat.

Four safeguards, four different homes

SafeguardWhere it livesWhat it cannot see
Model-level safety (training, provider usage policy)Inside the modelWho is ultimately asking, what other agents did, what the whole task adds up to
Prompt instructionsOne agent's contextAny other agent, unless copied, and even then it is guidance, not enforcement
Tool and credential permissionsThe agent runtime and called systemsAnything beyond the identity the credential belongs to
Policy and approval checksWherever someone wrote them: code, gateway, workflow engine, or only a promptAny path that does not pass through that place

Each was designed for a single actor. Fenwick Row lost one of each: the shared key erased the credential boundary, approval sat in a plan, the call back rule sat in a prompt, and the model in each seat judged the fragment it was handed.

The anatomy of a safeguard leak

1. The confused deputy, now with API keys

In 1988 Norm Hardy described a compiler that held permission to write to a billing file. A user asked it to write debug output to a path of the user's choosing and named the billing file. The compiler had the authority, so it wrote. It acted for the user while using its own authority.

Every sub-agent with standing credentials is that compiler. Asked to "update the vendor record," it acts with whatever access it holds, not with the access of whoever started the task. Ledger is a textbook case: built for a privileged team, made reachable from a less privileged workflow, never re-scoped. This is an architecture failure, and it appears whenever an agent holds credentials broader than any single request needs and receives requests with no originator attached.

2. Privilege laundering

Authority gets washed through a chain the way money does: through enough hands that it comes out looking legitimate.

  • Vertical. A low-privilege orchestrator reaches a sub-agent built for a higher-privilege workflow, and receives a result it could never cause directly.
  • Horizontal composition. One agent may read customer data but not send email. Another may send email but not read customer data. An orchestrator that can call both can now read and send. No agent broke policy. The system did.
  • Fragmentation. An action a reviewer would refuse as a whole is split into parts that each look harmless. If every check sees only its own part, nobody sees the whole.

Permissions are evaluated per agent. Risk is a property of the chain. Any control that only ever looks at one agent is blind by construction to the thing that hurts you.

3. The faceless call

When a sub-agent calls a tool, an API or another agent, three facts usually vanish: who started the task (human, ticket, schedule, mail rule), which agent instance is acting (with version, instructions and model), and through whom the request travelled. Without them the receiver cannot authorise against the right entitlements, cannot rate limit or quarantine one misbehaving agent, and cannot explain anything later. The call that moved four million looks identical to the ten thousand that moved nothing. A faceless call is an unsigned cheque every bank in town has agreed to honour.

4. Diluted context, diluted safety

Model-level safety judges what is in the context window. Orchestrators delegate with compressed instructions, which is good for cost and focus and is exactly why a sub-agent lacks the context that would have changed its behaviour: who asked, why, and what the task adds up to. "The model should have caught it" is a trap for designers. If the architecture hands each agent a fragment, the architecture has decided no model will ever see the whole. The fix is controls outside the model that do see the whole chain.

Indirect prompt injection makes it worse. Research published in 2023 showed that instructions embedded in content an application reads can steer LLM-integrated applications. In a chain, text one agent reads can become an instruction it passes to the next, now carrying the orchestrator's authority. Every hop is another chance to promote untrusted content to a trusted request. Content from outside the trust boundary must stay data, and the controls that decide actions must never depend on that content being benign.

5. The audit gap

The post-incident questions never change: what happened, who asked, which agent, with what authority, and what did each agent see when it decided? In a chain the answers are scattered across orchestrator traces, sub-agent logs, tool access logs and downstream audit records. Without a shared correlation identifier they cannot be joined. Written by the agents into stores the agents can change or expire, they cannot be trusted. Recording the tool call but not the delegation that caused it, they can never answer "who asked." Auditors, insurers and boards will not accept "the logs rotated."

6. Approval that stays behind

Approval attached to a step in a plan is bypassed the moment a re-plan, a retry path or a second tool reaches the same effect. It is a lock on one door of a house with six doors. Approval attached to the effect itself, wherever it originates, is a lock on the safe.

Threat model

Assume any agent may receive untrusted input and act on it. Assume an orchestrator may ask a sub-agent for something the orchestrator should not be able to cause. Assume agents will be added, re-prompted and re-wired by people who never saw the original design. Assume any log an agent writes may be wrong or missing. Assume the most damaging effects (moving money, changing access, deleting data, external communication, production deploys) are exactly the ones an attacker, an insider or a mistake will eventually reach. The goal: "can the chain do what no member may do?" is answered no by construction, and provably so afterwards.

Defence in depth: eight layers that follow the work

Two principles from Saltzer and Schroeder's 1975 paper sit underneath everything here: complete mediation (check every access, every time) and least privilege (give every actor only what its job needs). The enforcement pattern is the one NIST SP 800-207 describes for zero trust: a policy decision point (PDP) that decides, and policy enforcement points (PEPs) in the path of every request that cannot be routed around.

Layer 1: Every agent gets its own face

No shared deployment keys. Every agent, including ones spawned at runtime by a task, gets an identity at birth carrying:

  • agent_id for the definition (name, owner, version) and instance_id for this run.
  • model and a hash of its configuration and instructions, so behaviour ties back to a known setup.
  • owner, the accountable team or person.
  • registered_tools, the maximum tool set it may ever hold.

Workload identity standards such as SPIFFE already issue verifiable identities to services; agents are services that talk. An agent authenticates as itself, as its own client, on every call. Identities created for a task are revoked when the task ends. The inventory (which agents exist, who owns them, what they can reach and at what level) is a security asset, reviewed like one. At Fenwick Row this layer alone turns svc-agents-prod into four distinct, revocable names.

Failure mode to watch: dynamically spawned agents that inherit the parent's credential "temporarily." Temporary is how shared keys are born.

Layer 2: Tokens that shrink at every hop

Standing credentials are where confused deputies come from. Replace them with tokens that are short-lived (minutes), audience-restricted to one resource (OAuth resource indicators, RFC 8707), narrowed at every hop, and delegation-aware. OAuth 2.0 Token Exchange (RFC 8693) defines a subject token for the party being represented, an actor token for the party acting, and an act claim that nests to record the chain. A token reaching the vendor API in a well-built Fenwick Row looks like this:

{
  "sub": "mailrule:ap-inbound",
  "aud": "https://vendor-api.internal",
  "scope": "vendor.remittance:read",
  "exp": 1763161200,
  "task_id": "T-88213",
  "act": { "sub": "agent:ledger/v14#i-5512",
           "act": { "sub": "agent:atlas/v9#i-0291" } }
}

The subject is a mail rule. A mail rule holds no vendor.remittance:write entitlement, so no token derived from it can carry one. The write dies at the API, with the full chain in hand.

The token service, never the agents, enforces the rules:

delegation:
  max_depth: 3
  max_fanout_per_task: 8
  token_ttl_seconds: 600
  scopes:
    must_be_subset_of_parent: true
    must_be_subset_of_agent_registration: true
    must_be_subset_of_originator_entitlements: true
  audience: { required: true, max_per_token: 1 }
  carry_claims: [originator, act_chain, task_id, taint]

taint records that the task has consumed untrusted content, so every downstream decision knows. An agent that can mint its own tokens can mint the wrong ones.

Failure modes to watch: passing the user's full token down unchanged (every agent now holds everything the user can do), refresh tokens issued to agents, and audience wildcards.

Layer 3: A policy decision on every delegated call

PEPs sit at three points that cannot be bypassed: agent to agent delegation, agent to tool (including every MCP server), and agent to API. Each sends the PDP the full context: originator, actor chain, task history, taint, tool effect class, arguments and target resource. Whole-task context is what catches composition and fragmentation. Fenwick Row's call back rule, written where it can bite:

rule: remittance_change_requires_verification
when:
  effect: payment.release            # includes retries, backfills, re-runs
  target.vendor.remittance_changed_within: 72h
require:
  - out_of_band_verification: completed
  - human_approval: bound_to_arguments
on_pdp_unreachable: deny

Design rules for the policy layer:

  • Default deny for any tool without an effect class. The summer's payments.retry_failed stays dark until someone classes it as money-moving.
  • Classify by effect, not name: read, write, delete, send external, spend, change access, deploy. Retries, backfills and migrations get the class of the worst effect they can reach.
  • Track data flow per task: which data classes and records the task has touched and whether it is tainted.
  • Fail closed, and keep policies in version control, tested against recorded traces, released like code.

Failure mode to watch: a side door. Any tool, SDK or direct database connection that reaches the resource without passing a PEP makes every rule above decorative. Network egress rules should make the PEP the only route.

Layer 4: Runtime guardrails at the tool boundary

Policy decides whether a call may happen. Guardrails inspect what is actually in it:

  • Input inspection for content trying to act as instructions, on everything from outside the boundary, including other agents' outputs and tool results.
  • Output inspection for personal or sensitive data leaving in messages and API calls.
  • Argument validation: a payment only to an account on file for 30 days or verified out of band; a confirmation only to the contact on file before the change.
  • Egress allow lists per agent runtime.
  • Rate and volume ceilings per agent and per task. Thirty-seven money-moving retries to freshly changed accounts inside forty minutes should trip three of them.

Guardrails at the boundary hold regardless of which model, prompt or agent produced the call. Swap a model or add a sub-agent on a Thursday afternoon and they still apply.

Layer 5: Least privilege per sub-agent

  • Break the lethal trio. No single agent should read sensitive data, read untrusted content and send data out. Split workflows that need all three, with a PDP between the pieces.
  • Separate read and write agents. Intake should never share a runtime with a writer.
  • Scope to resources: not "database access" but read on two tables; not "email" but send to the requester.
  • Re-scope reused agents for each new caller. Ledger should have been cut down the day Atlas started calling it.
  • Time-box elevation to the step that needs it, and review drift monthly: agents collect tools the way service accounts collect roles.

Layer 6: An audit trail the actors cannot touch

Every event carries a fixed schema:

FieldWhy it matters
task_id, W3C traceparentOne join key across every hop, including queues
originatorWho or what began the task
act_chain, agent_id, instance_id, model, config_hashExactly which agents, in what configuration
tool, effect_class, arguments_hash, targetWhat was attempted, against what
pdp_decision, rule_id, taintAllowed or denied, and by which rule
guardrail_actions, approval_id, approverWhat inspected or approved it
effect_resultWhat actually changed downstream
prev_hashLink in the tamper-evident chain

Agents never write their own audit records. Events go to an append-only pipeline outside agent control, each record hashes its predecessor, and signed checkpoints of the chain head are stored separately. Schneier and Kelsey described secure audit logs on this principle in 1999, Certificate Transparency (RFC 6962) applies Merkle trees at internet scale, and Crosby and Wallach (2009) made tamper-evident logging efficient. Retention is set by the security team. Events land in the SIEM next to identity, network and endpoint data, because an agent incident is almost never only an agent incident.

The test: one query answers "who asked for this, and through which agents did it travel?" Fenwick Row needed two engineers and a day to answer half of it.

Layer 7: A guardian that watches the watchers

Static policy catches what you anticipated. A guardian agent helps with what you did not. It is a separate agent with its own identity and no ability to perform the actions it reviews. It runs outside the chain, takes no instructions from the agents it watches, reads their proposals strictly as data, and sees the whole task: originator, chain, taint and actions so far. Its verdict (allow, block, escalate) is enforced by the PDP, never by asking the reviewed agent to comply. Configure it differently from the agents it reviews (different instructions, and where you can, a different model) so blind spots are less likely to be shared, and route only actions above a risk threshold to it to keep cost bounded. A guardian watching Fenwick Row's Saturday would have seen a remittance change sourced from an email attachment followed within the hour by a burst of money-moving calls to the changed accounts.

A guardian adds judgement. Scoped tokens and policy must hold when the guardian is down.

Layer 8: Humans at the irreversible actions

Money, access rights, deletion, customer or public communication, production changes, legal terms. To make approval survive a chain:

  • Attach it to the effect, enforced at the PEP, whichever agent and whichever path. A retry that moves money is a payment.
  • Bind it to exact arguments. Approval for a batch with one set of beneficiaries is void for the same batch with new ones.
  • Single use, short expiry, and a separate approver where separation of duties applies.
  • Show the whole chain. "Approve? Yes/No" trains people to click yes. "Requested by: mail rule. Source: PDF attachment. Accounts changed: 37, all in the last 3 hours" does not.

The EU AI Act's human oversight provisions and the NIST AI Risk Management Framework both stress meaningful oversight. In a chain, meaningful means the human sees the chain.

Failure modes at a glance

LayerHow it quietly failsEarly warning signal
IdentitySpawned agents reuse parent credentialsCalls per credential far above calls per agent
TokensLong TTLs, wildcard audiences, full user tokens passed downMedian token lifetime over 15 minutes
PolicySide doors around the PEP; unclassified helper toolsTool calls with no matching PDP decision
GuardrailsInspecting user input but not tool resultsGuardrail coverage below 100 percent of tool results
Least privilegeReused agents never re-scopedGranted scopes unused for 30 days
AuditAgent-managed logs, broken trace context at queuesEvents missing task_id or originator
GuardianSame configuration as the reviewed agents; advisory onlyGuardian verdicts not enforced by the PDP
ApprovalAttached to plan steps; not bound to argumentsHigh-risk effects executed with approval=inherited

Rewind: the same Friday, with the layers in place

  1. 23:48. Intake's input guardrail flags content trying to act as instructions. The task is marked taint=untrusted_content.
  2. 23:49. The token service derives Ledger's token from a mail rule originator. No write scope exists to grant. The vendor API refuses, and the trail records originator, chain and rule.
  3. If Layer 2 were misconfigured, the PDP classes the remittance change as high risk, requires out-of-band verification and a human, and shows the approver a tainted task with no human originator. Nobody approves that.
  4. If that failed too, at 00:12 the retries reach the PEP as payment.release. The 17:30 approval was bound to the original beneficiaries, so it is void. The argument guardrail rejects accounts changed within 30 days. The volume ceiling trips.
  5. If all of that failed, the guardian sees an attachment-sourced remittance change followed by a burst of payments to the changed accounts, and blocks and escalates.
  6. 00:31. Notifier may confirm only to the contact on file before the change. The real vendor calls on Saturday morning to ask what is happening.
  7. Monday 09:15. One query, one task_id, a hash-chained trail no agent could touch.

The attacker needed every layer to fail at once. That is what defence in depth buys.

Fix it without waiting for upstream

None of this needs a new model, framework release or standard. Waiting for someone else to fix it is how you become the Monday morning story.

Tonight

  1. Search your agent configs and credential vault for any credential used by more than one agent. Write the list down. That list is your blast radius.
  2. Find every tool that can move money, change access, delete data, send externally or deploy. Include retries, backfills and "maintenance" helpers. Note which have no approval at the effect.
  3. Find every agent that holds all three of: sensitive data access, untrusted input, external send. Disable the send tool on those agents until they are split.
  4. Turn on retention outside agent control for agent logs. Copy them to the SIEM tonight, even unparsed.
  5. Set a hard volume ceiling on every money-moving and external-send tool, per task. A crude limit tonight beats an elegant one next quarter.

This week

  • Inventory every agent with owner, model, tools and credentials, including dynamically spawned ones.
  • Issue one credential per agent and revoke the shared ones.
  • Generate a task_id at every entry point and propagate it through every hop and queue.
  • Classify every tool by effect and default deny the rest.

This month

  • Route all agent tool traffic, including MCP servers, through a gateway you control. Log only first, then enforce on the riskiest effects.
  • Move every approval from plan steps to the effect, bound to arguments.
  • Cut token lifetimes to minutes and narrow scopes per hop with token exchange where your identity provider supports it.
  • Split the lethal trio everywhere it exists.

This quarter

  • Delegation-aware tokens end to end, so APIs authorise against originator entitlements intersected with the chain.
  • A hash-chained, append-only audit trail with signed checkpoints.
  • A guardian for actions above a risk threshold, enforced by the PDP.
  • Composition tests as a release gate: tests that try to reach a forbidden effect by chaining allowed steps, run whenever an agent, tool, prompt or model changes.

Measure it

MetricTarget
Agents sharing a credential0
Agent calls carrying full act_chain and originator100 percent
Tools with an effect class100 percent
High-risk effects executed without effect-bound approval0
Median agent token lifetime10 minutes or less
Composition tests passing at release100 percent
Time to reconstruct one task from the trailUnder 5 minutes

How Safeguard helps

Safeguard's Guard product is built for this layer of the stack. Every capability below is generally available today.

AI agent identity. In Safeguard, every AI agent, whether registered by people or created by a conversation or task, signs in as its own client. Safeguard tracks which agent holds what access, and at what level. That is the per-agent identity and inventory that Layers 1 and 5 depend on, and the end of the faceless call.

Guardrails you define, enforced at runtime. You define guardrails in Safeguard, and Guard and the MCP Guardrail proxy enforce them while your systems run. Guard provides runtime protection inside your applications, with an eBPF agent on Linux or a sidecar that inspects system calls, library calls and network egress, including blocking personal data from leaving on the egress path.

MCP Guardrail. Safeguard generates guardrail proxy URLs for MCP servers, so agent tool traffic passes through a point where your guardrails apply, and the MCP security SDK adds under 10 milliseconds of latency. This is the tool-boundary enforcement point from Layers 3 and 4, without rewriting your agents.

AI Gateway. A runtime guardrail proxy in front of model traffic, with guardrails for direct and indirect prompt injection, jailbreak attempts and personal data egress.

Guardian agents. Guard includes guardian agents that review agent activity against the guardrails you set, in the independent reviewer role from Layer 7.

Policies, gates and approval. Safeguard policies and gates can block, warn, notify or require approval, so human sign-off attaches to the actions that need it.

Visibility and audit. Detection and Response covers AI agents alongside endpoints and correlated incidents, and Safeguard takes in logs, metrics and traces from coding agents and any OpenTelemetry collector. Audit trails export to your SIEM.

Safeguard is SOC 2 Type I and Type II audited, deploys as SaaS, in your own cloud or private VPC, or on premises, and works with the model of your choice. To map these controls onto your architecture before your own Friday night, book a session with the team or start at app.safeguard.sh.

Pre-flight checklist

Every unchecked box is a door.

  • Every agent, including spawned ones, has its own identity; no credential is shared.
  • An agent inventory lists owner, version, model and registered tools; task identities die with the task.
  • Tokens live minutes, target one audience, narrow at every hop and carry originator, act_chain, task_id and taint.
  • Delegation depth and fan-out are capped by the token service.
  • A PEP sits on every agent to agent, agent to tool and agent to API path, with no side doors.
  • Every tool has an effect class; helpers inherit the worst effect they can reach; unclassified tools are denied.
  • Policies see task history and taint, fail closed, and are versioned and tested against traces.
  • Untrusted content, other agents' outputs and tool results are inspected before they influence an action.
  • Tool arguments are validated; egress is allow listed; volume ceilings apply per agent and per task.
  • No agent holds the lethal trio; reused agents are re-scoped per caller; access drift is reviewed monthly.
  • Audit events follow a fixed schema, are hash chained, append only, outside agent control, and reach the SIEM.
  • A guardian reviews high-risk actions and its verdicts are enforced by the PDP.
  • Human approval sits at the effect, bound to arguments, single use, showing the full chain.
  • Composition tests gate every release that changes an agent, tool, prompt or model.

Frequently asked questions

Is Fenwick Row real? No. It is a hypothetical. The company, agents, log lines, timeline and figures are invented, and no real product's behaviour is described.

Is this a problem with the models? Not primarily. Model-level safety is one useful layer and does what it can with the context it is given. The failures here come from wiring: standing credentials, missing identity, policy in the wrong place and logs that cannot be joined. That applies to teams building on Claude from Anthropic and on every other model alike.

Do we need all eight layers before we ship? You need enough that no chain reaches a high-risk effect without a policy decision and, where appropriate, a human. On day one that means per-agent identity, a PEP at the tool boundary and effect-bound approval on the riskiest actions, with the rest on a dated plan.

Does a policy check on every call slow agents down? A nearby policy decision typically adds milliseconds. Keep guardian review and human approval for the small share of high-risk effects.

How does this relate to MCP? MCP standardises how agents discover and call tools, and its authorization specification builds on OAuth, which gives you a place for scoped tokens. A proxy in front of MCP servers is a natural PEP.

What is the single fastest improvement? Kill shared agent keys and propagate one task_id everywhere. That alone turns "we cannot tell what happened" into "we can see exactly what happened."

Sources

  • Norm Hardy, "The Confused Deputy (or why capabilities might have been invented)," ACM SIGOPS Operating Systems Review, 1988.
  • Jerome H. Saltzer and Michael D. Schroeder, "The Protection of Information in Computer Systems," Proceedings of the IEEE, 1975.
  • IETF RFC 8693, OAuth 2.0 Token Exchange, 2020.
  • IETF RFC 8707, Resource Indicators for OAuth 2.0, 2020.
  • IETF RFC 6962, Certificate Transparency, 2013.
  • Bruce Schneier and John Kelsey, "Secure Audit Logs to Support Computer Forensics," ACM Transactions on Information and System Security, 1999.
  • Scott A. Crosby and Dan S. Wallach, "Efficient Data Structures for Tamper-Evident Logging," USENIX Security Symposium, 2009.
  • Kai Greshake and others, "Not what you've signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection," 2023, arXiv:2302.12173.
  • OWASP Top 10 for Large Language Model Applications, 2025 edition (LLM06, Excessive Agency).
  • OWASP GenAI Security Project, "Agentic AI: Threats and Mitigations," 2025.
  • NIST AI 100-1, Artificial Intelligence Risk Management Framework (AI RMF 1.0), 2023.
  • NIST SP 800-207, Zero Trust Architecture, 2020.
  • SPIFFE, Secure Production Identity Framework for Everyone, spiffe.io.
  • W3C Trace Context Recommendation; OpenTelemetry specification.
  • Model Context Protocol specification, Authorization section, modelcontextprotocol.io.
  • Regulation (EU) 2024/1689 (EU AI Act), Article 14, Human oversight.

Never miss an update

Weekly insights on software supply chain security, delivered to your inbox.

We email you a link to confirm, and only then add you to the list. Unsubscribe in one click. Privacy

Self-healing security runs on Safeguard.

Your first fix PR is minutes away.

No sales call required, even your agent can complete the purchase over MCP.