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

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"

---

📑 Table of Contents

• 📰 News
• 🚀 Key Features
• 🏗️ Architecture
• 📊 Experimental Results
• 🚀 Quick Start
• 💡 Examples
  • 🎬 Live Demonstrations
• ⭐ Star History
• 📄 License

---

📰 News

🎨 [2025-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] 🎉 [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%).

---

🚀 Key Features

🚀 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.

---

📊 Experimental Results

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.

① 🧠 Human Expert Performance (Top Machine Learning PhD)

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.

② 💼 State-of-the-Art Commercial Code Agents

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.

③ 🔬 Scientific Code Agents

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.

④ 🤖 LLM-Based Agents

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.

---

🎯 Autonomous Self-Orchestrating Multi-Agent Architecture

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

Loading

---

🏗️ Architecture

📊 System Overview

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.

---

🔧 Core Techniques

• 🧠 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.

---

🤖 Multi-Agent Architecture of DeepCode:

• 🎯 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.

---

🛠️ Implementation Tools Matrix

🔧 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.

📡 MCP Servers & Tools

🛠️ MCP Server	🔧 Primary Function	💡 Purpose & Capabilities
🔍 brave	Web Search Engine	Real-time information retrieval via Brave Search API
🌐 bocha-mcp	Alternative Search	Secondary search option with independent API access
📂 filesystem	File System Operations	Local file and directory management, read/write operations
🌐 fetch	Web Content Retrieval	Fetch and extract content from URLs and web resources
📥 github-downloader	Repository Management	Clone and download GitHub repositories for analysis
📋 file-downloader	Document Processing	Download and convert files (PDF, DOCX, etc.) to Markdown
⚡ command-executor	System Commands	Execute bash/shell commands for environment management
🧬 code-implementation	Code Generation Hub	Comprehensive code reproduction with execution and testing
📚 code-reference-indexer	Smart Code Search	Intelligent indexing and search of code repositories
📄 document-segmentation	Smart Document Analysis	Intelligent document segmentation for large papers and technical documents

🔧 Legacy Tool Functions (for reference)

🛠️ Function	🎯 Usage Context
📄 read_code_mem	Efficient code context retrieval from memory
✍️ write_file	Direct file content generation and modification
🐍 execute_python	Python code testing and validation
📁 get_file_structure	Project structure analysis and organization
⚙️ set_workspace	Dynamic workspace and environment configuration
📊 get_operation_history	Process monitoring and operation tracking

---

🎛️ 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:

🌟 Intelligence Processing Flow

💡 INPUT LAYER 📄 Research Papers • 💬 Natural Language • 🌐 URLs • 📋 Requirements
🎯 CENTRAL ORCHESTRATION Strategic Decision Making • Workflow Coordination • Agent Management
📝 TEXT ANALYSIS Requirement Processing		📄 DOCUMENT ANALYSIS Paper & Spec Processing
📋 REPRODUCTION PLANNING Deep Paper Analysis • Code Requirements Parsing • Reproduction Strategy Development
🔍 REFERENCE ANALYSIS Repository Discovery		📚 CODE INDEXING Knowledge Graph Building
🧬 CODE IMPLEMENTATION Implementation Generation • Testing • Documentation
⚡ OUTPUT DELIVERY 📦 Complete Codebase • 🧪 Test Suite • 📚 Documentation • 🚀 Deployment Ready

🔄 Process Intelligence Features

🎯 Adaptive Flow Dynamic agent selection based on input complexity

🧠 Smart Coordination Intelligent task distribution and parallel processing

🔍 Context Awareness Deep understanding through CodeRAG integration

⚡ Quality Assurance Automated testing and validation throughout

---

🚀 Quick Start

📋 Prerequisites

Before installing DeepCode, ensure you have the following:

Requirement	Version	Purpose
Python	3.9+	Core runtime
Node.js	18+	New UI frontend
npm	8+	Package management

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

📥 Install Node.js (if not installed)

# 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/

📦 Step 1: Installation

Choose one of the following installation methods:

⚡ Direct Installation (Recommended)

# 🚀 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

🔧 Development Installation (From Source)

📂 Click to expand development installation options

🔥 Using UV (Recommended for Development)

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

🐍 Using Traditional pip

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

pip install -r requirements.txt

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

🔧 Step 2: Configuration

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

🔑 API Keys (required)

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

🤖 LLM Provider (optional)

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"

