PaperlayerView exact revision on arXiv

Source-linked AI summary

ChatDev 2.0: A No-Code Multi-Agent Platform for Developing Everything

Yufan Dang, Shu Yao, Bowen Lai, Chenting Xu, Ruijie Shi, Wai-Shing Leung, Huatao Li, Chen Qian, Zhiyuan Liu

arXiv:2609.00714v1cs.AIcs.CLcs.MA

TL;DR

LLM-based MAS development requires balancing expressive programming frameworks against simpler no-code tools with constrained interaction patterns. DevAll uses declarative executable graphs, cycle-aware execution, and visual interfaces to build and inspect heterogeneous MAS. Across visualization, deep research, and software development, it reproduces representative specialized workflows with competitive performance without task-specific orchestration code.

  • Problem

    Existing code frameworks are expressive but engineering-intensive, while no-code builders simplify authoring but constrain agents to author-defined workflows.

  • Method

    DevAll combines a declarative graph compiler, semantic edges, and CADET cycle-aware scheduling with a visual interface for authoring, execution, monitoring, and inspection.

  • Results

    Across visualization, deep research, and software development, DevAll reproduces representative specialized workflows with competitive performance in a unified platform.

  • Takeaways & Limitations

    DevAll supports expressive heterogeneous and cyclic MAS development without task-specific orchestration code.

  • Takeaways & Limitations

    Users must still specify agent roles, prompts, dependencies, control conditions, and workflow structures, while some domain-specific interactions may require custom extensions.

Abstract

from arXiv · show

Large language model (LLM)-based multi-agent systems (MAS) have shown strong potential for solving complex tasks, yet their development forces a tradeoff: code frameworks are expressive but engineering-intensive, while no-code builders simplify authoring but constrain agent interactions to author-defined workflows. We present ChatDev 2.0: DevAll (hereafter DevAll), a no-code platform for building, executing, and inspecting heterogeneous MAS that delivers both high expressiveness and ease of use. In terms of expressiveness, DevAll pairs a declarative executable graph abstraction with a cycle-aware execution engine, so that heterogeneous agents and dynamic and cyclic interactions can be represented and executed within a single framework. For ease of use, an integrated visual interface lets users author, run, monitor, and inspect MAS, including human-in-the-loop steps, entirely without writing code. Experiments demonstrate that DevAll reproduces state-of-the-art MAS across three representative tasks at competitive performance and without task-specific orchestration code, highlighting its effectiveness as a general-purpose platform for LLM-based MAS. DevAll is available at https://github.com/OpenBMB/ChatDev.

1 Introduction

DevAll addresses the tension between expressive but engineering-intensive code frameworks and simpler no-code builders that constrain multi-agent interactions. It combines declarative executable graphs, cycle-aware execution, and visual authoring to support dynamic MAS without task-specific orchestration code.

  • Motivation: LLM-based multi-agent systems coordinate specialized agents to decompose complex tasks, exchange intermediate results, and respond to runtime feedback.
  • Motivation: Code frameworks provide reusable primitives but typically require programming for customized agent communication and orchestration.
  • Motivation: No-code platforms simplify authoring but rely on author-defined workflows, manual state binding, and limited support for interacting feedback cycles.
  • DevAll: DevAll compiles heterogeneous nodes and semantic edges into executable graphs, while CADET schedules multiple and nested feedback cycles with iteration-level states.
  • DevAll: DevAll enables users to author, execute, and inspect dynamic MAS without task-specific orchestration code, including validation across visualization, deep research, and software development.

2 Related Work

Related systems include programmable MAS frameworks and visual agent builders, but DevAll emphasizes an agent-centric graph abstraction in which state propagates along semantic edges. The same edge abstraction represents cyclic and acyclic interactions without special loop nodes.

  • LLM-Based Multi-Agent Systems: Programmable frameworks such as AutoGen and AgentScope expose abstractions for stateful agents, tools, messaging, and orchestration.
  • No-Code and Visual Agent Builders: No-code visual platforms expose agents, tools, retrieval components, and control operators on a canvas, while DevAll adopts an agent-centric abstraction with automatically propagated interaction contexts.
  • No-Code and Visual Agent Builders: Cyclic and acyclic interactions use the same semantic-edge abstraction, so the visual graph directly corresponds to the executed MAS without special loop nodes.

3 System Design

