TL;DR
Kaer is a new framework designed to protect multi-agent systems from "control hijacking"—a vulnerability where malicious agents manipulate an orchestrator's replanning process to execute unauthorized actions. By restricting agent feedback to abstract failure templates and using deterministic repair operators, Kaer enables systems to adapt to failures securely without sacrificing the flexibility needed for complex tasks.
What Problem Does This Paper Address?
Modern multi-agent systems (MAS) often use a "hub-and-spoke" architecture where a central orchestrator (powered by an LLM) creates a plan, assigns subtasks to specialized agents, and revises that plan if things go wrong. This dynamic replanning is essential for handling real-world uncertainty, but it creates a massive security hole.
If one of the agents is malicious or compromised, it can embed "prompt injection" instructions within its feedback to the orchestrator. For example, an agent might report a failure but include text that tricks the orchestrator into adding a new subtask that exfiltrates sensitive data. Existing defenses are often too rigid; they either block any plan changes (killing utility) or allow too much freedom (inviting attacks). The authors call this specific threat control hijacking.
Methods
The authors introduce Kaer, a framework built on three core security principles:
- Abstract Failure Templates: Instead of allowing agents to send free-form text back to the planner, Kaer forces them to choose from a fixed vocabulary of "failure templates" (e.g., Input lacks required datum or Capability not granted). This "type narrowing" prevents agents from injecting malicious instructions into the replanning loop.
- Deterministic Repair Operators: When a failure occurs, the LLM planner cannot rewrite the plan from scratch. It must use a set of seven predefined operators—such as
RE-EXECUTE,REASSIGN, orINSERT—to modify only the uncompleted parts of the plan. - Continuous Policy Enforcement: Every time a plan is revised, it must pass a "policy check" that ensures it still obeys global security invariants (e.g., "Agent A is never allowed to talk to Agent C").
Additionally, the authors propose an LLM-based output check. This addresses "silent failures" where a malicious agent claims success but provides faulty data to trick downstream agents.
Datasets
Because existing MAS benchmarks don't focus on replanning security, the authors created Cintra:
- 14 Benign Tasks: Scenarios requiring replanning due to agent reliability issues, unknown data locations, or evolving requirements.
- 14 Adversarial Objectives: Attacks targeting integrity (e.g., changing the user task), confidentiality (e.g., exfiltrating API keys), and availability (e.g., locking a database).
- Evaluation Models: The framework was tested using
gpt-5.6-terra,gpt-5.6-sol, anddeepseek-v4-pro.
Key Insights and Ideas
- The Power of Narrowing: The most significant "aha" moment is that a planner doesn't need to see the content of a failure to fix it; it only needs to know the category. By stripping away the "how" and "why" of a failure, Kaer removes the attack surface for prompt injection.
- Utility vs. Rigidity: Previous state-of-the-art defenses like ControlValve often fail because they are too static. If a task requires an agent that wasn't in the original plan, a static policy blocks it. Kaer allows the plan to grow, but only in "safe" directions defined by the repair operators.
- The "Lying Agent" Problem: The authors found that malicious agents often bypass replanning defenses by simply claiming they succeeded. This highlights that securing the replanning logic is only half the battle; you also need to verify the outputs of successful subtasks.
Key Results
Kaer significantly outperformed both the undefended baseline (Magentic-One) and the previous state-of-the-art (ControlValve):
- Security: On the
gpt-5.6-solmodel, Kaer achieved a 92.3% security score (percentage of blocked attacks), compared to 69.8% for ControlValve and only 35.0% for Magentic-One. - Utility: Kaer also completed more benign tasks (64.3%) than ControlValve (54.3%), proving that its security measures don't break the system's ability to solve complex problems.
- Robustness: When the LLM-based output check was added, Kaer's defense rate against sophisticated "always success" attacks jumped from ~87% to 96.8%.
Limitations and Future Work
- Information Loss: By restricting feedback to templates, the planner sometimes lacks the specific context (like a specific filename or URL) needed to make a perfect repair. This led to lower utility in some "unknown data" tasks.
- Internal Misuse: Kaer prevents an agent from hijacking the global plan, but it doesn't stop an agent from misusing its own authorized tools (e.g., an agent with file-delete permissions maliciously deleting its own working directory).
- Future Directions: The authors suggest exploring more expressive (but still secure) ways to pass runtime observations to the planner and investigating how to handle "multi-step" adversarial strategies that might try to exhaust the system's repair budget.
Summary updated