██████╗ ███████╗███████╗██████╗ ██████╗ ██████╗ ██████╗ ███████╗ ██╔══██╗██╔════╝██╔════╝██╔══██╗██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██║ ██║█████╗ █████╗ ██████╔╝██║ ██║ ██║██║ ██║█████╗ ██║ ██║██╔══╝ ██╔══╝ ██╔═══╝ ██║ ██║ ██║██║ ██║██╔══╝ ██████╔╝███████╗███████╗██║ ╚██████╗╚██████╔╝██████╔╝███████╗ ╚═════╝ ╚══════╝╚══════╝╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝

DeepCode: Open Agentic Coding

Advancing Code Generation with Multi-Agent Systems

🖥️ Interface Showcase

🖥️ CLI Interface Terminal-Based Development 🚀 Advanced Terminal Experience ⚡ Fast command-line workflow 🔧 Developer-friendly interface 📊 Real-time progress tracking Professional terminal interface for advanced users and CI/CD integration

🌐 Web Interface Visual Interactive Experience 🎨 Modern Web Dashboard 🖱️ Intuitive drag-and-drop 📱 Responsive design 🎯 Visual progress tracking Beautiful web interface with streamlined workflow for all skill levels

🎬 Introduction Video

🎯 Watch our complete introduction - See how DeepCode transforms research papers and natural language into production-ready code

"Where AI Agents Transform Ideas into Production-Ready Code"

• 📰 News
• 🚀 Key Features
• 🏗️ Architecture
• 📊 Experimental Results
• 🚀 Quick Start
• 🤖 nanobot Integration (Feishu Chatbot)
• 💡 Examples
  • 🎬 Live Demonstrations
• ⭐ Star History
• 📄 License

🛠️ [2026-04-17] Stability, Windows compatibility & secrets hygiene update

