ChatDev

What it is

ChatDev 2.0, which OpenBMB also calls DevAll, is a platform for building and running multi-agent systems without writing code. You describe the agents, the links between them and the task in a YAML workflow, or draw the same graph on a canvas, then launch it with a prompt. It runs on your own computer as a FastAPI backend with a Vue 3 web console, and the same workflows run from Python. ChatDev started in 2023 as a virtual software company, where agents such as a CEO, a CTO and a Programmer took a program through design, coding, testing and documentation. That version now lives on its own branch. This listing is Mindket’s setup notes for 2.0.

1. You pick a workflow, or draw one on the canvas
2. You type a task and attach any files it needs
3. Agent nodes call your model and pass context on
4. A human node can pause the run for your review
5. Outputs land in a session folder you can download

Who it suits

People who want a team of LLM agents on a job such as a research report, a set of charts or a small game, without writing the orchestration code. Python developers get the same workflows through the Python SDK, which the README offers for automation and batch processing: runtime.sdk inside a clone, or the chatdev package on PyPI. Researchers in multi-agent collaboration will find the group’s papers behind it. MacNet and the puppeteer orchestrator from its NeurIPS 2025 paper each have a branch in the repository.

The Manim, Blender and ChatDev_v1.yaml workflows run code, using Manim scripts, a local blender-mcp server and uv tools. The Python node page puts all three behind MAC_ALLOW_UNSAFE_CODE_EXECUTION=1, which is off by default.

Skip it if you want a hosted app with nothing to install: 2.0 is a backend and a console you start yourself. For the 1.0 software company as it was, use the chatdev1.0 branch, which these notes do not cover.

Where to use it

In your browser, on the web console your own machine serves at localhost:5173. The README names macOS, Linux, WSL and Windows.

• Web console: the Launch tab runs a workflow, the Workflow Workbench draws one and exports YAML, and a built-in Tutorial walks you through it
• Python: the chatdev package from PyPI, or runtime.sdk inside a clone of the repository
• Terminal and HTTP: run.py runs a workflow file, and POST /api/workflow/execute starts one on the backend
• OpenClaw: a chatdev skill lets it call existing ChatDev agent teams or create new ones
• Docker Compose: the backend and the console as two containers

How to set it up

Get it saves a zip of Mindket’s setup notes in your downloads folder, with each route’s commands from OpenBMB’s README and docs. The README’s recommended route is make, run from a clone of the repository.

1. Clone the repository and open it. The default branch, main, holds 2.0.
2. Install the backend with uv.
3. Install the web console. Its packages go in the frontend folder.
4. Copy .env.example to .env. Set API_KEY and BASE_URL there for your model provider.
5. Start both servers with make dev. Then open http://localhost:5173.

uv sync
cd frontend && npm install

Back in the project root, copy the settings file and start both servers.

cp .env.example .env
make dev

Without make, start the backend with uv run python server_main.py --port 6400 --reload. Then run the console from frontend/ with VITE_API_BASE_URL=http://localhost:6400 npm run dev. The Makefile’s own client target runs that line through npx cross-env. If the console cannot reach the backend, port 6400 may be taken: start the backend with --port 6401 and set VITE_API_BASE_URL=http://localhost:6401 for the console, which stays at localhost:5173. With Docker and Docker Compose, one command from the project root builds and starts both.

docker compose up --build

How to use it

On the Launch tab, choose a workflow from the left panel, upload any files it needs, type your task and click Launch. Each node moves from pending to running to success or failed. The output panel shows live logs, each node’s output and the files the run makes. When a run reaches a human node it stops and asks for text or a file. Download, on the right panel, saves the whole session with context.json, attachments and logs.

The ready workflows sit in yaml_instance/. Files named demo_*.yaml each show one feature, such as memory, MCP or loops, and the plainly named ones are full workflows. To make your own, draw nodes and edges on the Workflow Workbench and export the YAML, or write it by hand and check every file.

make validate-yamls

From Python, the PyPI package runs a workflow file and hands back the result. Its page gives the install under “From the repository root”, so run this inside a clone.

from chatdev import run_workflow

result = run_workflow(
    yaml_file="ChatDev_v1.yaml",
    task_prompt="This is a minimal run example",
)

print(result.success)
print(result.final_message)
print(result.output_dir)

Example

