Attack pattern

Multi-Agent Prompt Injection

How influenced content propagates across agent boundaries, why an authenticated agent message is not instruction authority, and how delegation and per-hop authorization break the chain.

By Norbert HofmannPublished: 2026-09-20Last reviewed: 2026-09-20Level: AdvancedAudience: Security Engineers, Developers, AI Engineers
Entry paths
Direct and indirect
Distinctive property
Propagation across agent boundaries
Level
Advanced
OWASP
LLM01:2026, LLM03:2026, ASI07
Table of contents

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.

What changes when a second agent is involved
AspectSingle agentMultiple agents
EntryDirect or indirectDirect or indirect, unchanged
Number of context assembliesOne planner contextOne per agent that receives the content
Provenance riskLabel may be dropped onceLabel may be dropped at every hop
Authority riskModel output mistaken for instructionPeer output additionally mistaken for delegated authority
Capability reachThe agent's own capabilitiesThe union of what each reachable agent can do, if delegation is not constrained
Gates requiredOne per actionOne 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

Related classes and how they differ
ClassDefining mechanismRelationship to this topic
Insecure Inter-Agent Communication (ASI07)Messages between agents lack authenticity, integrity or semantic validationThe boundary on which propagation happens; not identical with injection
Identity and Privilege Abuse (ASI03)Agent identity, delegation or entitlements are misusedEnabling weakness that decides how damaging propagation becomes
Memory and Context Poisoning (ASI06)Durable state carries adversarial content into later tasksOne of the propagation surfaces, and a distinct class in its own right
Cascading Failures (ASI08)One faulty component drives further failures through the systemThe systemic effect pattern, which injection can trigger but does not define
Tool Output InjectionContent returned by a tool influences the next stepThe same response-side problem one layer below the agent edge
AI Agent Prompt InjectionInfluence inside one agent loop leads to plans and actionsThe single-agent baseline this article builds on
Compromised agent or componentThe component itself is subvertedA different threat: the peer is untrustworthy, not merely influenced
Excessive Agency (LLM03:2026)Excessive functionality, permissions or autonomyDesign 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

From initiating principal to cross-agent effect
Variable trustInitiating Principal
SystemOrchestrator / Policy
SystemDelegated Scope
SystemAgent A
UntrustedExternal Content
Variable trustAgent A Output / Message
Variable trustAgent B Context
Variable trustAgent B Plan Proposal
SystemEdge Re-Authorization
Variable trustAction Proposal
SystemDeterministic Authorization
SystemScoped Capability
SystemExecution
Variable trustEffect

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.

What an inter-agent message actually establishes
PropertyEstablished by the messageNot established by the message
Origin componentWhich agent produced it, if authenticatedWhich upstream sources contributed to its content
IntegrityThat the content was not altered in transitThat the content is correct or benign
Schema validityThat the structure matches the contractThat free-text fields carry trustworthy semantics
Task relationWhich task identifier it claimsThat the claimed scope was ever delegated
RecommendationWhat the peer proposesThat 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.

  1. 01
    Explicit

    Delegated scope is stated, not inferred from the fact that one agent can reach another.

  2. 02
    Task-bound

    The scope refers to the current task and intent, not to the callee in general.

  3. 03
    Non-amplifying

    A child receives at most a subset of the authority currently held for that task.

  4. 04
    Time-limited

    The delegation expires with the task or sooner, and is not reusable in later runs.

  5. 05
    Externally enforced

    The decision is made by a policy component outside the model, not by the wording of a message.

  6. 06
    Auditable

    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

01
FieldInitiating principal

The human or service identity that started the task, with on-behalf-of context intact.

02
FieldAgent identity

The distinct identity of each agent in the chain, with an accountable owner.

03
FieldDelegation ancestry

Which agent delegated to which, in which order, for this task.

04
FieldTask and intent

The task identifier and the stated purpose the delegation was granted for.

05
FieldSource provenance

Where the content in the message originated and how trustworthy that origin is.

06
FieldPolicy version

Which policy set was in effect when the decision was made.

07
FieldCapability grant

The exact scope handed to this hop, never an unbounded standing entitlement.

08
FieldExact-action parameters

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.

What does not follow from calling a peer
GivenDoes not implyCorrect handling
A is allowed to call BA may act on B's recommendationsRe-evaluate the recommendation under A's own policy
B is an approved internal agentB's downstream sources are trustedKeep provenance for content B forwarded
B returned a well-formed resultThe result is factually or semantically safeTreat free text as data regardless of structure
B is more privileged than AA may use B to reach what A cannotBind B's action to the requester's delegated scope
A trusts B and B trusts CA trusts CNo 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.

