Misleading the Planner through Deceptive Resumes: Registration-Time Injection in Centralized Multi-Agent Systems

Zhaofeng Yu, Haokai Ma, Dongyang Zhan, Hongli Zhang, Han Fang, Ee-Chien ChangarXiv 2026 · arXiv

TL;DR

Centralized multi-agent systems rely on a central LLM "planner" to orchestrate specialized worker agents based on their natural language descriptions. This paper uncovers a novel vulnerability called registration-time injection, where a single maliciously crafted worker description can covertly hijack the planner's logic—even if that malicious worker is never actually executed. To counter this, the authors introduce DescGuard, a non-intrusive defense that sanitizes free-form agent descriptions into strict, worker-scoped interfaces.

What Problem Does This Paper Address?

Modern Multi-Agent Systems (MAS) often use a hub-and-spoke architecture: a central "planner" LLM takes a user's request, breaks it down into subtasks, and assigns those subtasks to specialized "worker" agents (e.g., web surfers, file analyzers, code executors). To know which worker to choose, the planner reads a natural language description—essentially a resume—provided by each agent.

Fig. 2: Overview of the Centralized MAS. The planner takes the user request and descriptions of worker agents as inputs, and generates a plan to guide subtask execution.

The core security flaw is that these descriptions are authored by third parties (often fetched from public marketplaces) but are treated as trusted instructions by the planner. This creates a registration-time injection channel. Unlike typical runtime prompt injections that exploit user inputs or retrieved data, this attack plants a payload before any user instruction even arrives.

As shown in Figure 1, the malicious payload targets the planner itself. The corrupted logic then propagates through the generated plan to completely benign workers, causing them to execute a compromised plan while the malicious agent sits idly by.

Fig. 1: Description-mediated attack in centralized MAS.

Methods

The Attack Framework

The authors systematically designed eight description-manipulation attack strategies categorized across three planning dimensions:

  1. Task Structuring Attacks: Distorting how tasks are broken down. This includes under-decomposition (forcing independent tasks to merge, losing granularity), over-fragmentation (splitting simple tasks into endless loops), and dependency disruption (forcing redundant verification steps).
  2. Capability Grounding Attacks: Manipulating agent selection. Attackers can trick the planner into over-assigning tasks to an incompetent worker or completely excluding a vital benign worker from the plan.
  3. Subtask Specification Attacks: Altering the instructions embedded within subtasks. This includes overworking (forcing workers into exhaustive, unnecessary loops like visiting every single link on a search page) and intermediate output suppression (preventing workers from sharing file paths, blinding downstream agents).

The Defense: DescGuard

To close this channel, the authors propose DescGuard, a three-stage registration-time sanitization pipeline:

  • Emphasis Neutralization: Strips out surface-level formatting tricks (Markdown, excessive capitalization, punctuation anomalies) used to force LLM attention.
  • Interface-Field Extraction: Forces descriptions into a strict four-field software interface: Functionality, Input Specification, Output Specification, and Usage Constraints. Any text dictating how the planner should behave is discarded.
  • Worker-Scoped Restatement: Rewrites the text objectively so it only speaks for the agent being registered, eliminating unbounded capability claims.

To prevent the defense itself from being hijacked, DescGuard wraps untrusted text in randomly generated delimiters and utilizes independent LLM validators to verify each stage.

Datasets

The paper utilizes two primary data sources:

  • Marketplace Analysis Dataset: The authors scraped and analyzed 32,000 real-world agent descriptions from three major public platforms: OpenAI’s GPT Store, Coze, and Baidu Wenxin, to evaluate how real-world descriptions deviate from structured interfaces.
  • GAIA Benchmark: A complex, multi-step benchmark for autonomous agents used to evaluate the downstream execution impact of the attacks and the mitigation efficacy of DescGuard.

Key Insights and Ideas

  • The "Ghost" Agent: The most alarming finding is that the malicious worker does not need to be assigned a subtask or invoked to cause damage. Simply existing in the planner's context window is enough to corrupt the orchestration of other, completely benign workers.
  • Upstream Blindness: Traditional agent defenses (like sandboxing, runtime monitors, or permission controls) operate downstream during execution. Because registration-time injection corrupts the plan upstream, benign workers faithfully execute malicious instructions, rendering downstream defenses completely blind to the attack.
  • The Marketplace Style Problem: Over 23% of real-world marketplace descriptions contain content completely outside standard technical specifications (e.g., direct instructions addressed to the planner). This means an adversarial description doesn't look anomalous; it perfectly mimics the prevailing, unconstrained style of commercial marketplaces.

Key Results

  • Devastating Success Degradation: In capability grounding attacks (specifically Agent Exclusion), a single manipulated description dropped the system's task success rate on the GAIA benchmark from a baseline of 84.31% down to 37.25%.
  • Resource and Cost Inflation: Structural attacks like dependency disruption and subtask overworking inflated average token consumption and execution time by over 111%, effectively acting as a economic denial-of-service attack on LLM API costs.
  • DescGuard Efficacy: Implementing DescGuard successfully neutralized these attacks, restoring task success rates and resource metrics back to near-baseline levels without requiring any modifications to the underlying planner LLM or worker code.

Limitations and Future Work

  • Description-Implementation Mismatch: While DescGuard successfully strips out manipulative planning instructions, it cannot verify if an agent's factual claims are true (e.g., if an agent claims it can process Excel files but lacks the code to do so). The authors note that future work must combine this defense with active capability probing.
  • Adaptive Prompt Injections: If an attacker gains white-box access to the specific prompts used within DescGuard's extraction and validation pipeline, they could theoretically engineer highly sophisticated, adaptive injections designed to bypass the filter.

Summary updated

Abstract

A centralized LLM-based multi-agent system (MAS) extends its functionality by registering new worker agents, whose descriptions are read by the planner to decide how a task is decomposed, which worker executes each subtask, and what each subtask requires. Third-party descriptions are authored outside the system but trusted by the planner, creating a registration-time injection channel. The payload is planted before any user instruction arrives, targets the planner and propagates through the generated plan to benign workers, taking effect even when the crafted worker is never assigned a subtask or invoked. We define four worker-description fields: functionality, input specification, output specification, and usage constraints. Among 32,000 descriptions from three public agent marketplaces, most omit input specifications and usage constraints, while at least 23.35% contain content outside these fields. We construct eight description-manipulation attack strategies targeting task decomposition, capability grounding, and subtask specification, and evaluate them on GAIA. In the most severe cases, a single manipulated description reduces task success from 84.31% to 37.25%, or increases token consumption or execution time by over 111%, while the user objective remains unchanged and workers faithfully execute the resulting plan. These effects persist across two MAS implementations, six planner LLMs, four LLM evaluators, and the real-world descriptions from three marketplaces. We further propose DescGuard, a registration-time defense that retains only worker-scoped interface information before descriptions reach the planner. DescGuard restores the targeted planning metrics and downstream performance toward their baseline levels without modifying worker implementations, the planner, or the orchestration logic, and composes with existing isolation, permission-control, and runtime mechanisms.
BibTeX
@misc{yu2026misleading,
  author = {Zhaofeng Yu and Haokai Ma and Dongyang Zhan and Hongli Zhang and Han Fang and Ee-Chien Chang},
  title = {{Misleading the Planner through Deceptive Resumes: Registration-Time Injection in Centralized Multi-Agent Systems}},
  year = {2026},
  eprint = {2609.15516},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2609.15516},
}
Figure