Dynamic Process Generation for Multi-Agent Systems

This direction is merged into another direction: architectural rigidity (static communication topology). Its last version stays readable and citable here.

Version 1 of 1108 papers112 conceptsfrozen 2026-10-04

Traditional multi-agent systems (MAS) operate like a rigid assembly line. A developer defines a "Coder," a "Reviewer," and a "Manager," and then hard-codes the sequence in which they speak. While this works for predictable scripts, it fails when the task is open-ended or when an agent encounters an unexpected error.

A new wave of research is moving away from these "design-then-deploy" architectures toward Dynamic Process Generation. In this paradigm, the system does not follow a fixed script; instead, it treats the workflow, the team composition, and even the agents' roles as variables to be optimized at runtime.

The Problem with Static Orchestration

Most early agent frameworks, such as MetaGPT or AutoGen, rely on predefined operating procedures. As noted by Leilei Lin and colleagues in Think-on-Process (ToP), these rigid sequences fail to adapt to the diverse requirements of different software projects. If a task requires a specialized expert not included in the initial "handcrafted" team, the system hits a wall.

This rigidity creates a "brittleness bottleneck." When an agent in a linear chain fails, the entire process collapses because the system lacks the structural flexibility to re-route the task or re-evaluate its plan.

Just-in-Time Team Assembly

Instead of starting with a fixed team, researchers are now building systems that "draft" their own experts. Guangyao Chen introduced AutoAgents, a framework that dynamically generates a customized team of specialized agents for every unique prompt. By analyzing the specific requirements of a query first, the system can instantiate a "Legal Expert" for a contract task or a "Biologist" for a lab simulation, rather than relying on generic personas.

This concept extends into specialized domains like medicine. Xiao Wu developed KAMAC, which allows LLMs to "recruit" medical specialists mid-discussion. If the agents realize they lack knowledge about a specific rare disease, they pause to bring in a virtual consultant, mimicking the dynamic referral process used by human doctors.

Workflows as Living Graphs

The most significant shift in this research area is the transition from linear sequences to dynamic graphs. Ben Niu and the team behind Flow represent workflows as Activity-on-Vertex (AOV) graphs. Unlike a static list of steps, an AOV graph allows agents to execute subtasks in parallel and, crucially, to re-plan the graph in real-time if a subtask fails.

Similarly, DyFlow separates the "Designer" (the planner) from the "Executor" (the doer). This separation of concerns allows the system to treat the reasoning path as a hypothesis that can be tested and adjusted based on intermediate feedback. If the Executor finds that a specific tool is unavailable, the Designer immediately rewrites the workflow to find an alternative path.

Recursive Growth and Meta-Orchestration

To handle truly massive complexity, some researchers are looking at how agents can "spawn" their own help. Philip Schroeder proposed THREAD, which treats LLM generation as a thread of execution that can recursively spawn "child threads" to handle sub-problems. This allows a small model to act like a large one by compartmentalizing "thinking" into separate, manageable contexts.

The ultimate expression of this trend is MAS², introduced by Kun Wang. MAS² is a multi-agent system that autonomously designs, configures, and repairs other multi-agent systems. By moving the human developer out of the loop and allowing the system to self-rectify its own architecture, MAS² achieves significant performance gains in environments where tool errors or network issues would normally cause a static system to fail.

Why It Works: The Intuition of Latent Processes

The reason dynamic process generation outperforms static methods is that it treats the "how" of a task as a latent variable to be discovered, rather than a constant to be followed.

By decoupling the goal (what to do) from the process (how to do it), these systems gain three critical capabilities:

  1. Adaptive Specialization: They only use the compute and expertise necessary for the specific nuances of a query.
  2. Error Resilience: They can "backtrack" or "re-route" around failures by modifying the workflow graph mid-execution.
  3. Emergent Efficiency: Through mechanisms like Monte Carlo Tree Search—used in TOA by Hai Ye—they can explore multiple collaboration strategies and select the one that maximizes the success-to-compute ratio.

In short, the field is moving from building "bots that follow instructions" to "systems that build their own solutions."

Papers in this version

Showing 60 of 108 papers.

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_dynamic_process_generation_for_multi_age_6e17100e,
  title = {Dynamic Process Generation for Multi-Agent Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/dynamic-process-generation-for-multi-agent-systems/rdr_6e17100e670d46f1b2bca8990c8d3c21},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_dynamic_process_generation_for_multi_age_6e17100e_v1,
  title = {Dynamic Process Generation for Multi-Agent Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/dynamic-process-generation-for-multi-agent-systems/rdr_6e17100e670d46f1b2bca8990c8d3c21/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}