01Setup

A low-privilege research agent can only read public records; a privileged operations agent can modify internal records.

02Request

The research agent sends a task message asking the operations agent to correct a record it claims is inconsistent.

03Weak handling

The operations agent authorizes with its own identity because the message came from an internal peer.

04Correct handling

The operations agent authorizes against the initiating principal and the scope delegated for this task, and denies anything beyond it.

Propagation Surfaces Between Agents

01
SurfaceTask messages

Instructions, sub-goals and parameters sent from one agent to another.

02
SurfaceSub-agent returns

Results, findings and recommendations handed back to the caller.

03
SurfaceOrchestrator output

Consolidated plans or briefs distributed to several workers.

04
SurfaceShared memory

A common store that several agents read and write across tasks.

05
SurfaceSummaries

Condensed content where provenance is most often lost.

06
SurfaceBlackboards and message buses

Publish and subscribe surfaces where any participant can pick up content.

07
SurfaceTool results

Responses consumed by one agent and forwarded to another, covered in detail under tool output injection.

08
SurfaceIndex and RAG writes

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

How topology changes propagation
TopologyTypical propagation pathWhat to watch
Hierarchical supervisorParent distributes, children report backParent treating child reports as authoritative; parent authority leaking into children
Peer to peerDirect agent-to-agent callsAbsent central policy; each edge must decide independently
Blackboard or busOne write, many readersFan-out; a single influenced entry reaching many contexts
PipelineSequential handoffProvenance erosion across successive transformations
Recursive delegationAgents spawning further agentsDepth 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

  1. 01
    Influenceable edge exists

    An attacker or user can control content that some agent in the system will consult.

  2. 02
    Content enters agent A context

    The material becomes model-visible for the first agent.

  3. 03
    Agent A output is influenced

    A message, summary or recommendation measurably reflects the injected content.

  4. 04
    Content crosses the edge

    The influenced output is transmitted to another agent through a propagation surface.

  5. 05
    Agent B treats it as authority

    The receiving agent lacks provenance or classifies the content as an instruction rather than data.

  6. 06
    Relevant capability is reachable

    Agent B holds or can request a capability that could produce the intended effect.

  7. 07
    Proposal reaches authorization

    A concrete action with resource and parameters is submitted for a decision.

  8. 08
    Delegation or policy fails

    The scope was over-broad, not re-checked, or no rule covered the case.

  9. 09
    Effect 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

Constraints that cut cross-agent chains
ConstraintStage it affectsOutcome when it holds
Source not reachable for any agentIngestionNo exposure at all
Provenance retained across the edgeMessage handlingContent stays classified as data
Message schema separates control fields from free textMessage handlingExternally authored text cannot occupy control positions
Receiving agent not influencedPlanningNo cross-agent plan drift
Delegated scope excludes the requested actionDelegationProposal denied at the edge
Initiating principal lacks the permissionAuthorizationDenied regardless of which agent asks
Capability not issued for this taskCapabilityNo path to the effect
Destination or data class deniedInformation flowInfluence without a security-relevant effect
Downstream service re-authorizesExecutionThe call fails at the resource owner
Hop, fan-out, time or cost limitsLoopPropagation ends before an effect
Human approval bound to the exact actionApprovalExecution 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.

01Task

An operator asks the triage agent to prepare OPS-7310 for handling and hand it over if action is needed.

02External content

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.

03Context assembly

The comment enters the triage agent context with a provenance label: external, portal-submitted, not attributable to an authenticated employee.

04Cross-agent message

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.

05Edge handling

The operations agent receives the briefing as data with its provenance and delegation record, not as an instruction from a trusted component.

06Delegation check

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.

07Authorization decision

Both out-of-scope steps are denied deterministically, with policy version, resource and parameters recorded.

08Permitted work

The operations agent updates the status and summary of OPS-7310 only, and the change is reversible.

09Result

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

One agent edge, handled correctly
  1. 01
    Message arrives

    The transport layer establishes sender identity and integrity, and the message keeps its provenance and delegation record.

  2. 02
    Content is classified

    Free-text fields are treated as data; only system-generated control fields are read as control information.

  3. 03
    Delegated scope is checked

    The claimed task scope is compared with what was actually delegated for this task, not with what the sender asserts.

  4. 04
    Plan is formed

    The receiving agent produces a proposal, which is still only a proposal.

  5. 05
    Action is authorized

    A deterministic decision binds the concrete action, resource, target and parameters to the initiating principal and the current policy version.

  6. 06
    Effect 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.

