Synapse-Control: Making Agent Experience Actionable with Lightweight Runtime Control

Zhiyuan Huang, Shengan Zheng, Chenghu Yang, Song Zhang, Lingyun Li, Chen Yu, Weiquan Huang, Linpeng HuangarXiv 2026 · arXiv

TL;DR

Synapse-Control is a lightweight runtime for LLM agents that makes experience reuse efficient by replacing expensive generative failure diagnosis with a fast 1.7B parameter classifier. By using "micro-contracts" to provide actionable guidance and a stateful "Prompt Value Table" to manage delivery, it improves task success by nearly 30% over unassisted agents while cutting auxiliary inference time in half compared to previous state-of-the-art systems.

What Problem Does This Paper Address?

Large Language Model (LLM) agents often struggle with complex, tool-based tasks where they must navigate APIs or web interfaces. To improve reliability, researchers have developed "experience reuse" systems that allow agents to learn from past failures.

However, existing systems like Sentry introduce a significant "computational tax." Before an agent can receive a helpful lesson, a large model must first examine the execution trajectory and generate a text-based diagnosis. As shown in Figure 2, this auxiliary work can add over 20% overhead to the total request time. The authors identify a gap: we need a way to connect agents with relevant experience without the high cost and latency of generative diagnosis.

Figure 2: Recovery requires both economical control and effective guidance. (a) Sentry’s actor request time is normalized to 100% within each benchmark; stacked segments show additional control work. (b) In the AppWorld development probe (342 attempts per condition), a larger actor-output cap increases Base completions but does not improve Sentry completions.

Methods

The core innovation of Synapse-Control is exploiting computational asymmetry: it is much cheaper to judge the suitability of a pre-retrieved suggestion than it is to generate a diagnosis from scratch.

The architecture (detailed in Figure 3) consists of three main components:

  1. Micro-contracts: Instead of storing entire task programs, the system uses "micro-contracts"—short, actionable statements of local constraints (e.g., "This API call requires a 'red' option to be selected"). This gives the agent concrete facts while leaving high-level planning to the actor.
  2. Lightweight Classifier: The system replaces the large generative "detector" with a fine-tuned 1.7B parameter classifier (Qwen-1.7B). It scores up to five candidate suggestions as Helpful, Irrelevant, or Harmful based on the current execution state.
  3. Prompt Value Table (PVT): This stateful component manages the "delivery" of hints. It tracks which suggestions were sent, monitors feedback (did the agent succeed after the hint?), and enforces token budgets and "cooldown" periods to prevent the system from nagging the agent with redundant advice.
Figure 3: Synapse-Control overview. Rules filter and prepare advice (§3.2), the classifier scores it (§3.1), and PVT decides when to send it (§3.3). Host verification and lesson updates remain active; hard repair is unchanged.

Datasets

The authors evaluated Synapse-Control on two primary benchmarks:

  • AppWorld: A complex environment for stateful API programming involving 168 distinct tasks.
  • WebShop: A web-based shopping benchmark where agents must search, inspect, and purchase products.

To train the 1.7B classifier, they used a 32B teacher model to label state-suggestion pairs collected from both unassisted and recovery-assisted trajectories (Figure 4).

Figure 4: Aligned supervision: collect target-actor states, reconstruct available candidate groups, label the exact payload, and fit the small classifier. Scenario or product-group partitions separate training, calibration, and classifier testing.

Key Insights and Ideas

  • Classification > Generation: You don't need a massive model to diagnose a failure if you can simply have a small model verify if a known "fix" applies to the current state. This shift from generation to assessment is the primary driver of efficiency.
  • Actionable Facts over General Principles: Figure 5 illustrates that providing a "micro-contract" (concrete interface facts) is far more effective than a "short principle" (general instructions). Agents perform better when told what constraint to satisfy rather than how to think.
  • Governance is Essential: Without the PVT, an experience reuse system might repeatedly send the same hint even if the agent is ignoring it. The PVT acts as a "control plane," ensuring that guidance is timely, non-redundant, and stays within a token budget.
Figure 5: Illustrative rendering of the implemented WebShop option-state asset. Both views use the same visible evidence; Contract adds the concrete check.

Key Results

Synapse-Control demonstrated that "less is more" when it comes to the control plane:

  • Higher Success: Across 1,308 attempts, it achieved 270 successes—a 29.8% improvement over the base agent and outperforming Sentry (256 successes).
  • Massive Speedup: It reduced auxiliary control time by 50.2% in AppWorld and 51.0% in WebShop compared to Sentry.
  • Efficiency: The system replaced 4,987 expensive generative diagnosis calls with lightweight classifier passes.
  • Token Savings: It achieved a 27.5% reduction in total tokens used per successful completion relative to the base agent.

Limitations and Future Work

  • Domain Onboarding: While the authors estimate only a few person-hours are needed to define templates for a new domain, it still requires manual effort. Future work could involve using LLMs to automatically extract micro-contracts from OpenAPI/Swagger documentation.
  • Teacher Dependency: The system relies on a larger (32B) teacher model for initial data labeling, which might be a bottleneck for some researchers.
  • Complex Planning: In AppWorld, some tasks failed because the agent hit a hard action limit (60 steps). While Synapse-Control helps with local interface errors, it doesn't solve the problem of agents getting lost in extremely long, multi-step workflows.

Summary updated

Abstract

Large language model agents reuse execution experience to improve reliability on complex tool-based tasks. Systems such as Sentry call large models to generate failure diagnoses before retrieving advice, adding inference cost to experience reuse. We present Synapse-Control, an agent runtime whose lightweight control plane selects advice and determines when to send it to the task-executing model. Rules shortlist relevant advice, and a lightweight 1.7B classifier fine-tuned on teacher-labeled state-suggestion pairs scores those candidates instead of generating a diagnosis. Micro-contracts encode reusable interface checks, such as required arguments or valid options, without prescribing complete task programs. A Prompt Value Table records earlier guidance and feedback to limit repeated suggestions through cooldown and token-budget checks. Across 1,308 attempts per method in AppWorld and WebShop, Synapse-Control achieves 270 successes (29.8% more than Base), replaces 4,987 generative diagnosis calls, and reduces auxiliary control time relative to Sentry by 50.2% and 51.0%, respectively.
BibTeX
@misc{huang2026synapse,
  author = {Zhiyuan Huang and Shengan Zheng and Chenghu Yang and Song Zhang and Lingyun Li and Chen Yu and Weiquan Huang and Linpeng Huang},
  title = {{Synapse-Control: Making Agent Experience Actionable with Lightweight Runtime Control}},
  year = {2026},
  eprint = {2611.13615},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13615},
}
Figure