• 🐛 Code Implementation no longer crashes with name 'LoopDetector' is not defined — added the missing LoopDetector/ProgressTracker imports in both workflows/code_implementation_workflow.py and workflows/code_implementation_workflow_index.py.
• 🪟 Windows: mkdir -p / touch / rm -rf / cp -r / mv now work natively. tools/command_executor.py translates these common Unix file-tree commands via pathlib/shutil on every platform, eliminating the bug where cmd.exe would create a literal -p directory and stall the workflow.
• 🚀 Removed Brave Search end-to-end. All Python code, MCP server config, Dockerfile pre-installs, nanobot integration and docs are scrubbed of brave/BRAVE_API_KEY/WebSearchTool. Web fetching keeps working via the built-in fetch MCP server; bocha-mcp is the recommended search backend.
• 🔌 OpenAI-compatible providers documented. New Quick Start → Configuration snippet shows how to point the openai block at Poe (https://api.poe.com/v1), OpenRouter, or Alibaba DashScope, plus how to set default_model/planning_model/implementation_model (e.g. gpt-5.4).
• 🔐 Secrets hygiene. .gitignore now covers *.secrets.yaml, *.secrets.yml, secrets.json, *credentials*.json, .env, .env.* (with *.env.example whitelisted). mcp_agent.secrets.yaml was also git rm --cached'd so existing checkouts stop tracking it.
• 📝 Launch table fixed. deepcode (no flags) actually starts Docker mode — the README now shows deepcode --local for the no-Docker path and adds explicit Troubleshooting rows for "Docker is installed but not running", Windows GBK encoding, and the issues fixed above.
• 🧹 Misc: auto-create logs/ directory so JSONL logging never fails on a fresh checkout, replace bare except: with except Exception: in agent_orchestration_engine.py (Ruff E722), command_executor MCP tool descriptions now embed the host OS so the LLM picks compatible commands.

🎉 [2026-02] nanobot ✖️ DeepCode. Just chat naturally with openclaw/nanobot to handle your coding tasks:

✦

• nanobot nanobot now powers your agentic coding & engineering! 🤖💻
• Step away from your laptop — make vibe coding even more vibe! Code directly from your phone! 📱✨
• One-command deploy: ./nanobot/run_nanobot.sh → Setup Guide →

_{Feishu Bot in Action — Natural language → Full code generation with setup instructions}

🎉 [2026-02] New Web UI Experience Upgrade!

• 🔄 User-in-Loop Interaction: Support real-time user interaction during workflows - AI asks clarifying questions directly in the chat
• 💬 Inline Interaction Design: Interaction prompts appear naturally within the chat flow for a seamless experience
• 🚀 One-Click Launch: Simply run deepcode to start the new UI (cross-platform: Windows/macOS/Linux)
• 🔧 Improved Process Management: Enhanced service start/stop mechanism with automatic port cleanup
• 📡 WebSocket Real-time Communication: Fixed message loss issues, ensuring proper interaction state synchronization

_{DeepCode New Web UI - Modern React-based Interface}

🎉 [2025-10-28] DeepCode Achieves SOTA on PaperBench!

DeepCode sets new benchmarks on OpenAI's PaperBench Code-Dev across all categories:

• 🏆 Surpasses Human Experts: 75.9% (DeepCode) vs Top Machine Learning PhDs 72.4% (+3.5%).
• 🥇 Outperforms SOTA Commercial Code Agents: 84.8% (DeepCode) vs Leading Commercial Code Agents (+26.1%) (Cursor, Claude Code, and Codex).
• 🔬 Advances Scientific Coding: 73.5% (DeepCode) vs PaperCoder 51.1% (+22.4%).
• 🚀 Beats LLM Agents: 73.5% (DeepCode) vs best LLM frameworks 43.3% (+30.2%).

🚀 Paper2Code Automated Implementation of Complex Algorithms Effortlessly converts complex algorithms from research papers into high-quality, production-ready code, accelerating algorithm reproduction.

🎨 Text2Web Automated Front-End Web Development Translates plain textual descriptions into fully functional, visually appealing front-end web code for rapid interface creation.

⚙️ Text2Backend Automated Back-End Development Generates efficient, scalable, and feature-rich back-end code from simple text inputs, streamlining server-side development.

We evaluate DeepCode on the PaperBench benchmark (released by OpenAI), a rigorous testbed requiring AI agents to independently reproduce 20 ICML 2024 papers from scratch. The benchmark comprises 8,316 gradable components assessed using SimpleJudge with hierarchical weighting.

Our experiments compare DeepCode against four baseline categories: (1) Human Experts, (2) State-of-the-Art Commercial Code Agents, (3) Scientific Code Agents, and (4) LLM-Based Agents.

DeepCode: 75.9% vs. Top Machine Learning PhD: 72.4% (+3.5%)

DeepCode achieves 75.9% on the 3-paper human evaluation subset, surpassing the best-of-3 human expert baseline (72.4%) by +3.5 percentage points. This demonstrates that our framework not only matches but exceeds expert-level code reproduction capabilities, representing a significant milestone in autonomous scientific software engineering.

DeepCode: 84.8% vs. Best Commercial Agent: 58.7% (+26.1%)

On the 5-paper subset, DeepCode substantially outperforms leading commercial coding tools:

• Cursor: 58.4%
• Claude Code: 58.7%
• Codex: 40.0%
• DeepCode: 84.8%

This represents a +26.1% improvement over the leading commercial code agent. All commercial agents utilize Claude Sonnet 4.5 or GPT-5 Codex-high, highlighting that DeepCode's superior architecture—rather than base model capability—drives this performance gap.

DeepCode: 73.5% vs. PaperCoder: 51.1% (+22.4%)

Compared to PaperCoder (51.1%), the state-of-the-art scientific code reproduction framework, DeepCode achieves 73.5%, demonstrating a +22.4% relative improvement. This substantial margin validates our multi-module architecture combining planning, hierarchical task decomposition, code generation, and iterative debugging over simpler pipeline-based approaches.

DeepCode: 73.5% vs. Best LLM Agent: 43.3% (+30.2%)

DeepCode significantly outperforms all tested LLM agents:

• Claude 3.5 Sonnet + IterativeAgent: 27.5%
• o1 + IterativeAgent (36 hours): 42.4%
• o1 BasicAgent: 43.3%
• DeepCode: 73.5%

The +30.2% improvement over the best-performing LLM agent demonstrates that sophisticated agent scaffolding, rather than extended inference time or larger models, is critical for complex code reproduction tasks.

The Challenges:

• 📄 Implementation Complexity: Converting academic papers and complex algorithms into working code requires significant technical effort and domain expertise

• 🔬 Research Bottleneck: Researchers spend valuable time implementing algorithms instead of focusing on their core research and discovery work

• ⏱️ Development Delays: Product teams experience long wait times between concept and testable prototypes, slowing down innovation cycles

• 🔄 Repetitive Coding: Developers repeatedly implement similar patterns and functionality instead of building on existing solutions

DeepCode addresses these workflow inefficiencies by providing reliable automation for common development tasks, streamlining your development workflow from concept to code.

flowchart LR
    A["📄 Research Papers<br/>💬 Text Prompts<br/>🌐 URLs & Document<br/>📎 Files: PDF, DOC, PPTX, TXT, HTML"] --> B["🧠 DeepCode<br/>Multi-Agent Engine"]
    B --> C["🚀 Algorithm Implementation <br/>🎨 Frontend Development <br/>⚙️ Backend Development"]

    style A fill:#ff6b6b,stroke:#c0392b,stroke-width:2px,color:#000
    style B fill:#00d4ff,stroke:#0984e3,stroke-width:3px,color:#000
    style C fill:#00b894,stroke:#00a085,stroke-width:2px,color:#000

DeepCode is an AI-powered development platform that automates code generation and implementation tasks. Our multi-agent system handles the complexity of translating requirements into functional, well-structured code, allowing you to focus on innovation rather than implementation details.

🎯 Technical Capabilities:

🧬 Research-to-Production Pipeline
Multi-modal document analysis engine that extracts algorithmic logic and mathematical models from academic papers. Generates optimized implementations with proper data structures while preserving computational complexity characteristics.

🪄 Natural Language Code Synthesis
Context-aware code generation using fine-tuned language models trained on curated code repositories. Maintains architectural consistency across modules while supporting multiple programming languages and frameworks.

⚡ Automated Prototyping Engine
Intelligent scaffolding system generating complete application structures including database schemas, API endpoints, and frontend components. Uses dependency analysis to ensure scalable architecture from initial generation.

💎 Quality Assurance Automation
Integrated static analysis with automated unit test generation and documentation synthesis. Employs AST analysis for code correctness and property-based testing for comprehensive coverage.

🔮 CodeRAG Integration System
Advanced retrieval-augmented generation combining semantic vector embeddings with graph-based dependency analysis. Automatically discovers optimal libraries and implementation patterns from large-scale code corpus.

• 🧠 Intelligent Orchestration Agent: Central decision-making system that coordinates workflow phases and analyzes requirements. Employs dynamic planning algorithms to adapt execution strategies in real-time based on evolving project complexity. Dynamically selects optimal processing strategies for each implementation step.
  

• 💾 Efficient Memory Mechanism: Advanced context engineering system that manages large-scale code contexts efficiently. Implements hierarchical memory structures with intelligent compression for handling complex codebases. This component enables instant retrieval of implementation patterns and maintains semantic coherence across extended development sessions.
  

• 🔍 Advanced CodeRAG System: Global code comprehension engine that analyzes complex inter-dependencies across repositories. Performs cross-codebase relationship mapping to understand architectural patterns from a holistic perspective. This module leverages dependency graphs and semantic analysis to provide globally-aware code recommendations during implementation.

• 🎯 Central Orchestrating Agent: Orchestrates entire workflow execution and makes strategic decisions. Coordinates specialized agents based on input complexity analysis. Implements dynamic task planning and resource allocation algorithms.
  

• 📝 Intent Understanding Agent: Performs deep semantic analysis of user requirements to decode complex intentions. Extracts functional specifications and technical constraints through advanced NLP processing. Transforms ambiguous human descriptions into precise, actionable development specifications with structured task decomposition.
  

• 📄 Document Parsing Agent: Processes complex technical documents and research papers with advanced parsing capabilities. Extracts algorithms and methodologies using document understanding models. Converts academic concepts into practical implementation specifications through intelligent content analysis.
  

• 🏗️ Code Planning Agent: Performs architectural design and technology stack optimization. Dynamic planning for adaptive development roadmaps. Enforces coding standards and generates modular structures through automated design pattern selection.
  

• 🔍 Code Reference Mining Agent: Discovers relevant repositories and frameworks through intelligent search algorithms. Analyzes codebases for compatibility and integration potential. Provides recommendations based on similarity metrics and automated dependency analysis.
  

• 📚 Code Indexing Agent: Builds comprehensive knowledge graphs of discovered codebases. Maintains semantic relationships between code components. Enables intelligent retrieval and cross-reference capabilities.
  

• 🧬 Code Generation Agent: Synthesizes gathered information into executable code implementations. Creates functional interfaces and integrates discovered components. Generates comprehensive test suites and documentation for reproducibility.

🔧 Powered by MCP (Model Context Protocol)

DeepCode leverages the Model Context Protocol (MCP) standard to seamlessly integrate with various tools and services. This standardized approach ensures reliable communication between AI agents and external systems, enabling powerful automation capabilities.

🎛️ Multi-Interface Framework
RESTful API with CLI and web frontends featuring real-time code streaming, interactive debugging, and extensible plugin architecture for CI/CD integration.

🚀 Multi-Agent Intelligent Pipeline:

Before installing DeepCode, ensure you have the following:

# Check your versions
python --version   # Should be 3.9+
node --version     # Should be 18+
npm --version      # Should be 8+

# macOS (using Homebrew)
brew install node

# Ubuntu/Debian
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

# Windows
# Download from https://nodejs.org/

Choose one of the following installation methods:

# 🚀 Install DeepCode package directly
pip install deepcode-hku

# 🔑 Download configuration files
curl -O https://raw.githubusercontent.com/HKUDS/DeepCode/main/mcp_agent.config.yaml
curl -O https://raw.githubusercontent.com/HKUDS/DeepCode/main/mcp_agent.secrets.yaml

git clone https://github.com/HKUDS/DeepCode.git
cd DeepCode/

curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv --python=3.13
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
uv pip install -r requirements.txt

# Install frontend dependencies
npm install --prefix new_ui/frontend

git clone https://github.com/HKUDS/DeepCode.git
cd DeepCode/

pip install -r requirements.txt

# Install frontend dependencies
npm install --prefix new_ui/frontend

pip install -e .

The following configuration applies to all installation methods (pip, UV, source, and Docker).

Edit mcp_agent.secrets.yaml with your API keys:

# At least ONE provider API key is required
openai:
  api_key: "your_openai_api_key"
  base_url: "https://openrouter.ai/api/v1"  # Optional: for OpenRouter or custom endpoints

anthropic:
  api_key: "your_anthropic_api_key"  # For Claude models

google:
  api_key: "your_google_api_key"     # For Gemini models

# mcp_agent.secrets.yaml
openai:
  api_key: "your_provider_api_key"
  base_url: "https://api.poe.com/v1"            # Poe
  # base_url: "https://openrouter.ai/api/v1"    # OpenRouter
  # base_url: "https://dashscope.aliyuncs.com/compatible-mode/v1"  # Alibaba DashScope

# mcp_agent.config.yaml — pick the model your provider supports
openai:
  default_model: "gpt-5.4"
  planning_model: "gpt-5.4"
  implementation_model: "gpt-5.4"

Edit mcp_agent.config.yaml to choose your preferred LLM provider (line ~106):

# Options: "google", "anthropic", "openai"
# If not set or unavailable, will automatically fallback to first available provider
llm_provider: "google"

Configure web search in mcp_agent.config.yaml:

# For Bocha-MCP (optional) — set in bocha-mcp.env section
bocha-mcp:
  env:
    BOCHA_API_KEY: "your_bocha_api_key_here"

Control document processing in mcp_agent.config.yaml:

document_segmentation:
  enabled: true          # true/false — whether to use intelligent document segmentation
  size_threshold_chars: 50000  # Document size threshold to trigger segmentation

# 1. Install MCP servers globally
npm i -g @modelcontextprotocol/server-filesystem

# 2. Find your global node_modules path
npm -g root

mcp:
  servers:
    filesystem:
      command: "node"
      args: ["C:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js", "."]

# Default search server configuration
# Option: "bocha-mcp"
default_search_server: "bocha-mcp"

# For Bocha-MCP (optional)
bocha-mcp:
  command: "python"
  args: ["tools/bocha_search_server.py"]
  env:
    PYTHONPATH: "."
    BOCHA_API_KEY: "your_bocha_api_key_here"

Choose your preferred launch method:

🐳 Docker (Recommended)	🚀 Local — no Docker	🛠️ Other Methods
No Python/Node needed — everything in container. git clone https://github.com/HKUDS/DeepCode.git cd DeepCode/ cp mcp_agent.secrets.yaml.example \ mcp_agent.secrets.yaml # Edit secrets with your API keys ./deepcode_docker/run_docker.sh Release History Version Changes Urgency Date v1.2.0 本次更新主要包括： DeepCode + nanobot 集成：支持通过 飞书机器人 调用 DeepCode，在聊天中发起论文转代码、对话转代码和任务进度查询，并新增飞书实战截图示例。 文档重构：全面更新 README.md 与 README_ZH.md，优化 Quick Start 结构，新增 nanobot 集成（飞书聊天机器人） 专章，并提供从配置到部署的一站式教程。 此版本重点提升了“在聊天软件中用 DeepCode 写代码”的体验，方便团队在日常协作中直接使用 AI 编程能力。 This release focuses on better chat-based usage and documentation: DeepCode + nanobot integration: You can now use DeepCode directly from a Feishu bot, including paper-to-code, chat-to-code, and task status queries, with new real- Low 2/11/2026 v1.1.0 DeepCode v1.1.0 重磅更新！新增 Docker 容器化支持，一键部署，开箱即用。让代码分析更简单，部署更便捷！ DeepCode v1.1.0 Major Update! Now with Docker containerization support - one-click deployment, ready to use out of the box. Making code analysis simpler and deployment easier! Low 2/9/2026 v1.0.9 DeepCode v1.09 - New UI Update The new React-based web interface is now available with these improvements: Interactive workflow - AI can ask follow-up questions during code generation Streamlined interface - Questions appear directly in the chat for better visibility Cross-platform - Works on Windows, macOS, and Linux with deepcode command Better stability - Improved process handling and automatic port management Run deepcode to try the new interface, or use deepcode --classic for the prev Low 2/4/2026 v1.0.8 Support for Google Gemini official API: DeepCode now supports configuration of Google’s official Gemini API, including full support for Gemini‑3‑pro. 支持 Google Gemini 官方 API 已支持配置 Google Gemini 大模型的官方 API，并完成对 Gemini‑3‑pro 的适配与使用。 Low 11/19/2025 v1.0.7 New Version: 1. We have updated DeepCode’s overall workflow and fixed several issues and bugs previously reported by users. 2. We have improved the robustness of the system and introduced targeted optimizations for models with relatively weaker coding capabilities. 3. Our currently recommended most stable and high‑quality large language models include: Claude 3.5 and above, GPT‑4o and above, and Gemini‑pro. 4. We will continue to iterate, further refining the workflow and robustness, Low 11/18/2025 v1.0.6 **Full Changelog**: https://github.com/HKUDS/DeepCode/compare/v1.0.5...v1.0.6 Low 11/10/2025 v1.0.5 Got a brilliant idea in mind but don’t know where to start? It’s time to let the Agent become your product manager! DeepCode Major Update! We are introducing a brand-new personalized requirements customization feature. It’s a new interactive feature that turns vague ideas into actionable development plans. Instead of requiring you to provide detailed specifications up front, DeepCode’s Agent will: - Ask clarifying questions about your idea. - Break down abstract requirements into c Low 10/2/2025 v1.0.4 ## Key Features - 1. Intelligent Document Segmentation - 2. Memory Optimization **Full Changelog**: https://github.com/HKUDS/DeepCode/compare/v1.0.3...v1.0.4 Low 8/8/2025 v1.0.3 ## New Features - Integrate `bochaai` into the search tool. **Full Changelog**: https://github.com/HKUDS/DeepCode/compare/v1.0.2...v1.0.3 Low 7/25/2025 v1.0.2 ## Hot Fix - Fixed the issue where file conversion would get stuck, and added compatibility for Windows systems. **Full Changelog**: https://github.com/HKUDS/DeepCode/compare/v1.0.1...v1.0.2 Low 7/23/2025 v1.0.1 ## What's Changed * Add pypi-publish.yml by @LarFii in https://github.com/HKUDS/DeepCode/pull/12 **Full Changelog**: https://github.com/HKUDS/DeepCode/compare/v1.0.0...v1.0.1 Low 7/21/2025 v1.0.0 New release! Low 7/21/2025 Dependencies & License Audit Loading dependencies... Similar Packages swing-trading-agentMulti-agent swing trading system — automated screening, research, and execution with backtesting and live trading0.0.0 MaiBotMaiSaka, an LLM-based intelligent agent, is a digital lifeform devoted to understanding you and interacting in the style of a real human. She does not pursue perfection, nor does she seek efficiency; 1.0.0-pre.4 hermes-gate🏛️ Hermes Gate — Terminal TUI for managing remote Hermes Agent sessions with auto-reconnect, detach support, and zero config0.0.0 ComfyUI-LoaderUtils🔄 Optimize model loading in ComfyUI with flexible node connections and controlled sequences for better performance and memory management.main@2026-04-21 Paper2Slides📊 Transform research papers into professional slides and posters seamlessly and quickly with Paper2Slides, saving you valuable time.main@2026-04-21