Amplifying versus non-amplifying chains
PatternAmplifying, avoidNon-amplifying, prefer
Scope at each hopChild inherits the callee's full standing permissionsChild receives a subset of the delegated task scope
IdentityService identity replaces the initiating principalInitiating principal and on-behalf-of context are preserved
DurationDelegation outlives the taskDelegation expires with the task or sooner
ReuseThe same grant serves later runsEach task receives its own grant
DepthUnlimited recursive delegationBounded depth with an explicit limit
Blast radiusGrows with each hopStays 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

01
FieldCorrelation identifier

A single identifier spanning the whole task across all agents.

02
FieldDelegation identifier

An identifier per delegation edge, linking parent and child.

03
FieldInitiating principal

The identity that started the task, preserved at every hop.

04
FieldAgent identity per hop

Which agent acted, under which owner and version.

05
FieldDelegated scope

What was granted for this hop, and by whom.

06
FieldMessage identity and provenance

Which message carried which content, and where that content came from.

07
FieldReceiving classification

How the receiver labelled the content: data, control metadata or approved instruction.

08
FieldProposal

The plan or action proposed before any decision.

09
FieldAuthorization decision

Allow or deny, the rule applied and the policy version.

10
FieldCapability used

Scope or entitlement identifier, never the credential itself.

11
FieldExecuted effect

The operation performed and the downstream result.

12
FieldState write

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

Higher risk
  1. Shared Mixed Context
  2. Implicitly Trusted Peer Messages
  3. Broad Standing Delegation
  4. 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.

Stronger
  1. Provenance-Aware Context
  2. Signed Message with Delegation Record
  3. Content Classified as Data
  4. Edge Re-Authorization
  5. Task-Scoped Capability
  6. Exact-Action Approval
  7. Isolated Execution
  8. Downstream Re-Authorization
  9. 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.

Separate metrics with explicit denominators
MetricDenominatorWhat it measures
Agent-to-Agent Exposure RateControlled content items placed in reachable sourcesShare that became model-visible in at least one further agent
Propagation RateExposed cases in the first agentShare whose influence measurably crossed at least one agent edge
Delegation Scope Violation Proposal RateCross-agent proposals observedShare proposing something outside the delegated task scope
Policy Bypass RateProposals reaching an authorization decisionShare permitted although policy should have denied them
Unauthorized Action RateCases with an available out-of-scope action pathShare where such an action actually executed
Cross-Agent Containment RatePropagated cases with an available prohibited effect or action pathShare stopped or contained before a security-relevant effect
Detection RecallKnown injected test casesShare flagged by detection
False-Positive RateBenign control casesShare 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

  1. LLM01:2026 Prompt InjectionOWASP GenAI Security Project · GuidanceReviewed 2026-09-20
  2. LLM03:2026 Excessive AgencyOWASP GenAI Security Project · GuidanceReviewed 2026-09-20
  3. OWASP Top 10 for Agentic Applications 2026OWASP GenAI Security Project · GuidanceReviewed 2026-09-20
  4. AI agent shared responsibility modelMicrosoft Learn · GuidanceReviewed 2026-09-20
  5. Least privilege for AI agentsMicrosoft Learn · GuidanceReviewed 2026-09-20
  6. Adversarial Machine Learning: A Taxonomy and Terminology of Attacks and Mitigations, NIST AI 100-2e2025NIST · Standard · 2025-03Reviewed 2026-09-20
  7. Accelerating the Adoption of Software and AI Agent Identity Management (initial public draft, concept paper)NIST NCCoE · Technical documentation · 2026-02Reviewed 2026-09-20
  8. AI Research: Security and Resilience (program context)NIST · Technical documentationReviewed 2026-09-20
  9. Bounded Agents: Delegation Security for Multi-Agent AI SystemsarXiv · Research paperReviewed 2026-09-20
  10. Attesting Outputs and Delegation Ancestry in Multi-Agent AI SystemsarXiv · Research paperReviewed 2026-09-20
  11. When Prompts Control Robots: Prompt Injection Attacks in Multi-Agent Robotic SystemsarXiv · Research paperReviewed 2026-09-20
  12. AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM AgentsarXiv · Research paper · 2024-06Reviewed 2026-09-20