You want an article drafted, with the last word yours. You save the authoring guide’s example workflow as a file in yaml_instance/ and set its BASE_URL under vars to your provider. Change its name: gpt-4o to a model your provider serves, with provider: gemini for Gemini, as the agent node page shows. If it is not in the Launch list, run make sync, which the README says uploads all workflow files from yaml_instance/ to the database. It has an Article Writer agent and a Human Reviewer node. On the Launch tab you pick it and type a short phrase, as its instruction asks:

Remote work for small teams

Article Writer drafts the piece on your model, then the run stops at Human Reviewer and the page asks for your input. Type revision notes and the draft goes back to the writer for another pass. Type ACCEPT and the loop ends, because the edge back to the writer fires only when ACCEPT is missing. The session folder keeps context.json, with what each node took in and gave back.

For newcomers and experts

If you are new. A multi-agent system splits one job between several model calls with different roles, one writing and one reviewing, and passes text between them. ChatDev 2.0 lets you set that up as a graph instead of code. Start with the console’s Tutorial, then a demo workflow, then a full one. Every agent node calls your provider at least once, and tools, reflection, retries, loops and dynamic runs add more calls, so a hosted model bills each one. LM Studio or Ollama keep the calls on your own computer.

For experts. Graphs without cycles run as ordinary DAGs. For loops, the engine finds the cycles with Tarjan’s algorithm and runs each one as a super node, recursing into nested ones. loop_counter and loop_timer nodes cap a loop by count or by time. An edge can carry a condition, a keyword match or a Python function in functions/edge/, and a process step such as regex_extract. Dynamic execution fans a message out in map mode, or in tree mode reduces the results in groups until one is left. Up to ten units run at once by default. The authoring guide puts the dynamic block on a node and the dynamic execution page on an edge, so check demo_dynamic.yaml before you copy either.

Variables resolve from vars in the YAML first, then the shell, then .env, and a missing one raises a ConfigError with its path. Agent nodes make up to five attempts at a failed call, the first included, waiting 1 to 6 seconds between tries, on 408, 409, 425, 429, 500, 502, 503 and 504. Tools come from Python functions in functions/function_calling/, typed by their hints, or from MCP servers, remote over HTTP or local over stdio. Memory stores are simple, file, blackboard or Mem0. From a terminal, the guide gives this line, which takes the task from TASK_PROMPT or a prompt it shows. The folder holds no demo.yaml, so point --path at a demo_*.yaml file such as demo_human.yaml.

python run.py --path yaml_instance/demo.yaml --name test_run

Good to know

ChatDev runs on your machine, and these are the parts that reach further.

• Code execution: off by default. MAC_ALLOW_UNSAFE_CODE_EXECUTION covers Python nodes, execute_code, code_save_and_run, uv tools, Manim and local MCP servers. The docs say turning it on grants the backend user’s permissions and is not a sandbox, so use it only for workflows you trust
• Model provider: agent nodes send prompts and context to the address a workflow gives them, usually BASE_URL from .env. With LM Studio or Ollama that address is your own machine
• Web tools: web_search goes through Serper.dev with SERPER_DEV_API_KEY, and read_webpage_content through Jina Reader, limited to 20 requests a minute without a JINA_API_KEY
• Memory: a mem0 store is cloud-managed by Mem0, with an API key from app.mem0.ai, and sends user input there. simple and file stores send text to the embedding provider you set, openai in the memory page’s samples
• The backend API: the attachment guide says the attachment APIs require the session ID, and to guard them with proxy-layer auth or internal JWT checks in production. The Docker route binds the backend to 0.0.0.0 and publishes port 6400
• Files: each run writes to WareHouse/<session>/ in the project folder, and attachments stay there unless MAC_AUTO_CLEAN_ATTACHMENTS=1. make stop frees both ports with npx kill-port, whatever holds them
• Doc drift: the README names GameDev_v1.yaml, data_visualization_enhanced.yaml, blender_scientific_illustration.yaml and yaml_instance/demo.yaml, which the folder did not hold on 3 November 2026. Pick from the console’s list
• Python: pyproject.toml takes 3.12 only, while the chatdev package on PyPI, version 0.1.0, takes 3.12 or 3.13
• Not run: Mindket read the README and docs and did not run the commands. The pages give no uninstall steps
• License: Apache-2.0, and the LICENSE file reads “Copyright 2025 OpenBMB”