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

AI summary

Overview

• Research area: LLM-based multi-agent systems (MAS), agent orchestration infrastructure, and no-code/visual development platforms.
• Technical level: Intermediate — the platform is no-code, but the underlying execution model (strongly connected component condensation, cycle-aware scheduling) assumes some familiarity with graphs and agent frameworks.
• Scope: The paper introduces and evaluates DevAll (ChatDev 2.0), an open-source no-code platform that lets users build, run, and inspect heterogeneous multi-agent systems by drawing declarative graphs, with a scheduler that handles arbitrary feedback cycles.

What This Paper Is About

Building LLM multi-agent systems currently forces a tradeoff: code-first frameworks (AutoGen, MetaGPT, LangGraph) are expressive but demand heavy engineering, while no-code canvas builders are easy to use but lock agents into author-defined workflows with manually wired loops and state. The paper's goal is to deliver both expressiveness and ease of use in one platform, so that dynamic, feedback-driven, cyclic agent interactions can be authored by drag-and-drop and executed without any task-specific orchestration code.

Key Contributions

1. An open-source no-code platform (DevAll) for authoring, executing, monitoring, and inspecting heterogeneous multi-agent systems through a visual canvas, an integrated execution view, a batch "Laboratory" interface, and a Python SDK.
2. A declarative executable graph abstraction with seven built-in node types (Agent, Human, Python, Subgraph, Literal, Passthrough, LoopCounter) and semantic edges that explicitly separate data-flow policy from control-flow policy, letting information routing and scheduling be specified independently.
3. CADET (Cycle-Aware Dynamic Execution Topology), a scheduling algorithm that makes graphs with arbitrary and nested feedback cycles executable by condensing cyclic regions into strongly connected components, restoring deterministic layer-wise scheduling on the resulting acyclic graph.
4. Cross-domain validation showing that one unified platform can reproduce three specialized multi-agent workflow systems — CoDA (scientific visualization), Enterprise Deep Research (research reports), and ChatDev 1.0 (software generation) — at competitive performance without any task-specific orchestration code.

Main Findings

• Cycle handling is the core technical distinction: CADET decomposes the graph into strongly connected components with Tarjan's algorithm, contracts cyclic components into "condensed nodes" to form a DAG, then executes each condensed component as a scoped iterative subgraph. Internal edges are partitioned into non-back edges (executed within the current iteration) and back edges (treated as loop-carried dependencies deferred to the next iteration), with a configurable iteration limit guaranteeing termination.
• Semantic edges are the key abstraction: each edge is a tuple (source, target, activation condition, data-flow policy, control-flow policy). This means cyclic and acyclic interactions use the same edge construct, so authors never place special "loop nodes" or manually plumb persistent outputs — a direct contrast with Dify, Langflow, and Flowise.
• Visualization task: DevAll matches and slightly exceeds its reference. On MatPlotBench, overall score rose from 0.7130 (CoDA) to 0.7950 (+0.0820), driven mainly by execution pass rate jumping from 0.8300 to 0.9900 — attributed to unified workspace management and error handling rather than changed workflow logic.
• Deep research task: a small, likely-noise-level shortfall. On DeepResearchBench, DevAll scored 0.3319 versus 0.3500 for Enterprise Deep Research (−0.0181). The paper notes the benchmark relies entirely on LLM-as-judge scoring, which carries notable variance.
• Software generation task: essentially parity. On SRDD, DevAll scored 0.6509 versus 0.6574 for ChatDev 1.0 (−0.0065), with higher completeness but slightly lower executability and consistency.
• Construction burden is modest. Reproducing the three workflows required 84–258 estimated structural operations (nodes + edges + non-default config items), which translate to point-and-click canvas actions. The DevAll YAML specification was 9.0% of CoDA's source size, 4.6% of EDR's, and 54.4% of ChatDev 1.0's.
• Runtime orchestration overhead is negligible relative to LLM inference. Scaling from 1 to 16 cyclic SCCs, median compilation time grew to 16.23 ms (p95: 35.36 ms), planning to 91.96 microseconds, and local execution to 14.46 ms — all dwarfed by network and model inference latency.
• Human-in-the-loop is a first-class node. Execution pauses at Human nodes, collects feedback through the same interface, and resumes the downstream path.

Methodology in Plain English

The researchers separated the problem into two engines.

The MAS Compilation Engine takes a human-readable YAML file — the canonical, shareable on-disk representation of a design — and turns it into an executable directed graph. Each node is instantiated through a registry that maps a node type to its configuration schema and executor. Each edge is resolved into an executable communication rule carrying three policies: a condition deciding whether the edge fires, a data-flow policy determining how the source's output is merged, transformed, retained, or cleared in the target's context, and a control-flow policy governing the target's scheduling state. Graph consistency is validated before handoff.