DevAll combines declarative graph compilation, semantic-edge execution, and a cycle-aware runtime with a visual no-code interface for authoring, running, monitoring, and inspecting heterogeneous MAS. CADET schedules acyclic graph structure globally while executing cyclic regions iteratively within strongly connected components.

  • System overview: DevAll separates visual MAS authoring from runtime execution through a compilation engine and a cycle-aware execution engine.The compilation engine turns declarative specifications into executable graphs, while the execution engine schedules and runs them.
  • MAS Compilation Engine: Declarative specifications define graph-level settings, executable nodes, and semantic edges within a uniform executable-graph abstraction.Global configuration includes shared memory, model and tool registries, workspace, and permissions; seven built-in node types represent common MAS operations.
  • MAS Compilation Engine: Semantic edges independently specify information transfer and downstream scheduling activation, enabling richer interactions than fixed workflows.Their policies determine how outputs are merged, transformed, retained, or cleared and how target scheduling state is updated.
  • MAS Execution Engine: The execution engine runs eligible nodes and propagates outputs through activated semantic edges, advancing acyclic graphs in deterministic topological layers.Node executors consume local context, generate artifacts, emit messages, and update the execution frontier through edge policies.
  • MAS Execution Engine: CADET condenses cyclic regions into strongly connected component subgraphs, producing an acyclic condensation graph for global layer-wise scheduling.Singleton non-self-loop components remain ordinary nodes, while cyclic components become condensed nodes retaining their internal subgraphs.
  • MAS Execution Engine: Within each cyclic component, CADET executes a scoped iterative process in which non-back edges form the current-iteration skeleton and back edges carry dependencies forward.Activated external or prior-iteration triggers update contexts and states, while a configurable iteration limit ensures termination.
  • No-code interface: The integrated interface connects tutorial, authoring, execution, and inspection views, including metadata-driven controls and human-feedback pauses.Users can construct graphs without code, launch requests with optional files, monitor runtime events, and inspect intermediate messages and artifacts.

4 Experiment

The evaluation tests whether one no-code platform can reproduce specialized multi-agent workflows across visualization, deep research, and software generation. DevAll achieves competitive cross-domain performance while keeping construction burden controlled and CADET runtime overhead modest.

  • Cross-Domain Results: The same no-code platform attains competitive performance with each domain-specific implementation across all three evaluated domains.The evaluation targets workflow reproduction and generality rather than surpassing specialized systems.
  • Experimental Setup: DevAll reproduces three specialized workflow systems across scientific visualization, deep research, and software generation without task-specific orchestration code.Users re-express each workflow as a declarative MAS graph using YAML specifications of nodes and semantic edges.
  • Cross-Domain Results: 0.7950 overall score on MatPlotBench versus 0.7130 for CoDA, with execution pass rate increasing from 0.8300 to 0.9900.The gain is concentrated in execution pass rate and is attributed in the passage to stable workspace management and error handling.
  • Cross-Domain Results: DeepResearchBench scores 0.3319 for DevAll versus 0.3500 for the reproduced reference workflow, a difference described as within expected LLM-as-judge evaluation noise.On SRDD, completeness is higher while executability and consistency are slightly lower, with nearly identical overall scores.
  • Workflow Construction and Runtime Overhead: 84–258 estimated structural operations were required to reproduce the three workflows, keeping construction burden below 300 estimated operations.Estimated operations sum nodes, edges, and configuration items and approximate structural configuration burden rather than exact clicks or keystrokes.
  • Workflow Construction and Runtime Overhead: At the largest evaluated configuration, median compilation and execution took 16.23 and 14.46 ms, while planning took 91.96 µs.Median compilation, planning, and execution times increased approximately linearly with the number of cyclic SCCs from 1 to 16; compilation includes planning.
  • Workflow Construction and Runtime Overhead: CADET adds modest local processing latency compared with the latency typically incurred by model inference.Runtime measurements exclude network requests and LLM inference.

5 Conclusion

DevAll treats a multi-agent system as a no-code executable object rather than a static workflow. Its declarative graph, cycle-aware scheduling, and integrated interface support building, running, and inspecting diverse MAS without task-specific orchestration code.

  • 5 Conclusion: DevAll compiles declarative YAML into executable graphs whose semantic edges decouple data flow from control flow.The compilation engine dynamically assembles agent contexts from runtime messages.
  • 5 Conclusion: CADET schedules cyclic MAS graphs by condensing strongly connected components into an acyclic topology and restoring deterministic layer-wise execution.This enables arbitrary cycles and dynamic multi-agent interaction patterns.
  • 5 Conclusion: The integrated interface lets users author, launch, monitor, and inspect graphs without writing code, including human-in-the-loop intervention and trace inspection.The platform combines visual authoring with runtime monitoring and inspection.
  • 5 Conclusion: Across visualization, deep research, and software generation, DevAll reproduces three domain-specific workflow systems within one unified platform at competitive performance.The reproductions require no task-specific orchestration code.

Limitations

DevAll simplifies implementation but does not automate workflow design and may not cover every domain-specific interaction pattern. Scaling also leaves visual organization, maintenance, version evolution, and design-knowledge transfer as open improvement areas.

  • Limitations: Users must still translate task requirements into workflow structures and manually specify agent roles, prompts, dependencies, and control conditions.No-code authoring simplifies implementation but does not yet automate workflow design.
  • Limitations: The current graph abstraction and component ecosystem may not cover every domain-specific interaction pattern, and specialized integrations may require custom extensions.The limitation concerns both coverage of interaction patterns and integration requirements.
  • Limitations: As workflows grow, visual organization, modular maintenance, version evolution, and transfer of accumulated design experience remain opportunities for improvement.Future work includes intelligent authoring assistance, reusable templates, stronger lifecycle management, and user studies.

