DeepCode Open Agentic Coding
Turns research papers and natural-language requirements into algorithm, frontend, and backend code through a multi-agent coding runtime.
- Source repo
- HKUDS/DeepCode
- Stars
- ★ 17k
- Last updated
- 4d ago
- License
- MIT
- Primary language
- Python
- FA score
- 60/100 · Some gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI API · Claude APIClaude Code (Partial support)
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- An ML researcher reproducing an algorithm from a paper can use the Paper2Code workflow to generate an implementation, tests, and documentation.
- Not a fit if
- Environments where an agent running shell commands and reading local files is unacceptable
- Users wanting a zero-dependency install without Python 3.12+ and Node.js frontend setup
- Source review
- 60/100 · Some gaps
What does this agent do, and when should you use it?
DeepCode is a multi-agent software-development platform organized around Paper2Code, Text2Web, and Text2Backend workflows. It offers an interactive terminal conversation, a locally hosted React and FastAPI web UI, and a headless CLI that emits machine-readable JSON events for scripting or CI. Its shared runtime uses MCP tools for file operations, web retrieval, repository downloading, document processing, command execution, code indexing, and implementation work. Configuration is layered between a user base and project overrides, with documented provider settings for OpenAI, Anthropic, Gemini, and OpenRouter. The README also describes persistent sessions, reusable skills, lifecycle hooks, planning, memory, and isolated subagent delegation for larger tasks.
DeepCode accepts research papers, natural-language requests, URLs, and files, then coordinates work through the Central Orchestrating Agent, Intent Understanding Agent, Document Parsing Agent, Code Planning Agent, Code Reference Mining Agent, Code Indexing Agent, and Code Generation Agent. It calls the MCP servers filesystem, fetch, github-downloader, file-downloader, command-executor, code-implementation, code-reference-indexer, and document-segmentation to read inputs and produce code, tests, and documentation. Run an interactive session with deepcode or python -m cli.tui, start the local web mode with deepcode --local, or execute one task with python -m cli.exec_cli "task" --json, which emits NDJSON events. Sessions are stored under ~/.deepcode/sessions/<id>/; ~/.deepcode/deepcode_config.json is merged with a project deepcode_config.json when present.
- An ML researcher reproducing an algorithm from a paper can use the Paper2Code workflow to generate an implementation, tests, and documentation.
- A frontend developer translating a written product brief into a working interface prototype can use Text2Web.
- A backend engineer starting from a short service specification can use Text2Backend to generate server-side code.
- A CI or internal-automation owner who needs a one-shot coding task with machine-readable output can invoke
python -m cli.exec_cli "task" --json. - A developer working repeatedly in a local repository can use
deepcodefor a multi-turn session and/resumeto reopen a saved conversation.
How do you install or deploy this agent?
Prerequisites are Python 3.9+, Node.js 18+, and npm 8+. For direct installation, run pip install deepcode-hku, then deepcode init to create ~/.deepcode/deepcode_config.json; add at least one provider key, for example {"providers":{"openai":{"apiKey":"your_openai_api_key"}}}. For source development, run git clone https://github.com/HKUDS/DeepCode.git, cd DeepCode, pip install -r requirements.txt, and npm install --prefix new_ui/frontend. To bind the global command to that checkout, run pip install -e ..
How do you use this agent?
After configuring a provider key, run deepcode in a project directory for an interactive, multi-turn coding session. Use python -m cli.tui -w ./my-project to select a workspace or python -m cli.tui --resume <session_id> to continue a saved session; in chat, /help, /new [title], /resume, /model [id], /clear, and @src/main.py are documented controls. Run deepcode --local for the local web UI at http://localhost:5173 with a backend at http://localhost:8000. For scripting or CI, run python -m cli.exec_cli "fix the failing test in mathlib.py" --json.
What are this agent's strengths and limitations?
- It supports terminal chat, a locally hosted web UI, and headless NDJSON execution, covering both interactive development and CI-style automation.
- Its MCP tool matrix explicitly covers filesystem access, fetching, repository download, document segmentation, command execution, code indexing, and implementation tasks.
- It documents configurable paths for OpenAI, Anthropic, Gemini, and OpenRouter, with project configuration overriding user-level defaults.
- Sessions are persisted as JSONL and indexed with SQLite, enabling session listing, resumption, and branching.
- You must provide at least one model-provider API key; the supplied material does not document a default free model or cost-control mechanism.
- The local web UI adds Node.js 18+ and npm 8+ requirements alongside the Python runtime and frontend dependency installation.
- Its operation can involve local filesystem access, shell execution, network access, and MCP servers, so workspace permissions and credential handling need review before adoption.
- The PaperBench scores and comparisons with Cursor, Claude Code, Codex, and PaperCoder are repository-reported claims; the supplied evidence does not include an independent reproduction.
How does this agent compare with similar options?
The README reports PaperBench results of 84.8% for DeepCode versus 58.4% for Cursor, 58.7% for Claude Code, and 40.0% for Codex on one subset. It also reports 73.5% for DeepCode versus 51.1% for PaperCoder. Treat these as the repository’s stated benchmark results, not independently verified findings.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| DeepCode Open Agentic Coding This agent | 60 · Some gaps | CLIFree + model costs | ★ 17k | 4d ago | Python | OpenAI API · Claude API |
| Lang-Agent Visual Agent Configuration Platform | 50 · Major gaps | Web appFree + model costs | ★ 331 | 10mo ago | TypeScript | — |
| Okto Pulse | 80 · Good | CLIFree | ★ 127 | 3d ago | Python | Codex · Claude Code |
| Puppyone | 39 · Major gaps | Self-hosted serviceFreemium | ★ 1.3k | 4mo ago | TypeScript | ChatGPT · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence shows explicit project trust, three permission modes (Ask/Read only/Full access), tool-level allow/ask/deny, sensitive-path protection, platform sandboxing, and Job Object isolation on Windows. User confirmation mechanism exists but lacks implementation details. Data flow transparency: tool calls, execution progress, and file changes are visible, but data flow not detailed. Sensitive data handling: credentials stored in user-private storage, not written to session history, but implementation not shown. Dependency security: dependencies not pinned, no security audit or vulnerability scan evidence. External effects: command execution sandboxed, but details not provided. Rollback: session lifecycle has archive and delete, but no code rollback mechanism. Source attribution: no explicit source attribution mechanism.
Self-consistency: README description aligns with code structure, tests cover automation transport and codec. Dependency availability: dependency list clear but not pinned. Failure messages: tests verify error handling like InvalidParams and ParseError.
Audience and scenarios: targets developers and researchers, supports multiple scenarios (Paper2Code, Text2Web, etc.). Capability boundaries: explicitly states not designed to make Agent look busier but to help finish real work. Trigger precision: supports natural language instructions and automation scheduling. Environment fit: supports CLI and Desktop, cross-platform (macOS, Windows, Linux).
Information architecture: README structure clear with TOC and detailed sections. Install notes: provides installation steps for CLI and Desktop. Naming stability: version history shows stable naming. Examples and FAQ: provides quick start and demos, but lacks FAQ. Known limitations: not explicitly listed. License: MIT. Versioning and changelog: news and milestones recorded. Maintenance responsibility: GitHub Actions CI present, but maintainers not explicit.
Output usability: provides visual interface and session history, output reviewable. Marginal value: offers multi-agent system and automation, unique value. Cost-benefit: no performance or cost data.
Claim traceability: README claims correspond to code and tests. Cross-source corroboration: paper and video exist, but no independent verification. Fact-inference separation: README distinguishes facts and inferences.
- Dependencies are not pinned, posing supply chain risk.
- No security audit or vulnerability scanning evidence provided.
- Known limitations are not explicitly listed.
- Publisher identity is unverified, but no malicious indicators found.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
DeepCode v2.3.1 is a stability release for the terminal UI on the shared background service. Answers now appear once and render as Markdown while they stream, the TUI survives a slow or restarted service, /compact works on coding sessions, and the background service no longer stops right after starting on Windows installs in a virtual environment. It also includes five community fixes and dependency security updates. Highlights …View on GitHub ↗ -
Release notes excerpt
DeepCode v2.3.0 runs the TUI, Desktop, and a new browser client on one local background service, so work you start in one interface keeps running and can be followed and approved from another. It adds voice dictation, Opper and Amazon Bedrock, correct DeepSeek V4 numbers, and a set of opt-in protections for model traffic that passes through a relay. It also fixes a SQLite locking bug behind occasional "database disk image is malformed" errors and folds in three weeks of community work. Highlights …View on GitHub ↗ -
Release notes excerpt
DeepCode v2.2.0 makes long sessions dependable and puts the model under your control: sessions survive resume, compaction, and a second window; settings, models, and reasoning are declared rather than guessed; sub-agents and MCP servers start when needed and stop cleanly; and the Desktop speaks Simplified Chinese. It also folds in a month of community fixes and security hardening. Highlights …View on GitHub ↗
FAQ
What is required before the first run?
deepcode init, configure at least one provider API key.Which model providers are documented?
apiBase for OpenAI-compatible endpoints.Can it change files in my project?
write, edit, and apply_patch capabilities that can read and modify workspace files and run commands; use an appropriate workspace and permission policy.How can it be used in CI or automation?
python -m cli.exec_cli "task" --json for a one-shot task. The README states that this command streams machine-readable NDJSON events.