The MAS Execution Engine runs the graph using two primitives: node execution (consume local context, compute, emit messages) and semantic edge propagation (apply the two edge policies to the target). For acyclic graphs this yields a clean deterministic layer-by-layer schedule. For graphs with cycles, no topological order exists, so CADET first condenses cyclic regions into strongly connected components, producing an acyclic "condensation graph" that can be scheduled normally. Each condensed node is then expanded and run iteratively: back edges are identified recursively at each scope, non-back edges execute in the current round, back-edge outputs are deferred to the next round, and the loop exits when execution leaves the component, no deferred triggers remain, or the iteration limit is hit.

To evaluate, the team re-expressed each reference system's workflow as a DevAll YAML graph — without writing any task-specific orchestration code — and ran all three on a standardized GPT-4o backbone with consistent tool configurations, so that score differences reflect workflow reproduction fidelity rather than model or tool variation. They also ran microbenchmarks scaling cyclic components from 1 to 16 to isolate compilation, planning, and execution latency, and measured structural construction complexity via node, edge, and configuration counts.

Why This Matters

The paper reframes the executable object in agent development from a static workflow that invokes agents as steps to a multi-agent system whose agents own and evolve their own state. That shift matters because the most useful agent patterns — planner–executor, generator–reviewer–reviser, iterative research loops — are inherently cyclic and stateful, and current visual builders force authors to hand-wire loop scopes and persistent variables, sometimes forbidding nested loops outright. DevAll's claim is that removing that plumbing while keeping full cyclic expressiveness is possible, and the cross-domain results support it: the same platform hosted three structurally and behaviorally distinct systems.

Real-world applications:

• Scientific data visualization pipelines — iteratively generate, execute, and repair plotting code with a vision-based reviewer, as demonstrated on MatPlotBench.
• Automated deep research and report writing — multi-stage search, synthesis, and critique loops producing structured reports.
• Software generation and prototyping — multi-agent role decomposition (architect, coder, tester, reviewer) with feedback cycles, as in ChatDev 1.0.
• Human-in-the-loop content and decision workflows — any pipeline needing an approval checkpoint, since Human is a built-in pause-and-resume node.
• Domain experts without programming backgrounds — researchers, analysts, and educators who can express a workflow as a graph in YAML and on a canvas rather than as orchestration code.

Industry relevance: the YAML-specification-as-artifact design makes multi-agent workflows versionable, shareable, and distributable objects, which is a prerequisite for treating agent designs as reusable assets. Low orchestration overhead (milliseconds against seconds of inference) means the platform's cost sits essentially entirely in model calls, not infrastructure. The metadata-driven configuration panels also mean third parties can register new node types without writing UI code, which is a plausible path to an ecosystem of contributed components.

Future Directions

• More sophisticated loop-control mechanisms. The current iteration limit is a blunt termination bound; richer exit conditions, convergence detection, and nested-loop coordination remain open.
• Intelligent authoring assistance. The paper explicitly acknowledges that users must still translate requirements into workflow structures and manually specify roles, prompts, dependencies, and control conditions — no-code simplifies implementation but does not yet automate design.
• Broader domain coverage and ecosystem gaps. The current abstraction and component set may not cover every domain-specific interaction pattern, and specialized integrations may still need custom extensions.
• Lifecycle and scale management. As workflows grow, visual organization, modular maintenance, version evolution, and transfer of accumulated design experience become problems, motivating reusable templates and stronger lifecycle tooling.
• User studies. The authors propose assessing authoring efficiency and learnability across different levels of programming expertise, which the current evaluation does not include.
• Application expansion into scientific discovery, automated data analysis, and interactive education.

Target Audience

This paper is most valuable to agent-framework developers and platform engineers deciding whether to build on code-first orchestration or a visual builder, and to researchers studying multi-agent system design patterns, who will find the semantic-edge abstraction and CADET's cycle-aware scheduling the substantive technical contributions. Tool builders and product teams in the LLM application space will benefit from the construction-cost and runtime-overhead analysis. Domain practitioners without deep programming backgrounds — scientists, analysts, educators — are the intended end users of the platform itself and can read the system design and interface sections without engaging the scheduler internals. Readers mainly interested in raw benchmark superiority will find less here, since the paper explicitly positions its goal as reproducing specialized workflows within one platform rather than surpassing them.

Authors’ abstract

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.