In the AI era, code generation is no longer a simple "translation" of text but a complex engineering task: extracting algorithmic logic from academic papers, building front‑end interfaces and back‑end services, and then testing and deploying — each step requires expert‑level coordination. Traditional tools like GitHub Copilot or Cursor are efficient but often remain at the level of "code completion," struggling with cross‑modal inputs (such as PDF papers) or full‑stack implementation. In October 2025, the University of Hong Kong Data Science Lab (HKUDS) officially open‑sourced DeepCode — an open multi‑agent coding system focused on "agentic coding," supporting Paper2Code (paper‑to‑code), Text2Web (text‑to‑web frontend) and Text2Backend (text‑to‑backend service). The project centers on a self‑coordinating multi‑agent architecture and achieved SOTA on OpenAI's PaperBench, outperforming human experts by 3.5% and leading commercial code agents by 26.1%. Released under an MIT license, DeepCode lowers the barrier to AI‑driven code generation and provides research and product teams an end‑to‑end solution for turning ideas into prototypes. This article, based on the GitHub repository, HKUDS official documentation and a GTC 2025 presentation, analyzes its features, architecture, performance, usage and future potential, revealing how this "AI full‑stack engineer" may reshape the software development ecosystem.
Project Background and Mission: Bridging the Paper‑to‑Code Gap
DeepCode grew out of HKUDS's long‑term research into AI for Science. In traditional research cycles, implementing code after a paper is published can take months, with researchers spending significant time on repetitive implementation rather than innovation. The project's slogan, "AI Agents Transform Ideas into Production‑Ready Code," targets this pain point: converting natural language, paper PDFs or URLs into deployable code covering algorithm implementation, front‑end UI and back‑end logic. It is not a single LLM tool but a multi‑agent system that simulates an expert team for planning, analysis, generation and verification.
The project carries three missions: accelerating scientific reproduction (e.g., ICML 2024 benchmarks); simplifying product prototyping (rapid web app iteration); and empowering the open‑source community. It supports languages such as Python and is compatible with models including Claude 3.5 Sonnet and GPT‑5. A GTC 2025 demo video shows DeepCode producing a complete web application from a paper input in about 10 minutes, far faster than manual coding that can take weeks. As of November 2025 the repository has over 8,000 stars and 1,200 forks, with high activity.
Core Features: The Three Pillars — Paper2Code, Text2Web, Text2Backend
DeepCode's feature matrix covers the full coding pipeline, accepting diverse inputs (papers, text, URLs, files) and producing production‑ready artifacts (code + tests + docs).
1. Paper2Code: an "intelligent reproducer" from paper to code
Primary scenario: generate runnable code from ArXiv papers. Users upload a PDF or URL; the system parses algorithms, mathematical formulas and pseudocode, and outputs optimized implementations.
- Workflow: a document‑parsing agent extracts logic; a planning agent decomposes tasks; a code‑generation agent composes modules; a testing agent verifies results.
- Highlights: supports multiple frameworks (e.g., PyTorch, TensorFlow) while preserving computational complexity. Example: generating a Transformer variant from an ICML 2024 paper, including data structures and hyperparameters.
- Performance: 73.5% on PaperBench, outperforming PaperCoder by 22.4%.
2. Text2Web: the "UI magician" turning text into web front‑ends
Generates interactive web applications from descriptions. For input like "build an e‑commerce homepage with a cart and search bar," it outputs React/Vue code plus CSS.
- Workflow: an intent agent parses requirements; a reference agent mines templates; a generation agent builds a component tree; a debugging agent optimizes responsiveness.
- Highlights: integrates Tailwind CSS and Next.js, supports dynamic rendering. Example: generating a full responsive blog with SEO and PWA features from a description.
- Advantage: supports Figma import, reducing friction between designers and developers.
3. Text2Backend: the "service weaver" building back ends from text
Constructs APIs, databases and microservices. Input such as "design a user authentication backend with JWT and PostgreSQL" yields Node.js/Flask code plus deployment scripts.
- Workflow: an architecture agent designs ER diagrams; an indexing agent checks compatible libraries (e.g., Express, SQLAlchemy); an implementation agent generates routes/models; a security agent integrates OAuth.
- Highlights: supports Docker containerization and auto‑generates Swagger documentation. Example: generating a RESTful API for an inventory management system with caching and error handling.
- Performance: compatible with the MCP protocol and highly extensible.
These features are unified under multi‑modal input support: PDF/DOC/PPTX/HTML/TXT inputs and Git‑ready repository outputs.
Technical Architecture: Self‑Coordinating Multi‑Agent System Enabled by MCP
The core of DeepCode is a self‑coordinating multi‑agent architecture that simulates an expert team: a central coordinator makes decisions while sub‑agents handle specialized tasks.
Agent roles:
- Central coordinator: assesses input complexity, dynamically plans tasks and allocates resources.
- Intent understanding agent: NLP parses requirements and extracts specifications/constraints.
- Document parsing agent: processes papers and extracts algorithms/formulas.
- Code planning agent: designs architecture and selects stacks (e.g., Django/Flask).
- Reference mining agent: searches GitHub repositories and checks compatibility.
- Code indexing agent: builds knowledge graphs for semantic retrieval.
- Code generation agent: synthesizes code and integrates components.
- Testing/debugging agent: generates unit tests and fixes bugs.
Core technologies:
- MCP protocol: Model Context Protocol standardizes tool calls and supports 15+ services such as Brave search, file systems and GitHub downloads, ensuring reliable inter‑agent communication.
- CodeRAG: retrieval‑augmented generation that combines vector embeddings and dependency graphs with 98% compatibility.
- Memory mechanisms: hierarchical semantic storage to handle long contexts with 70% compression.
- Quality assurance: AST analysis plus property‑based testing with 95% coverage.
The architecture flow is: input layer → coordination layer → analysis layer → implementation layer → output layer, with iterative debugging. It supports Claude 3.5 Sonnet and gpt‑4o1 with API key configuration.
Performance and Benchmarks: PaperBench SOTA, Surpassing Experts by 3.5%
DeepCode set records on OpenAI PaperBench (ICML 2024 benchmark of reproducing 20 papers):
- Overall score: 75.9%, above experts at 72.4% (+3.5%).
- Commercial agents: 84.8% vs Cursor/Claude 58.7% (+26.1%).
- Scientific agents: 73.5% vs PaperCoder 51.1% (+22.4%).
- LLM agents: 73.5% vs o1 43.3% (+30.2%).
Evaluated across 8,316 components (SimpleJudge layered weighting), DeepCode leads in planning, generation and debugging. A human expert (ML PhD) may require 36 hours, while DeepCode completes the task in about 2 hours.
Features and Advantages: The Three Pillars — Open, Autonomous, Reliable
- Self‑coordination: agents dynamically adjust strategies without human intervention.
- Open and transparent: MIT license, active GitHub repository and community contributions.
- Multi‑modal input: accepts papers, text, URLs and files and outputs complete repositories.
- Strong compatibility: MCP integrates 15+ tools and extends to CI/CD.
- Efficiency gains: reduces time from concept to prototype by up to 90% and achieves 95% test coverage.
Compared with Copilot, DeepCode handles complex papers while Copilot is geared toward completion.
How to Use: From Installation to "Zero‑Code" Generation
Installation (UV recommended):
git clone https://github.com/HKUDS/DeepCode.git cd DeepCode uv venv --python=3.13 uv pip install -r requirements.txt
Configure API keys (mcp_agent.secrets.yaml): OpenAI/Anthropic keys.
Optional: Brave/Bocha search APIs (mcp_agent.config.yaml).
Start:
- Web UI: streamlit run ui/streamlit_app.py (localhost:8501).
- CLI: python cli/main_cli.py.
Example:
- Input a PDF paper or text like "build an e‑commerce homepage."
- The system parses → plans → generates React + Node.js code and tests.
- Output: a Git‑ready repository including Docker deployment.
Demo video: paper to web application in 10 minutes.
Future Plans: From Prototype to Ecosystem
v1.2.0 added document splitting; coming features include an A/B testing dashboard, CI/CD plugins and broader language support. Contributions welcome via forks and PRs, with roles from contributor to core developer.
Conclusion: DeepCode — a New Open‑Source Era for AI Coding
With multi‑agent autonomy, DeepCode reshapes code generation from papers to full‑stack prototypes. PaperBench SOTA results demonstrate its potential to outperform experts. As an HKUDS open‑source project it delivers multiple SOTA advances, lowering barriers for research reproduction, accelerating scientific innovation and supporting AI for Science. For details, visit GitHub: DeepCode: Open Agentic Coding and join the revolution of turning ideas into code.