🔍 Search API Keys (optional)

Configure web search in mcp_agent.config.yaml:

# For Brave Search (default) — set in brave.env section (line ~28)
brave:
  env:
    BRAVE_API_KEY: "your_brave_api_key_here"

# For Bocha-MCP (alternative) — set in bocha-mcp.env section (line ~74)
bocha-mcp:
  env:
    BOCHA_API_KEY: "your_bocha_api_key_here"

📄 Document Segmentation (optional)

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

🪟 Windows Users: Additional MCP Server Configuration

If you're using Windows, you may need to configure MCP servers manually in mcp_agent.config.yaml:

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

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

Then update your mcp_agent.config.yaml to use absolute paths:

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

Note: Replace the path with your actual global node_modules path from step 2.

🔍 Search Server Configuration (Optional)

DeepCode supports multiple search servers for web search functionality. You can configure your preferred option in mcp_agent.config.yaml:

# Default search server configuration
# Options: "brave" or "bocha-mcp"
default_search_server: "brave"

Available Options:

• 🔍 Brave Search ("brave"): Default option with high-quality search results. Requires BRAVE_API_KEY. Recommended for most users.
• 🌐 Bocha-MCP ("bocha-mcp"): Alternative search server. Requires BOCHA_API_KEY. Uses local Python server implementation.

Full MCP server configuration in mcp_agent.config.yaml:

# For Brave Search (default) - around line 28
brave:
  command: "npx"
  args: ["-y", "@modelcontextprotocol/server-brave-search"]
  env:
    BRAVE_API_KEY: "your_brave_api_key_here"

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

💡 Tip: Both search servers require API key configuration. Choose the one that best fits your API access and requirements.

⚡ Step 3: Launch Application

🐳 Docker (Recommended — Easiest Setup)

No need to install Python, Node.js, or any dependencies — everything runs inside the container.

Prerequisites: Install Docker Desktop (includes Docker Engine + Docker Compose).

# 1. Clone the repository (if not already done)
git clone https://github.com/HKUDS/DeepCode.git
cd DeepCode/

# 2. Configure your API keys (see Step 2: Configuration above)
cp mcp_agent.secrets.yaml.example mcp_agent.secrets.yaml
# Edit mcp_agent.secrets.yaml with your API keys

# 3. Start with one command
./deepcode_docker/run_docker.sh        # Build & start (auto-builds on first run)

# Access at http://localhost:8000

Management Commands:

./deepcode_docker/run_docker.sh stop         # Stop the service
./deepcode_docker/run_docker.sh restart      # Restart (after config changes, no rebuild needed)
./deepcode_docker/run_docker.sh --build      # Rebuild (after code changes)
./deepcode_docker/run_docker.sh logs         # View real-time logs
./deepcode_docker/run_docker.sh status       # Check service status
./deepcode_docker/run_docker.sh clean        # Remove containers and images

Or use Docker Compose directly:

docker compose -f deepcode_docker/docker-compose.yml up --build   # Build and start
docker compose -f deepcode_docker/docker-compose.yml up -d        # Start in background
docker compose -f deepcode_docker/docker-compose.yml down         # Stop
docker compose -f deepcode_docker/docker-compose.yml logs -f      # View logs

💡 Config changes don't need rebuild: mcp_agent.config.yaml and mcp_agent.secrets.yaml are mounted as volumes — just edit them and run ./deepcode_docker/run_docker.sh restart.

💡 Windows users: Run docker compose -f deepcode_docker/docker-compose.yml up --build directly if the shell script is not available.

🚀 Using deepcode Command (Local Installation)

# 🌐 Launch the new React-based web interface
deepcode

# Frontend: http://localhost:5173
# Backend API: http://localhost:8000
# Press Ctrl+C to stop all services

📦 Auto Install: On first run, dependencies are automatically installed (pip install for backend, npm install for frontend)

✨ Features: User-in-Loop interaction, real-time progress tracking, inline chat interaction

🛠️ Alternative Launch Methods

🍎 macOS / 🐧 Linux	🪟 Windows
# Using run.sh ./run.sh # Or using Python directly python deepcode.py	# Using run.bat run.bat # Or using Python directly python deepcode.py

# Classic Streamlit UI (all platforms)
deepcode --classic

🖥️ CLI Interface (Advanced Users)

# CLI via Docker (no local Python needed)
./deepcode_docker/run_docker.sh cli

# Or: deepcode --cli

