DDAgent

DDAgent

One UI for all your AI coding agents.
Self-hosted server and Flutter client (web, Linux, Windows & Android) for Claude Code, Codex, Cursor CLI, OpenCode, Devin, Command Code and Antigravity — sessions, files, git, terminals and tasks in a single place.

= 22">

Install · Contributing · Bug Reports

English · Polski · Deutsch · Español · Français · Italiano · 日本語 · 한국어 · Русский · Türkçe · 简体中文 · 繁體中文

Sessions from every agent in one list	Kanban board — cards start agent runs	Git panel — diff, stage hunks, commit

What is DDAgent?

DDAgent runs on your own machine or VPS and puts one polished UI on top of the coding agents you already use. The server reads each agent's sessions straight from its own on-disk history (~/.claude, ~/.codex, ~/.cursor, OpenCode, Devin, …), so existing conversations show up without importing anything. Only session metadata is indexed locally; nothing is sent to a third party.

Connect from the Flutter client on your desktop, phone or browser. Your machine, your agents, your data.

Features

• Multi-agent sessions — run and resume sessions from seven agent CLIs side by side, with live streaming over WebSocket
• Auto orchestrator — "Auto" sessions route each task to a suitable agent and model, taking remaining subscription quota into account, and delegate work to child sessions
• Split workspace — up to six panes (chat, terminal, browser, preview, editor, git, notes) in one window
• File explorer & editor — browse the workspace and edit code in the built-in editor
• Git panel — stage files or individual hunks, commit (with AI-generated messages), diff, branch, pull/push and restore checkpoints without leaving the UI
• Integrated terminal — a full shell per workspace
• Kanban board — move a card to start an agent run on it (optionally in its own worktree); the agent reports back when it is done
• TaskMaster — turn PRDs into tasks and track them on a task board
• Message queue — messages sent while an agent is busy are queued on the server and survive refreshes and device switches
• MCP management — add, edit and sync MCP servers across agents
• Knowledge base — one local, searchable memory for every agent: rules, skills, memories and personal info, retrieved on demand over MCP (docs)
• Skills & rules — manage agent skills and shared rules from one place
• Quota & usage — token usage and subscription limits per agent, at a glance
• Browser-use — agent-driven browser sessions for research and testing, with a live browser pane
• Worktrees — spin up isolated git worktrees per task, with per-worktree setup/run scripts and an authenticated live dev-server preview
• Remote approvals — approve tool permissions from Telegram, Discord or the Android app (docs)
• Voice input — dictate prompts through a Whisper-compatible speech-to-text endpoint
• Agent broadcast & shared memory — message every agent at once and keep per-project notes they all read
• Multi-account switching — named accounts per provider with per-session env overrides
• Scheduler — cron-driven, unattended agent runs, with an option to keep the device awake while runs are active
• Team collaboration — roles (owner/member/viewer), invite links, assignees, comments, presence and an activity feed on the board (docs)
• MCP server — let external MCP clients (Claude Desktop, OpenClaw) list sessions, create tasks and message sessions (docs)
• Notifications & TTS — push, Telegram and Discord notifications when a session needs you, plus optional read-aloud replies
• Command palette — Ctrl/Cmd+Shift+K to search sessions and messages, jump to any page or run quick actions
• Docker sandboxes — run agents in microVM-isolated Docker Sandboxes (docs)
• Flutter client — one codebase for web, Linux, Windows and Android; 12 languages, dark and light themes

Supported agents

The agent CLIs must be installed and signed in on the server machine. You bring your own subscriptions — DDAgent provides the environment, not the AI.

Install

DDAgent has two parts: the server, which runs next to your agents and exposes a REST/WebSocket API, and the client, which connects to it. The server needs Node.js 22+ (the prebuilt tarballs need Node.js 22.x, because their native modules are built against it).

Server — installer script

curl -fsSL https://github.com/Zakwei/ddagent/releases/latest/download/install.sh | bash

Requires git, Node.js 22+ and npm. The script clones a release tag into ~/.ddagent/app, installs dependencies, builds the backend and writes a start.sh launcher. Pass options after bash -s --:

curl -fsSL https://github.com/Zakwei/ddagent/releases/latest/download/install.sh | bash -s -- --systemd --port 3001

Then start the server:

~/.ddagent/app/start.sh        # API on http://<host>:3001 (set SERVER_PORT to change)

Server — prebuilt tarball

No build step: download ddagent-server-<version>-<os>-<arch>.tar.gz (linux-x64, mac-arm64 or win-x64) from Releases, unpack it and run the launcher:

mkdir ddagent && tar xzf ddagent-server-*-linux-x64.tar.gz -C ddagent
./ddagent/start.sh             # start.bat on Windows

Each tarball comes with a .sha256 checksum. Settings go in an optional .env file next to start.sh.

Client

Download a prebuilt client from Releases:

On first launch, enter your server URL (for example http://my-vps:3001) and create the first account. On Windows and Linux x64, the desktop client can also download and run a local server for you ("This device" on the connect screen).

The web build has no login screen and calls the API on its own origin, so it must be served behind a reverse proxy in front of a server running in single-user platform mode (VITE_IS_PLATFORM=true, which disables authentication). In a source checkout, node scripts/serve-flutter-web.cjs serves flutter/build/web on port 8085 and proxies the API and WebSockets to the server on FLUTTER_BACKEND_PORT (default 10087). Only expose this setup on a trusted network.

To build the client yourself:

cd flutter
flutter pub get
flutter build linux --release      # or: windows, apk, web

Updating

Settings → About → Updates in the client has a separate button for each part:

Release tarballs are built for Node.js 22 — the server refuses a tarball built for a different Node.js major. Servers from 0.8.12 or older (installer script or tarball) update to 0.8.13 once by hand — re-run install.sh --version v0.8.13 or unpack the new tarball over the old one — and from the UI after that.

From source

git clone https://github.com/Zakwei/ddagent.git
cd ddagent
npm install
npm run build && node dist-server/server/index.js   # API on http://localhost:3001

Docker sandbox (experimental)

ddagent sandbox ~/my-project

Runs DDAgent and an agent (Claude Code or Codex) inside a microVM-isolated Docker Sandbox. Requires the sbx CLI — see docker/README.md.

CLI

In a source or install.sh checkout, ddagent below means node dist-server/server/modules/cli/cli.js (it has a shebang, so ./dist-server/server/modules/cli/cli.js works too).

Configuration

The server reads an optional .env file from its install directory (next to start.sh); real environment variables take precedence. Run ddagent status to see which file is used.

See .env.example for more.

Development

npm install
npm run dev               # start the backend from source (tsx, no reload)
npm run server:dev-watch  # same, restarting on file changes
npm run build             # compile the server to dist-server/
npm test                  # backend tests
npm run typecheck         # TypeScript check
npm run lint              # ESLint

Client (Flutter 3.47.5 stable):

cd flutter
flutter pub get
flutter run -d linux --dart-define=DEFAULT_SERVER_URL=http://localhost:3001
dart format --line-length 100 lib test
flutter analyze
flutter test

Backend code follows the module architecture in server/modules/; see server/modules/providers/README.md for provider internals.

Contributing

Bug fixes are welcome — see CONTRIBUTING.md. To report a vulnerability, see SECURITY.md.