A Implementation Details

DevAll implements executable MAS graphs with registered node types and cycle-aware execution procedures. Its CADET engine schedules condensed graphs and handles cyclic dependencies within strongly connected components.

  • A Implementation Details: Table 4 summarizes the built-in nodes used to construct executable MAS graphs.The table is identified as the built-in node-type reference for DevAll.
  • A Implementation Details: CADET executes MAS graphs by scheduling the condensation graph and resolving cycles inside condensed components.The implementation provides separate procedures for condensation-graph execution and cyclic dependency handling.
  • A Implementation Details: The execution procedure runs ordinary nodes through EXECUTENODE and SEMPROP, while strongly connected components use EXECUTESCC.This separates ordinary-node execution from SCC-specific processing.
  • A Implementation Details: Cyclic handling identifies loopback edges, removes them from internal edges, initializes triggers, and iterates activated edges.The procedure defines Bk as loopback edges, forms bEk by removing them, initializes Q, and processes activated edges from RUN.

B Evaluation Details

The evaluation follows the protocols of the original MatPlotBench, DeepResearchBench, and SRDD benchmark papers. Corresponding metrics are summarized for these benchmarks.

  • B Evaluation Details: The evaluation follows protocols from the original MatPlotBench, DeepResearchBench, and SRDD benchmark papers.The paper summarizes the corresponding benchmark metrics below.

B.1 MatPlotBench Metrics

MatPlotBench measures generated code execution and chart quality using execution, code-quality, visualization, and overall metrics. The metrics distinguish executable cases from non-executable cases where specified.

  • B.1 MatPlotBench Metrics: MatPlotBench evaluates code execution and chart quality using EPR, CS, VSR, and OS.These four metrics cover execution, code quality, visualization success, and overall performance.
  • B.1 MatPlotBench Metrics: EPR is the fraction of queries whose generated code executes successfully.For query q, success is determined by exec(cq), where cq is the generated code.
  • B.1 MatPlotBench Metrics: VSR is the average vision-based score sv(q) over executable cases Qexec.The vision-based score is computed only for executable cases.
  • B.1 MatPlotBench Metrics: OS averages code and vision scores, assigning sv(q) = 0 for non-executable cases.The metric combines sc(q) and sv(q) across queries.

B.2 DeepResearchBench Evaluation Procedure

DeepResearchBench evaluates reports with dynamically weighted, reference-based RACE scoring across four dimensions. SRDD evaluates software projects using completeness, executability, consistency, and quality metrics.

  • B.2 DeepResearchBench Evaluation Procedure: RACE evaluates reports on COMP, DEPTH, INST, and READ, measuring coverage, analysis, requirement adherence, and organization.These dimensions correspond to comprehensiveness, insight/depth, instruction-following, and readability.
  • B.2 DeepResearchBench Evaluation Procedure: The judge LLM generates criteria and dimension weights, with weights summing to 1.Dynamic weight estimation produces task-specific wd values, and criteria generation supplies dimension-specific scoring criteria.
  • B.2 DeepResearchBench Evaluation Procedure: RACE scores target and reference reports under shared criteria, aggregates weighted dimension scores, and normalizes them so 0.5000 indicates parity.The normalized target score divides its intermediate score by the sum of target and reference intermediate scores.
  • B.2 DeepResearchBench Evaluation Procedure: SRDD evaluates software projects using completeness, executability, consistency, and quality.The metrics are denoted C, E, CS, and Q.
  • B.2 DeepResearchBench Evaluation Procedure: Completeness is the percentage of generated projects without placeholder code, while executability is the percentage that compile and run successfully.These metrics measure project completeness and successful execution directly.
  • B.2 DeepResearchBench Evaluation Procedure: Consistency is embedding cosine similarity between requirements and generated code, and quality integrates the metrics as Q = C × E × CS.Quality combines completeness, executability, and consistency multiplicatively.

C Supplementary Results and Case Studies

The supplementary results examine DevAll’s workflow specification cost and generated artifacts. DevAll uses fewer structural configuration actions while producing artifacts qualitatively comparable to specialized baselines.

  • Workflow Specification Cost: DevAll workflow specifications record canvas configuration produced through drag-and-drop and parameter-setting operations.The comparison excludes reusable libraries, model APIs, evaluation scripts, data files, environment files, and generated outputs.
  • Workflow Specification Cost: Lower YAML/Source ratios indicate fewer canvas-level configuration operations relative to task-specific reference code.YAML/Source divides DevAll specification size by the corresponding reference source size.
  • Generated Artifacts: DevAll produces visible visualization and software artifacts qualitatively comparable to corresponding specialized baselines.The paper presents representative outputs in Figures 4 and 5.
Loading 2609.00714v1…