To prevent security issues in multi-agent systems, a Rust sidecar is suggested to validate delegations at the handoff between agents, ensuring that low privilege agents cannot delegate high privilege actions.
**The failure mode:** Agent A (low privilege) gets prompt-injected. Agent A passes instructions to Agent B (high privilege). Agent B executes because the request came from inside the system. This is the confused deputy attack applied to agentic pipelines. Most frameworks ignore it. I built a LangGraph demo showing this. LangGraph is useful here because it forces explicit state passing between nodes—you can see exactly where privilege inheritance happens. The scenario: an Intake Agent (local Llama, file-read only) parses a poisoned resume. Hidden text hijacks it to instruct an HR Admin Agent (Claude, has network access) to exfiltrate salary data. **The fix:** a Rust sidecar validates delegations at the handoff. When Intake tries to delegate `http.fetch` to HR Admin, the sidecar checks: does Intake have `http.fetch` to delegate? No—Intake only has `fs.read`. Delegation denied. **The math:** `delegated_scope ⊆ parent_scope`. If it fails, the handoff fails. Demo: [https://github.com/PredicateSystems/langgraph-poisoned-escalation-demo](https://github.com/PredicateSystems/langgraph-poisoned-escalation-demo) The insight: prompt sanitization is insufficient if execution privileges are inherited blindly. The security boundary needs to be at agent handoff, not input parsing. **How are others handling inter-agent trust in production?**