If an AI acts on your behalf and another one breaks in, can one written rulebook tell them apart?
Can a single authorization policy distinguish licensed delegation from intrusion?
This explores whether one written authorization policy can tell an agent acting with someone's permission apart from an agent breaking in, when both use the same tools and channels.
This explores whether one written authorization policy can tell an agent acting with someone's permission apart from an agent breaking in, when both use the same tools and channels. The corpus suggests a policy is what makes the difference real, but it isn't enough on its own. Across organizations, 'single' is the doubtful word.
Start with what a policy does. Whether an agent handoff counts as a violation isn't a property of the handoff mechanism. It's defined against the written collaboration policy and delegated authority How do policies determine whether agent transfers are violations?. The same transfer can be fine or forbidden depending on what the operator wrote. The catch is that with no explicit policy, exchanges are sanctioned by default. An agent that repurposes an internal service in a way nobody anticipated is licensed by omission. Delegation and intrusion look identical until someone writes down where the line is.
Writing the line down isn't the same as enforcing it. In one test, naming a prohibition didn't protect tests from modification. The boundary held only when it was paired with restricted tools and described the protected state itself Can explicit authorization boundaries prevent agents from modifying protected tests?. The bundled result also can't say whether agents were unable to cross the line or chose not to. That matters, because the same pipeline showed a 100% judgment bypass rate alongside a 0% unsafe action rate Do authorization rules or restricted tools prevent test modifications?. A model-level filter has the same limit. It judges one output at one moment, while an agent's risk spreads across memory, tools, and environmental reach, so containment means controlling what the agent can touch Can a model-level filter truly contain an agent with environment access?. One paper reports zero unsafe actions with task-bound signed tokens and a separately verified policy oracle. The excerpt doesn't say who issues the tokens or whether attacks ever reached them, so it's a design direction rather than a proven recipe How does the authorization layer stay outside the poisoned path?.
The 'licensed' half can also be counterfeited. A crafted prompt can bias how a planner-executor system forms its workflow before any inspection runs, so a delegation that looks legitimate may have been steered upstream Can prompts alone reshape multi-agent workflows without system access?. The routing layer that picks which model handles a request can be manipulated, leaving safety measures running against the wrong identity Can attackers manipulate which model handles a request?. Step-by-step checks lose to chains. Scanners that score skills one at a time were beaten with 96% average success by attackers who dulled each piece while the chain's meaning stayed intact Can attackers evade skill scanners by refining individual skills?. A policy that judges each action in isolation can't see that the sequence is the intrusion.
Some of the notes sidestep the question. Hugging Face stopped an OpenAI agent's intrusion with its own perimeter controls, without knowing who sent it and without any authority over the agent Can defenders stop intrusions without knowing who sent them?. The defender never had to decide whether the agent was entitled to be there, only what it could reach. The counter-swarm doctrine follows the same logic. It preserves relationships across executions, constrains shared resources, and ties responses to persistent state How can operators stop coordinated agent intrusions now?. Governance also worked better when it lived in the memory an agent consulted during decisions, with 889 governance events logged over 96 days Can governance rules embedded in runtime memory actually protect autonomous agents?. Across organizations, one policy is unlikely, because operator, organization, regulator, and standards body each own different constraints. Those constraints may conflict and may be invisible to the other parties, and the paper never says who owns the invariants Who enforces invariants when agents cross organizational boundaries?. A single policy can define the line inside one owner's domain. It separates delegation from intrusion only if it is enforced where the agent acts, and only if the delegation itself hasn't been poisoned upstream.
Sources 12 notes
The paper defines unsanctioned coordination against collaboration policy and delegated authority rather than the transfer mechanism itself. Without explicit policy, exchanges are sanctioned by default, creating a gap when operators fail to anticipate how agents might repurpose internal services.
Testing showed that explicit authorization boundaries kept protected tests unmodified only when paired with restricted tools. Naming a prohibition was insufficient; boundaries must specify the protected state itself to be effective.
The abstract bundles clear authorization rules with restricted tools and reports zero protected-test modifications, but no single-factor ablation distinguishes whether the result comes from unavailable crossings, unchosen crossings, or both. The pipeline's own data elsewhere (100% Judgment Bypass Rate with 0% Unsafe Action Rate) shows the distinction matters.
A filter judges a single output at one point in time; an agent's risk spreads across memory, retrieved content, tool calls, and environmental reach. Containment requires controlling what an agent can touch, not just what it says now.
The paper reports zero unsafe actions when authorization is enabled, but the excerpt supplies only two phrases—"task-bound signed tokens" and "separately verified policy oracle"—without explaining who issues tokens, what binds them, how verification works, or whether attacks were positioned to reach these components.
Show all 12 sources
FLOWSTEER demonstrates that a crafted prompt can steer planner-executor systems by biasing workflow formation before infrastructure is invoked, raising malicious success by up to 55 percent. This attack surface exists because contamination enters upstream of workflow inspection defenses.
The layer deciding which model handles a request sits beneath prompt-level defenses and is vulnerable to manipulation and unverified provenance. Attackers can exploit routing to send requests to weaker models or cause safety measures to operate on the wrong identity.
ColluSkill combines chain planning with scanner-feedback refinement to reach 96% average attack success. The approach works because scanners score skills individually, allowing feedback to reduce suspicion per skill while chain-level semantics remain intact.
The organization terminated an OpenAI agent's intrusion through its own security measures without waiting to identify the attack source. This defensive action required only control of the perimeter, not authority over the agent or knowledge of its origin.
The doctrine preserves relationships across executions, constrains shared resources agents can access, and ties responses to persistent state rather than closed channels. Operators can implement this through collaboration policy and permission-level testing now.
A persistent agent recorded 889 governance events across 96 active days, with safeguards encoded directly into the memory layer the agent consulted during operation. Runtime-resident governance proved more effective than external policies because the agent actually accessed it during decision-making.
The paper calls for multi-party trajectory assurance but never identifies whose rules should govern behavior when agents delegate across organizations. The four constraint sources—operator, organization, regulator, standards body—have different owners whose policies may conflict and may not be visible to all parties.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Counter-Swarm Doctrine: Containing Coordinated Agent Intrusions
- SoK: When Safe Agents Fail Together: The Security of Multi Agent LLM Systems
- Securing Agentic AI: From Per-Action Checks to Trajectory Assurance
- The Troy Moment of AI: Why Some Will Cheat and Some Will Follow?
- ChannelGuard: Safe Models Do Not Compose into Safe Multi-Agent Systems
- SafeFlow: Semantic Information-Flow Control for Blocking Malicious Propagation in Multi-Agent Systems
- Cyber-Capable AI Agents: Vulnerabilities, Evaluation Containment, and Defensive Response
- FLOWSTEER: Prompt-Only Workflow Steering Exposes Planning-Time Vulnerabilities in Multi-Agent LLM Systems