What Is Multi-Agent Prompt Injection?
Multi-agent prompt injection describes what happens to injected influence once a system consists of several cooperating agents. One agent reads external content, summarises it, delegates a subtask, or returns a result, and that material becomes the input of another agent that has a different context, a different task framing and often a different set of capabilities.
The interesting property is not that a model can be influenced. That is already covered by indirect prompt injection and, for a single agent loop, by AI agent prompt injection. What is specific here is propagation: influence that entered at one place in the system can travel across agent boundaries, lose its provenance on the way and arrive somewhere with more reach than the point where it started.
Propagation, Not a Third Entry Variant
Entry into a multi-agent system is still direct or indirect. A user can supply competing instructions through an intended input channel, or external content can carry them in through a website, an email, a document, a retrieved passage, a repository file or a tool result. There is no separate third entry mode that only exists because more than one agent is involved.
| Aspect | Single agent | Multiple agents |
|---|---|---|
| Entry | Direct or indirect | Direct or indirect, unchanged |
| Number of context assemblies | One planner context | One per agent that receives the content |
| Provenance risk | Label may be dropped once | Label may be dropped at every hop |
| Authority risk | Model output mistaken for instruction | Peer output additionally mistaken for delegated authority |
| Capability reach | The agent's own capabilities | The union of what each reachable agent can do, if delegation is not constrained |
| Gates required | One per action | One per agent edge and one per action |
Treating this as propagation rather than as a new entry class keeps the analysis honest. The question to answer for a given system is not whether agents talk to each other, but which edges are influenceable, how far content actually travels, and which authority decision is made at each arrival point.
Scope and Neighbouring Classes
| Class | Defining mechanism | Relationship to this topic |
|---|---|---|
| Insecure Inter-Agent Communication (ASI07) | Messages between agents lack authenticity, integrity or semantic validation | The boundary on which propagation happens; not identical with injection |
| Identity and Privilege Abuse (ASI03) | Agent identity, delegation or entitlements are misused | Enabling weakness that decides how damaging propagation becomes |
| Memory and Context Poisoning (ASI06) | Durable state carries adversarial content into later tasks | One of the propagation surfaces, and a distinct class in its own right |
| Cascading Failures (ASI08) | One faulty component drives further failures through the system | The systemic effect pattern, which injection can trigger but does not define |
| Tool Output Injection | Content returned by a tool influences the next step | The same response-side problem one layer below the agent edge |
| AI Agent Prompt Injection | Influence inside one agent loop leads to plans and actions | The single-agent baseline this article builds on |
| Compromised agent or component | The component itself is subverted | A different threat: the peer is untrustworthy, not merely influenced |
| Excessive Agency (LLM03:2026) | Excessive functionality, permissions or autonomy | Design risk that converts an influenced proposal into a damaging action |
Insecure inter-agent communication deserves particular care. Signing, mutual authentication and schema validation address transport and message integrity. They do not decide whether the text inside a well-formed, correctly signed message should be allowed to steer another agent.
The Multi-Agent Pipeline and Its Trust Boundaries
Orchestrator, policy engine, authorization service and the agent runtimes are operator-controlled. External content is untrusted by default. Everything an agent produces from that content, including messages to peers, summaries and plan proposals, is variable: its security meaning depends entirely on how the receiving side classifies and gates it.
Inter-Agent Output Is Data by Default
When agent B receives a message from agent A, that message is an observation. It reports what another component produced; it does not report a verified fact, an authorized instruction or a sanctioned goal change. If agent A consulted external sources, its output inherits that exposure, and the receiving agent has no way to see which parts of the text originated where unless provenance travels with it.
| Property | Established by the message | Not established by the message |
|---|---|---|
| Origin component | Which agent produced it, if authenticated | Which upstream sources contributed to its content |
| Integrity | That the content was not altered in transit | That the content is correct or benign |
| Schema validity | That the structure matches the contract | That free-text fields carry trustworthy semantics |
| Task relation | Which task identifier it claims | That the claimed scope was ever delegated |
| Recommendation | What the peer proposes | That the proposal may be executed |
Microsoft's shared responsibility guidance for AI agents states the same point for orchestration: in multi-agent setups one agent's output becomes another agent's instruction, which creates a new trust boundary, and agent, tool and retrieval outputs should be treated as untrusted with actions gated accordingly.
Authentication Is Not Instruction Authority
Mutual TLS, signed envelopes, workload identity and a registry of approved agents are valuable. They establish who sent a message and that it arrived intact. None of them establishes that the sender was entitled to expand the task, that the content inside is free of external influence, or that the receiver may act on it.
The failure pattern to avoid is an implicit rule of the form "internal message, therefore trusted input". Internal origin is a property of the transport path, not a property of the text. Research on output attestation and delegation ancestry explores cryptographic evidence for where an output came from and which delegation chain produced it; that evidence strengthens accountability and forensics, but attestation of an output does not prevent the output from having been influenced in the first place.
Delegation Is an Authorization Problem
The security question in a multi-agent system is rarely "can these agents talk". It is "what may a called agent do because it was called". Delegation is the mechanism by which authority moves, and it needs the same rigour as any other authorization decision.
- 01Explicit
Delegated scope is stated, not inferred from the fact that one agent can reach another.
- 02Task-bound
The scope refers to the current task and intent, not to the callee in general.
- 03Non-amplifying
A child receives at most a subset of the authority currently held for that task.
- 04Time-limited
The delegation expires with the task or sooner, and is not reusable in later runs.
- 05Externally enforced
The decision is made by a policy component outside the model, not by the wording of a message.
- 06Auditable
Who delegated what to whom, for which task and under which policy version, is recorded.
The Zero Trust guidance for least privilege with AI agents describes the operational side of this: revalidate identity, role and scope at every hop, preserve on-behalf-of context, issue task-scoped and just-in-time permissions, require downstream authorization, and keep the decisions auditable. Research on bounded delegation in multi-agent systems argues for the same direction conceptually, with delegated scope, accumulated session state and external authorization as the design primitives; those are research proposals, not settled standards.
Context That Must Survive Every Hop
The human or service identity that started the task, with on-behalf-of context intact.
The distinct identity of each agent in the chain, with an accountable owner.
Which agent delegated to which, in which order, for this task.
The task identifier and the stated purpose the delegation was granted for.
Where the content in the message originated and how trustworthy that origin is.
Which policy set was in effect when the decision was made.
The exact scope handed to this hop, never an unbounded standing entitlement.
The concrete action, resource, target and arguments a decision refers to.
Most practical failures are losses of this context rather than dramatic breaks. A summary drops the source label; a message bus carries only the text; a nested call replaces the initiating principal with a service account. After two or three such losses, a downstream authorization decision is made on information that no longer describes the real request.
Trust Transitivity Must Fail Closed
That agent A may call agent B says something about the call graph. It says nothing about B's data. Trust in a component and trust in the content that component returns are different relations, and the second must not be derived from the first.
| Given | Does not imply | Correct handling |
|---|---|---|
| A is allowed to call B | A may act on B's recommendations | Re-evaluate the recommendation under A's own policy |
| B is an approved internal agent | B's downstream sources are trusted | Keep provenance for content B forwarded |
| B returned a well-formed result | The result is factually or semantically safe | Treat free text as data regardless of structure |
| B is more privileged than A | A may use B to reach what A cannot | Bind B's action to the requester's delegated scope |
| A trusts B and B trusts C | A trusts C | No transitive trust; each edge is decided on its own |
Fail-closed means that when the receiving side cannot determine provenance, delegated scope or intended authority, the content is handled as untrusted data and the requested action is denied rather than allowed by default.
Confused Deputy and Over-Broad Delegation
The classic confused-deputy shape appears clearly in agent systems: a more-privileged agent performs an action on behalf of a less-privileged requester without checking whether the requester was ever entitled to that action. The privileged agent is not compromised. It is simply being used as an instrument.
A low-privilege research agent can only read public records; a privileged operations agent can modify internal records.
The research agent sends a task message asking the operations agent to correct a record it claims is inconsistent.
The operations agent authorizes with its own identity because the message came from an internal peer.
The operations agent authorizes against the initiating principal and the scope delegated for this task, and denies anything beyond it.
Propagation Surfaces Between Agents
Instructions, sub-goals and parameters sent from one agent to another.
Results, findings and recommendations handed back to the caller.
Consolidated plans or briefs distributed to several workers.
A common store that several agents read and write across tasks.
Condensed content where provenance is most often lost.
Publish and subscribe surfaces where any participant can pick up content.
Responses consumed by one agent and forwarded to another, covered in detail under tool output injection.
Content written back into a retrievable store and later served to a different agent or task.
Each surface should have an owner, a schema, a provenance contract and a stated trust level. A surface that any agent may write and any agent may read without labels is the most efficient propagation path a system can offer.
Orchestration Topologies and Reach
| Topology | Typical propagation path | What to watch |
|---|---|---|
| Hierarchical supervisor | Parent distributes, children report back | Parent treating child reports as authoritative; parent authority leaking into children |
| Peer to peer | Direct agent-to-agent calls | Absent central policy; each edge must decide independently |
| Blackboard or bus | One write, many readers | Fan-out; a single influenced entry reaching many contexts |
| Pipeline | Sequential handoff | Provenance erosion across successive transformations |
| Recursive delegation | Agents spawning further agents | Depth without limits; authority drift and loop risk |
Topology does not determine whether influence occurs, but it determines how many contexts one influenced item can reach and how many independent decision points stand between that item and an effect.
Cross-Agent Contamination of Derived State
Derived state is where multi-agent propagation becomes durable. A summary written by one agent, a note placed in shared memory, an entry added to an index or a status written to a ticket can be read much later by a different agent, for a different user, in a different task.
Containment for shared state
- Record lineage for every write: which agent, which task, which source content
- Isolate state per tenant, user and task wherever the data model allows it
- Do not let a summary silently replace the provenance of the content it condenses
- Require review before externally influenced content becomes durable shared memory
- Support targeted invalidation and rebuild of derived state per source
- Expire working state with the task instead of carrying it into unrelated runs
This overlaps with memory and context poisoning, which is its own class with its own controls. The multi-agent aspect is that the writer and the reader are different components with different privileges, so contamination can also move authority-relevant framing, not just content.
The Multi-Agent Success Chain
- 01Influenceable edge exists
An attacker or user can control content that some agent in the system will consult.
- 02Content enters agent A context
The material becomes model-visible for the first agent.
- 03Agent A output is influenced
A message, summary or recommendation measurably reflects the injected content.
- 04Content crosses the edge
The influenced output is transmitted to another agent through a propagation surface.
- 05Agent B treats it as authority
The receiving agent lacks provenance or classifies the content as an instruction rather than data.
- 06Relevant capability is reachable
Agent B holds or can request a capability that could produce the intended effect.
- 07Proposal reaches authorization
A concrete action with resource and parameters is submitted for a decision.
- 08Delegation or policy fails
The scope was over-broad, not re-checked, or no rule covered the case.
- 09Effect occurs
An unauthorized access, modification, transmission or persistent change actually happens.
Every hop repeats the later stages. A chain can therefore be cut many times over, and in a well-built system it usually is.
Competing Constraints Across Hops
| Constraint | Stage it affects | Outcome when it holds |
|---|---|---|
| Source not reachable for any agent | Ingestion | No exposure at all |
| Provenance retained across the edge | Message handling | Content stays classified as data |
| Message schema separates control fields from free text | Message handling | Externally authored text cannot occupy control positions |
| Receiving agent not influenced | Planning | No cross-agent plan drift |
| Delegated scope excludes the requested action | Delegation | Proposal denied at the edge |
| Initiating principal lacks the permission | Authorization | Denied regardless of which agent asks |
| Capability not issued for this task | Capability | No path to the effect |
| Destination or data class denied | Information flow | Influence without a security-relevant effect |
| Downstream service re-authorizes | Execution | The call fails at the resource owner |
| Hop, fan-out, time or cost limits | Loop | Propagation ends before an effect |
| Human approval bound to the exact action | Approval | Execution stops at the oversight gate |
Early constraints can mean there was never any model exposure; late ones mean influence is observable while no security-relevant effect occurs. Recording which constraint held, and at which hop, is the actual result of an assessment.
Authorized Offensive Assessment
Multi-agent testing belongs in an authorized engagement with written scope, bounded permissions or a non-production environment, synthetic data and reversible effects. The goal is to map edges and gates, not to prove that a language model can be influenced.
Questions that structure the assessment
- Which agent edges can be influenced from a legitimately controllable surface?
- How many hops does influenced content travel before it stops or is relabelled?
- Is provenance preserved across each edge, or lost in a summary or transformation?
- Is the initiating principal preserved, or replaced by a service identity somewhere in the chain?
- Which capabilities become reachable only after delegation to another agent?
- Can a less-privileged agent cause a more-privileged one to act beyond the delegated scope?
- Is each edge re-authorized, or does an earlier approval carry the whole workflow?
- Do shared memory, buses or indexes carry content into unrelated tasks?
- Which gate stopped the chain, and is that gate deterministic?
Worked Scenario
A synthetic support organisation runs two agents. A triage agent reads incoming issues, including comments submitted through a public portal, and may hand a structured briefing to an operations agent. The operations agent may update the status and summary of the one ticket named in the briefing. Neither agent may read unrelated customer records, and neither holds an outbound messaging tool.
An operator asks the triage agent to prepare OPS-7310 for handling and hand it over if action is needed.
A portal comment contains narrative text framing an unrelated account as part of the same case and suggesting that a summary be forwarded outside the organisation.
The comment enters the triage agent context with a provenance label: external, portal-submitted, not attributable to an authenticated employee.
The briefing produced for the operations agent now mentions the unrelated account and a forwarding step. Influence has crossed the agent edge and is logged as such.
The operations agent receives the briefing as data with its provenance and delegation record, not as an instruction from a trusted component.
The delegated scope for this task covers exactly one ticket identifier and the status and summary fields. The additional record and the forwarding step lie outside it.
Both out-of-scope steps are denied deterministically, with policy version, resource and parameters recorded.
The operations agent updates the status and summary of OPS-7310 only, and the change is reversible.
Deepest observed gate: delegation and action authorization. Cross-agent propagation and plan influence observed; no unauthorized action, no data exposure, no durable contamination.
Re-Authorization at Every Edge
- 01Message arrives
The transport layer establishes sender identity and integrity, and the message keeps its provenance and delegation record.
- 02Content is classified
Free-text fields are treated as data; only system-generated control fields are read as control information.
- 03Delegated scope is checked
The claimed task scope is compared with what was actually delegated for this task, not with what the sender asserts.
- 04Plan is formed
The receiving agent produces a proposal, which is still only a proposal.
- 05Action is authorized
A deterministic decision binds the concrete action, resource, target and parameters to the initiating principal and the current policy version.
- 06Effect and logging
The permitted operation executes and the decision, parameters and outcome are recorded with correlation and delegation identifiers.
An authenticated message never transfers authority on its own, and an approval given earlier in a workflow is not an approval for a later, differently parameterised action. If parameters, target or the underlying state change between decision and execution, the decision must be made again.
Downstream Authorization and Credentials
The resource owner is the last place where the request can be judged against reality. A downstream service that accepts a call because the orchestrator approved it has effectively delegated its access control to a component that does not know its data model.
Downstream expectations
- Every called service authorizes independently, on the initiating principal and the task scope
- No broad bearer-style credentials shared across agents or tasks
- Short-lived, task-scoped entitlements instead of standing access in the agent context
- Authority may narrow along the chain, never widen
- Destination allowlists and data-class rules for every outbound action
- Immediate revocation of tokens, delegations and sessions, with a working kill switch
Monotonic, Non-Amplifying Delegation
A delegation chain should be monotonic in the direction of narrowing. Each hop may hand on a subset of the authority currently held for the task, and never more. Being delegated to is not itself a reason to hold more.
| Pattern | Amplifying, avoid | Non-amplifying, prefer |
|---|---|---|
| Scope at each hop | Child inherits the callee's full standing permissions | Child receives a subset of the delegated task scope |
| Identity | Service identity replaces the initiating principal | Initiating principal and on-behalf-of context are preserved |
| Duration | Delegation outlives the task | Delegation expires with the task or sooner |
| Reuse | The same grant serves later runs | Each task receives its own grant |
| Depth | Unlimited recursive delegation | Bounded depth with an explicit limit |
| Blast radius | Grows with each hop | Stays at or below the parent's task authority |
Research on bounded delegation for multi-agent systems formalises this as keeping the blast radius non-amplifying across delegation, together with external authorization and explicit handling of accumulated session state. That is a research design direction rather than an established standard, and it is cited here as such.
Loop, Cascade and Fan-Out Containment
Multi-agent systems fail in patterns single agents do not: two agents reinforcing each other's conclusions, a briefing that fans out to many workers, a delegation cycle that never terminates, a faulty result that propagates through every dependent task.
Containment controls
- Maximum hop and delegation depth per task, enforced outside the model
- Fan-out limits for broadcast and blackboard surfaces
- Cycle detection on the delegation graph, with termination on repeat
- Step, time and cost budgets per run, shared across the whole agent group
- Circuit breaking when denied proposals or error rates rise within a run
- Isolation of derived state so a contaminated artifact does not seed the next task
OWASP's agentic risk list treats cascading failures as its own concern for good reason: the damage pattern can arise from an ordinary fault as easily as from an injection, and the containment controls are the same either way.
Detection and Telemetry
A single identifier spanning the whole task across all agents.
An identifier per delegation edge, linking parent and child.
The identity that started the task, preserved at every hop.
Which agent acted, under which owner and version.
What was granted for this hop, and by whom.
Which message carried which content, and where that content came from.
How the receiver labelled the content: data, control metadata or approved instruction.
The plan or action proposed before any decision.
Allow or deny, the rule applied and the policy version.
Scope or entitlement identifier, never the credential itself.
The operation performed and the downstream result.
Any shared memory, summary or index write, with lineage.
Useful signals include content appearing in an agent that never had a legitimate reason to see it, goal or scope drift after a handoff, an unexpected new delegation edge, repeated denied cross-agent proposals, a proposal that does not match the executed operation, growing fan-out within one task, and writes to shared state from agents that normally only read.
Defensive Architecture
- Shared Mixed Context
- Implicitly Trusted Peer Messages
- Broad Standing Delegation
- Direct Cross-Agent Execution
Agents share an unlabelled context and memory, internal messages are treated as authoritative, delegation grants whole tool families for the session, and a peer request leads directly to execution.
- Provenance-Aware Context
- Signed Message with Delegation Record
- Content Classified as Data
- Edge Re-Authorization
- Task-Scoped Capability
- Exact-Action Approval
- Isolated Execution
- Downstream Re-Authorization
- Logged Effect
Content keeps its origin across hops, messages carry identity and delegation evidence, free text stays data, each edge and each consequential action is decided deterministically, capabilities are issued per task, and the resource owner authorizes again.
The additional controls that matter most between agents are message schemas that separate system control fields from externally authored text, per-edge policy rather than one global allowance, memory isolation between agents and tasks, sandboxed execution without standing credentials, egress control, and the loop and fan-out limits described above.
Controlled Testing and Metrics
Each metric needs its own explicit denominator and must be reported separately. A composite cross-agent score hides which edge leaked and which gate held, and makes results incomparable between architectures.
| Metric | Denominator | What it measures |
|---|---|---|
| Agent-to-Agent Exposure Rate | Controlled content items placed in reachable sources | Share that became model-visible in at least one further agent |
| Propagation Rate | Exposed cases in the first agent | Share whose influence measurably crossed at least one agent edge |
| Delegation Scope Violation Proposal Rate | Cross-agent proposals observed | Share proposing something outside the delegated task scope |
| Policy Bypass Rate | Proposals reaching an authorization decision | Share permitted although policy should have denied them |
| Unauthorized Action Rate | Cases with an available out-of-scope action path | Share where such an action actually executed |
| Cross-Agent Containment Rate | Propagated cases with an available prohibited effect or action path | Share stopped or contained before a security-relevant effect |
| Detection Recall | Known injected test cases | Share flagged by detection |
| False-Positive Rate | Benign control cases | Share incorrectly flagged |
Benign task utility belongs alongside these as a separate dimension, never merged into them: a system that blocks every handoff scores perfectly on containment and fails at its purpose. Without that separate measurement, a control can look strong simply because it prevents useful work.
Incident Response
Responding to a suspected cross-agent injection
- Pause or revoke the acting capability of the affected agents before analysis, keeping read-only evidence access
- Preserve the full chain: correlation and delegation identifiers, messages, proposals and decisions
- Record which identities, delegations, scopes and policy versions were in effect at each hop
- Reconstruct where the content entered and how many edges it crossed
- Identify every shared memory, summary, index or downstream record written during the run
- Distinguish influence, propagation, proposal, execution and data exposure explicitly in the timeline
- Revoke or rotate delegations and credentials based on evidence of use, not on suspicion alone
- Invalidate and rebuild derived state that originated from the affected content, including in other agents
- Retest the edge or gate that failed with the same controlled case
- Record the deepest gate reached and the actual effect in the final report
Classification discipline matters more here than in a single-agent case, because a chain produces many intermediate states. An influenced briefing, a denied cross-agent proposal and an executed out-of-scope action are three different outcomes with three different remediations.
Standards and Research Context
Reference frameworks
- OWASP
- LLM01:2026 Prompt Injection, LLM03:2026 Excessive Agency, Top 10 for Agentic Applications 2026 (ASI03, ASI06, ASI07, ASI08)
- NIST
- AI 100-2e2025 terminology, NCCoE 2026 concept paper (draft), AI research, security and resilience program context
- Microsoft
- AI agent shared responsibility model, Least privilege for AI agents
OWASP LLM01:2026 defines prompt injection as the mechanism by which inputs alter model behaviour, and LLM03:2026 describes excessive agency as the enabling design risk. The OWASP Top 10 for Agentic Applications 2026 provides the agent-specific classes used here: insecure inter-agent communication as the boundary, identity and privilege abuse as the amplifier, memory and context poisoning as a propagation surface with its own controls, and cascading failures as the systemic effect pattern. NIST AI 100-2e2025 supplies the terminology for prompt injection and adversarial machine learning.
The Microsoft shared responsibility model for AI agents is the clearest published statement of the core idea in this article: in multi-agent orchestration one agent's output becomes another agent's instruction, which creates a new trust boundary, so agent, tool and retrieval outputs are treated as untrusted and actions are gated. The Zero Trust guidance on least privilege for AI agents adds the operational expectations: revalidate identity, role and scope at every hop, preserve on-behalf-of context, grant task-scoped and just-in-time authority, require downstream authorization and keep the chain auditable. These are product-level recommendations and are cited as such.
Two NIST items describe direction rather than settled requirements. The 2026 NCCoE concept paper on accelerating adoption of software and AI agent identity is an initial public draft whose comment period has closed; it addresses identity, authentication, authorization, delegation and on-behalf-of context, auditing and non-repudiation, and prompt-injection mitigation. The NIST programme page on AI research, security and resilience states that control-overlay work covering single-agent and multi-agent systems is under development. Neither should be read as completed guidance.
On the research side, work on bounded delegation for multi-agent systems develops delegated scope, accumulated session state, external authorization and non-amplifying blast radius as design concepts; work on attesting outputs and delegation ancestry explores cryptographic evidence for output origin and delegation chains, which supports accountability without preventing injection; and a study of prompt injection in multi-agent robotic systems reports empirical cross-agent propagation in that specific domain, which should not be generalised to other architectures. All three are research contributions, not standards. Related site material covers the single-agent loop under AI agent prompt injection, the response side of a tool call under tool output injection, retrieval paths under RAG prompt injection, and the control architecture in the defense area.
Frequently Asked Questions
Is multi-agent prompt injection its own attack class?
It is best understood as propagation of the same mechanism. Entry remains direct or indirect; what is specific is that influence crosses agent boundaries and may arrive where more capability is reachable.
If a message between agents is authenticated, can it be trusted?
Authentication establishes the sender and the integrity of the message. It says nothing about whether the content was influenced by external sources or whether the sender was delegated the scope it claims.
Is an influenced sub-agent already an incident?
Classification depends on organizational policy, and some organizations treat observable influence as a reportable event. Influence alone does not establish unauthorized action or data exposure. Report the deepest gate observed and the actual effect.
Is this the same as insecure inter-agent communication?
No. Insecure inter-agent communication is about authenticity, integrity and validation of the channel and messages. Prompt injection is about the content inside them. A perfectly secured channel can still carry externally influenced text.
Can delegation grant more authority than the parent holds?
It must not. A child should receive at most a subset of the authority currently delegated for the task. Any design where calling a peer increases reach is an amplification path and should be treated as a finding.
If the orchestrator approved the task, is per-edge authorization still needed?
Yes. An approval for a task is not an approval for each later action with different parameters or targets, and the resource owner must authorize independently of the orchestration layer.
Is this the same as memory poisoning?
They overlap but are distinct. Shared memory is one propagation surface among several, and memory and context poisoning is its own class with its own controls for lineage, isolation and invalidation.
How is propagation measured?
With separate rates and explicit denominators: how much controlled content became visible to a further agent, how much of that measurably crossed an edge, how many cross-agent proposals exceeded the delegated scope, and how many were contained before an effect.
Do guardrails between agents solve the problem?
No. Message classifiers are probabilistic and produce false positives and negatives. They are useful signals for triage, but the decisive control is deterministic authorization bound to the concrete action.
What should be reported after a contained cross-agent proposal?
Both facts: that influence propagated across an agent boundary, and that the delegation or policy layer denied the resulting proposal, including which gate decided and under which policy version.
References
- LLM01:2026 Prompt InjectionOWASP GenAI Security Project · GuidanceReviewed 2026-09-20
- LLM03:2026 Excessive AgencyOWASP GenAI Security Project · GuidanceReviewed 2026-09-20
- OWASP Top 10 for Agentic Applications 2026OWASP GenAI Security Project · GuidanceReviewed 2026-09-20
- AI agent shared responsibility modelMicrosoft Learn · GuidanceReviewed 2026-09-20
- Least privilege for AI agentsMicrosoft Learn · GuidanceReviewed 2026-09-20
- Adversarial Machine Learning: A Taxonomy and Terminology of Attacks and Mitigations, NIST AI 100-2e2025NIST · Standard · 2025-03Reviewed 2026-09-20
- Accelerating the Adoption of Software and AI Agent Identity Management (initial public draft, concept paper)NIST NCCoE · Technical documentation · 2026-02Reviewed 2026-09-20
- AI Research: Security and Resilience (program context)NIST · Technical documentationReviewed 2026-09-20
- Bounded Agents: Delegation Security for Multi-Agent AI SystemsarXiv · Research paperReviewed 2026-09-20
- Attesting Outputs and Delegation Ancestry in Multi-Agent AI SystemsarXiv · Research paperReviewed 2026-09-20
- When Prompts Control Robots: Prompt Injection Attacks in Multi-Agent Robotic SystemsarXiv · Research paperReviewed 2026-09-20
- AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM AgentsarXiv · Research paper · 2024-06Reviewed 2026-09-20