# CLI locally (requires Python environment)
python cli/main_cli.py

🎯 Step 4: Generate Code

1. 📄 Input: Upload your research paper, provide requirements, or paste a URL
2. 🤖 Processing: Watch the multi-agent system analyze and plan
3. ⚡ Output: Receive production-ready code with tests and documentation

---

🔧 Troubleshooting

❓ Common Issues & Solutions

🐳 Docker build fails with tsc: not found

node_modules/.bin/tsc: line 1: ../typescript/bin/tsc: not found

Cause: Corrupted Docker build cache.

Fix: Clear the cache and rebuild:

docker builder prune -f
docker compose -f deepcode_docker/docker-compose.yml build --no-cache
docker compose -f deepcode_docker/docker-compose.yml up -d

🐳 Docker command returns error during connect / cannot find the file specified

Cause: Docker Desktop is not running.

Fix: Start Docker Desktop from the Start menu (Windows) or Applications (macOS), wait until it's fully ready, then retry.

🌐 Frontend displays abnormally or shows a blank page

Cause: Corrupted node_modules — frontend dependencies are incomplete.

Fix: Reinstall frontend dependencies:

cd new_ui/frontend
rm -rf node_modules
npm install

Then rebuild (for Docker) or restart (for local mode).

🌐 Browser shows ERR_CONNECTION_REFUSED or JSON response instead of UI

Cause: Accessing the wrong port or backend not running.

Fix:

• Docker mode (deepcode): Access http://localhost:8000. Make sure the container is running: docker ps
• Local mode (deepcode --local): Access http://localhost:5173 (not 8000). Port 5173 is the frontend dev server.

📦 npm install fails with Could not read package.json

Cause: Running npm install in the project root instead of the frontend directory.

Fix: Run it in the correct directory:

npm install --prefix new_ui/frontend

🪟 Windows: MCP servers not working

See the Windows MCP Server Configuration section above for setting up absolute paths.

---

💡 Examples

🎬 Live Demonstrations

📄 Paper2Code Demo Research to Implementation ▶️ Watch Demo Transform academic papers into production-ready code automatically

🖼️ Image Processing Demo AI-Powered Image Tools ▶️ Watch Demo Intelligent image processing with background removal and enhancement

🌐 Frontend Implementation Complete Web Application ▶️ Watch Demo Full-stack web development from concept to deployment

🆕 Recent Updates

📄 Smart Document Segmentation (v1.2.0)

• Intelligent Processing: Automatically handles large research papers and technical documents that exceed LLM token limits
• Configurable Control: Toggle segmentation via configuration with size-based thresholds
• Semantic Analysis: Advanced content understanding with algorithm, concept, and formula preservation
• Backward Compatibility: Seamlessly falls back to traditional processing for smaller documents

🚀 Coming Soon

We're continuously enhancing DeepCode with exciting new features:

🔧 Enhanced Code Reliability & Validation

• Automated Testing: Comprehensive functionality testing with execution verification and error detection.
• Code Quality Assurance: Multi-level validation through static analysis, dynamic testing, and performance benchmarking.
• Smart Debugging: AI-powered error detection with automatic correction suggestions

📊 PaperBench Performance Showcase

• Benchmark Dashboard: Comprehensive performance metrics on the PaperBench evaluation suite.
• Accuracy Metrics: Detailed comparison with state-of-the-art paper reproduction systems.
• Success Analytics: Statistical analysis across paper categories and complexity levels.

⚡ System-wide Optimizations

• Performance Boost: Multi-threaded processing and optimized agent coordination for faster generation.
• Enhanced Reasoning: Advanced reasoning capabilities with improved context understanding.
• Expanded Support: Extended compatibility with additional programming languages and frameworks.

---

⭐ Star History

Community Growth Trajectory

---

🚀 Ready to Transform Development?

---

📖 Citation

If you find DeepCode useful in your research or applications, please kindly cite:

@misc{li2025deepcodeopenagenticcoding,
      title={DeepCode: Open Agentic Coding},
      author={Zongwei Li and Zhonghang Li and Zirui Guo and Xubin Ren and Chao Huang},
      year={2025},
      eprint={2512.07921},
      archivePrefix={arXiv},
      primaryClass={cs.SE},
      url={https://arxiv.org/abs/2512.07921},
}

---

📄 License

MIT License - Copyright (c) 2025 Data Intelligence Lab, The University of Hong Kong

---