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

DeepCode: Open Agentic Coding

Advancing Code Generation with Multi-Agent Systems

🖥️ Interface Showcase

🖥️ DeepCode Desktop

Work with DeepCode in a visual workspace for Sessions, goals, tool activity, code changes, and verification.

DeepCode provides TUI, Desktop, and Web clients over one shared local service. They share Projects, Session history, models, Skills, permissions, Goals, and Automations. Use deepcode, deepcode desktop, or deepcode web; see Quick start for installation and your first task.

---

🎬 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
• 🧠 What Deep means in DeepCode
• 🚀 Core capabilities
  • Work directly in your repository
  • Goal-driven Loop Engineering
  • Evidence-driven completion
  • Durable Sessions and project context
  • Your models, your reasoning settings
  • Reusable Skills
  • Permissions you can understand
  • Parallel agents without file collisions
  • Automate repeatable engineering work
  • Paper2Code
• ⚡ Quick start
  • Launch commands at a glance
  • Install the runtime
  • Configure a model
  • Start the TUI
  • Start Desktop
  • Start Web
  • Complete your first task
  • Manage the shared background service
• 🧭 Using DeepCode
• ⚙️ Headless and automation
• 🔬 Paper2Code
  • The original architecture
  • Research results
• 🎬 Live demonstrations
• 🛠️ Development
• ⭐ Star History
• 🙏 Appreciation
• 📖 Citation
• 📄 License

News

2026-09-28 · DeepCode v2.3.0: voice dictation, Opper and Bedrock, Desktop polish, and opt-in hardening

• Dictate your prompt. Add a dictation block to your config and the Desktop and Web composer gains a microphone. See Voice dictation. (#240)
• More providers and models. Opper and Amazon Bedrock join the provider templates, and DeepSeek V4 gets its own 1M context window and pricing. (#242, #208, #249)
• Desktop polish. Drag the conversation's edge to resize it, import a VS Code color theme, and choose from fonts that are actually installed. (#238, #207, #239)
• Opt-in hardening. providers.egress limits which hosts receive your prompts, DEEPCODE_COMMAND_SCREEN=strict screens risky commands, DEEPCODE_BASH_SCRUB_ENV=1 keeps provider keys out of shell commands, and DEEPCODE_KEYRING=1 reads keys from the OS keychain. (#229, #230, #232, #246)
• Leaner memory and clearer signals. MEMORY.md can be a short index of topic files, mcp list flags servers worth a second look, and the agent is reminded when a call keeps returning the same result. (#233, #241, #247)
• Steadier everywhere. The state database keeps its locks when several DeepCode processes share it, and a round of Windows fixes landed. (#210, #235, #236, #237)

2026-09-09 · TUI, Desktop, and Web share one local background service

• Choose your interface. Run deepcode for the TUI, deepcode desktop for the native app, or deepcode web to open the workbench in your browser. All three connect to the same local service; Web needs no DeepCode account.
• Continue the same task across interfaces. Closing a client leaves running work in the background. Reconnect from another interface to follow the same conversation, review tool activity, and respond to approvals. The computer must remain awake, and pending approvals still need your response.
• Configure and verify your models. Save cloud or local model connections for use across all three interfaces. Browse available models, check a model's response, and test streaming and tool calls before using a custom server. See Models and providers.
• Manage your background service and prepare for upgrades. Use deepcode service commands to check status, read logs, or stop after current work finishes. Create a runtime snapshot before upgrading and restore it when needed; keep project files in your usual version control or backup. See Upgrading DeepCode.

Start with the updated Quick start and first coding task tutorial. (#212)

2026-09-06 · DeepCode v2.2.0: Session context-window caps, compaction that leaves a memory, and a fully localized Desktop

• Cap a Session's context window. /context 64k in the TUI or the preset next to the Desktop model picker narrows the model's published window for future Turns; the cap is frozen into each accepted Turn and feeds the compaction gate directly. /context auto follows the model again. (#203)
• Compaction leaves a note in memory, and memory notes cannot escape their boundary. A compaction summary is deposited into the workspace memory on a background thread, and injected memory content is wrapped in an <untrusted-data> boundary whose closing tags are escaped, so a poisoned note cannot forge instructions. (#204)
• Appearance settings speak Simplified Chinese too, completing the Desktop shell's zh-CN coverage. (#202)

What Deep means in DeepCode

Most Coding Agents can generate code. The hard part is understanding a real project, making changes within the right boundaries, continuously correcting course from runtime results, and making it clear why the outcome can be trusted.

DeepCode is an open-source Coding Agent for real software engineering. Give it a simple change or a goal that takes dozens of steps. It can understand the project, work on the code, run tools, verify results, and continue after an interruption, restart, or model switch.

“Deep” represents four kinds of depth that remain with the task from start to finish:

DeepCode stands out in three ways:

• Turn complex knowledge into a working system. DeepCode is not limited to Issues and code snippets. Paper2Code can start from papers, documents, reference repositories, and experiment goals, then carry the work through understanding, implementation, and verification.
• Keep long tasks moving while staying in control. A Goal is not a one-shot prompt. Add requirements, revise the Goal, pause, stop, or continue while the task is running without losing completed work.
• Take code changes through verification and review. DeepCode goes beyond generating a patch. It runs the commands and tests the task requires, inspects build results and file changes, and links the Goal outcome to relevant execution records for review.

DeepCode is not designed to make an Agent look busier. It is designed to help you finish real software engineering work more reliably.

Core capabilities

DeepCode provides a complete local Coding Agent workflow. TUI, Desktop, and Web use the same Agent, Sessions, models, Skills, permissions, and task state through the shared local service.

Work directly in your repository

DeepCode can read and search code, edit files, apply patches, run commands and tests, and continue working from the results. Tool calls, execution progress, and file changes stay visible, so you can see what the Agent did and what changed in the project.

Use it to explain code, fix bugs, and add tests—or for cross-file refactors, feature development, and longer repository-level tasks.

When you provide a public HTTP or HTTPS URL, the shared web_fetch tool can read the page without a search provider or an additional API key.

Goal-driven Loop Engineering

For work that cannot be completed in one response, give DeepCode a natural- language Goal. The Agent keeps analyzing, implementing, verifying, and fixing around that Goal without requiring you to push every step manually.

While it runs, you can still:

• add information to the current task;
• revise the Goal or its acceptance criteria;
• queue the next instruction;
• pause, stop, or continue the task;
• resume the same Goal after leaving the application.

Automatic execution does not take away your control. You can always change what should happen next.

Evidence-driven completion

DeepCode does not use one hard-coded rule to judge every Coding task. It selects evidence that fits the task, such as test results, build output, static checks, diagnostics, file changes, Diffs, or generated Artifacts.

A failed verification is not presented as success. It becomes input to the next repair. When a task is complete—or genuinely blocked—the result, reason, and related evidence remain in the Session for review and reproduction.

Durable Sessions and project context

Every Session is stored locally and linked to its original project. Start DeepCode from any directory, find earlier projects and Sessions, and continue the same work in CLI or Desktop.

A Session stores more than chat text: it keeps tool calls, permission decisions, Goals, model configuration, and verification records. Project rules, persistent memory, Skills, and long-conversation compaction help the Agent keep context throughout complex work.

Your models, your reasoning settings

DeepCode is not tied to one model provider. Connect OpenRouter, OpenAI, Anthropic, DeepSeek, Gemini, an OpenAI-compatible gateway, Ollama, vLLM, or another compatible endpoint with your own API Key.

Before use, a connection can check credentials, the model catalog, and a real inference request. Each Session can choose a model and Thinking Level. Changing models mid-Session affects future Turns only; it does not delete history or confuse where earlier work came from. When supported, DeepCode can also show a reasoning summary returned by the Provider.

Reusable Skills

Skills turn team conventions, domain knowledge, review methods, and repeated workflows into reusable Agent capabilities. DeepCode includes pinned upstream Skills for authoring, review, security, frontend, MCP, and web testing workflows. Keep project Skills in .agents/skills, keep personal Skills in ~/.agents/skills, or use the bundled Skill Creator to build one conversationally.

DeepCode also reads existing .deepcode/skills and Claude-style directories without migrating them. A Skill can guide how the Agent works, but it cannot bypass project trust, tool permissions, or safety boundaries.

Permissions you can understand

Every project must be explicitly trusted before execution. Each Session can use one of three modes:

• Ask: confirm sensitive operations before they run;
• Read only: allow analysis and reading only;
• Full access: allow complete work in a trusted project.

Individual tools also support allow, ask, and deny. CLI and Desktop share the same permission state, and DeepCode does not silently replay operations with side effects after a task is stopped or interrupted.

Parallel agents without file collisions

Complex work can be split across focused Agents—for example, separate Agents for code investigation, test analysis, and implementation review.

Parallel changes can run in isolated Git worktrees so Agents do not edit the same working directory at once. Results return to the main task for review and integration. Conflicts are shown explicitly instead of being silently overwritten, and the main Agent remains responsible for the final Goal.

Automate repeatable engineering work

Once a workflow is stable, save it as an Automation and run it manually or on a schedule. For example:

• check tests and builds regularly;
• scan for regressions;
• organize pending work;
• run repository maintenance or periodic reviews.

Automation does not launch a separate, reduced Agent. It uses the same Sessions, models, Skills, permissions, approvals, and recovery behavior, and keeps the history of every run.

Shared background service

Desktop, Web, TUI, exec, loop, and MCP task calls use the same local service. Starting a client starts the service when needed. Closing a client leaves its accepted tasks running; explicitly stop the service to shut down the runtime. See Quick start for installation and launch commands.

Paper2Code

Paper2Code was DeepCode's original research direction and remains its dedicated workflow for research reproduction.

It can start from a paper, technical document, URL, or reference repository; understand the research goal; find related implementations; organize a development plan; generate code; and verify the result through experiments and Artifacts. It reflects DeepCode's core idea: the goal is not to generate code that merely looks correct, but to turn complex knowledge into a system that can run, be inspected, and keep improving.

Quick start

Use DeepCode to explore a repository, make changes, and run tests. Choose the terminal, desktop app, or browser—your projects and conversations are available in all three.

Launch commands at a glance

After installation, open the interface you prefer:

DeepCode starts its local background service automatically. You can close an interface and return to your conversation later.

Install the runtime

Published package

With uv installed, run:

uv tool install --python 3.12 deepcode-hku
deepcode init

On Windows, you can install uv with winget install --id astral-sh.uv --exact, then open a new terminal. DeepCode requires Python 3.12 or later.

To use the native app, also install DeepCode Desktop from GitHub Releases. To try changes that have not been released yet, install from source below.

git clone https://github.com/HKUDS/DeepCode.git
cd DeepCode
npm --prefix desktop ci
npm --prefix desktop run build:web
uv tool install --python 3.12 --force .
deepcode init

If your terminal cannot find deepcode, run uv tool update-shell and open a new terminal.

Configure a model

Choose either the graphical setup or the terminal commands below.

In Desktop or Web: open Settings → AI providers, select Add provider, and enter your provider's API key. Click Save and check to load its models. Under Agent model, choose a model and click Save and verify model to try a short request. Then choose the connection and model in your conversation's message box.

In your terminal: this example connects to OpenRouter. Enter your API key when prompted; it will not be displayed as you type.

deepcode provider set my-openrouter --template openrouter --api-key
deepcode provider models my-openrouter --refresh

Choose a model from the list. Replace MODEL_ID below with its exact ID and send a short test request:

deepcode provider test my-openrouter --model MODEL_ID

You can use the same connection in all three interfaces. For other providers, local models, and tool-calling checks, see Models and providers.

Start the TUI

Open a terminal in the project you want to work on. On your first visit, use --trust to allow DeepCode to work in that folder. With the connection configured above:

cd /path/to/your-project
deepcode --trust --connection my-openrouter --model MODEL_ID

Replace the path with your project directory; on Windows, for example, C:\projects\my-app. For later visits, run deepcode in that directory and use /model to choose your connection and model. Use /help to see available commands.

Start Desktop

deepcode desktop

Add your project folder, confirm that you trust it, and click New thread. Choose a model in the message box, then describe what you want to do.

If you installed from source, this command opens the development app. Its first launch may take longer while dependencies are prepared; keep the terminal open while you use it. See the Desktop guide for platform setup and custom installation paths.

Start Web

deepcode web

DeepCode opens a browser tab. Add your project folder on this computer, confirm that you trust it, and create a thread. Select a model and send your first message. No DeepCode account is needed.

To copy the access link and open it yourself, use deepcode web --no-open. Open the link within 60 seconds. If it expires or the page asks you to sign in again, run deepcode web to get a fresh link.

Complete your first task

Start by asking DeepCode to help you understand your project:

Explain how this project is organized and how to run its tests.
Do not change any files yet.

Then ask for a small change, describing the behavior you want and how to check it:

Add tests for the configuration loader's handling of missing and invalid
values. Follow the existing test style, run the relevant tests, and summarize
the changes and results.

Adapt the task to your repository. Follow the tool activity as DeepCode works, respond to any approval requests, and review the changed files and test output. You can send a follow-up message to adjust the task, or use the stop button (/stop in the TUI) to interrupt it.

Your conversation is saved automatically. In Desktop/Web, select it from the project's thread list. In the TUI, use /resume to pick a saved conversation. You can switch interfaces and continue the same task.

For a complete exercise in a new folder, follow Your first coding task. It takes you through creating a Python function, testing it, and returning to the conversation later.

Manage the shared background service

Closing an interface leaves running tasks in the background. Pending approvals still need your response, and the computer must remain awake for work to continue.

Most days, you can just launch your preferred interface. When you need to inspect or stop the background service, use the command for that action:

For updates and backups, follow Upgrading DeepCode. If something does not work, start with Troubleshooting.

Using DeepCode

Prefer a guided walkthrough? The teaching guides cover the same ground page by page — first session, the TUI, sessions, models, skills and memory, and headless automation — with worked examples.

Sessions

Every task lives in a durable Session attached to its original Project. Open a Project in Desktop or start deepcode from its directory, then create a new Session or resume an existing one. The same history is available in TUI, Desktop, and Web without export or conversion.

Session history, tool activity, approvals, Goal state, and verification evidence remain together. TUI, Desktop, and Web can observe the same Session while the shared service serializes its execution. Normal input during a Turn steers the active work; explicit queueing requests a subsequent Turn. The interface reports how the input was accepted. Closing a client leaves accepted work running. Archiving hides a Session without deleting its history; permanent deletion removes the Session records but never repository files.

Connections and models

Desktop provides connection setup and verification under Settings → AI providers. In the CLI, /model changes the connection and model for future Turns, while /effort selects a Thinking level supported by that model. Use the model picker's context control, or /context 64k in the TUI, to make future Turns compact history sooner; /context auto restores the model's published window.

Model changes never rewrite earlier history or alter an active Turn. Thinking effort controls the request sent to the provider; transcript detail controls only presentation. DeepCode shows provider-designated reasoning summaries when available and never merges raw chain-of-thought into the assistant answer.

Provider administration, environment-variable credentials, custom gateways, model discovery, and machine-readable checks are documented in the Headless and Automation guide.

Skills

Skills turn reusable engineering knowledge into instructions the Agent can load for a task. Desktop provides a Skills workspace; the interactive CLI uses /skills to discover them and /skill <name> to select one for the next Turn. Choose Skills → Create Skill in Desktop or invoke $skill-creator in CLI to create and validate one through a normal Agent Turn.

Project Skills in .agents/skills travel with a repository; user Skills in ~/.agents/skills remain available across Projects. Existing DeepCode and Claude-compatible directories remain readable. A Skill can guide the Agent, but it cannot grant permissions or bypass Project trust, approvals, or tool policy. Import, enable, disable, and catalog commands live in the advanced guide.

Local Plugins

Plugins optionally package Skills behind a validated local manifest; standalone project and user Skills continue to install and run without a Plugin. New packages must use the Agent Plugins 1.0.0 manifest and fixed skills/ layout. Add a trusted folder from the Desktop Plugins workspace or with deepcode plugin add <path>; its Skills then appear in the ordinary Skill catalog and Composer. A standards-compliant mcp.json may also contribute MCP servers; registration remains inert and those processes start only inside an Agent Session. DeepCode does not execute Plugin hooks or Apps and does not download from a Marketplace. See the local Plugin contract.

MCP servers

Generic coding-agent MCP servers live in the top-level mcpServers section of deepcode_config.json; the historical Paper2Code tools.mcpServers section is kept separate. Configure servers in Desktop under MCP, or use the compact deepcode mcp CLI. The bundled catalog is listed with deepcode mcp presets; add <id> copies a disabled definition, test <name> performs a real handshake, and login/logout <name> manages explicit browser OAuth. The TUI offers the same actions under the single /mcp command. User and trusted-project layers replace whole server entries rather than merging executable fields. Provider secrets are referenced from private DeepCode connections, and MCP tool policy can only narrow global trust, read-only, approval, and sandbox decisions.

DeepCode supports stdio, SSE, and Streamable HTTP, session-owned startup and shutdown, bounded discovery, stable mcp__server__tool identities, tool annotations, allow/deny lists, per-tool approvals, timeouts, and cancellation. For a concrete two-Skill plus MCP integration, see the OpenSpace guide. Setup, preset, OAuth, and connection-state details are in the MCP client guide.

Safety and execution

DeepCode treats execution as a product boundary rather than a client-side confirmation:

• Projects require explicit trust before Agent execution on every interface.
• Permission decisions are allow, ask, or deny.
• An approval resumes the exact suspended tool call.
• Ask keeps the workspace command sandbox and protected-path checks; Read only denies mutating tools; Full access is an explicit, confirmed Session grant that removes approval and filesystem sandbox boundaries. Explicit deny rules still win.
• CLI and Desktop edit the same Session override. Each admitted Turn freezes the complete resolved security profile: changes apply to new submissions, while active and already queued Turns keep their recorded access after resume or worker handoff.
• Shell and code processes are terminated as owned process trees on timeout, interruption, or shutdown.
• Crash recovery settles incomplete Turns without automatically replaying side effects.

Long-running work

Ordinary prompts can run a full multi-tool coding Turn. When work must continue across several Turns or process restarts, attach a durable Goal to the Session. Use the Goal panel in Desktop or /goal <objective> in the CLI.

While DeepCode works, new input can steer the active Turn. You can edit the Goal, stop the current Turn, queue a follow-up, pause the Goal, or resume it later. These actions preserve the same Session, history, permissions, Skills, and evidence instead of starting an isolated execution.

The working Agent requests complete or blocked from its full context. DeepCode enforces ownership, lifecycle, permission, and budget boundaries, but does not pretend a generic host-side rule can validate every coding task. A normal semantic result is labelled Completed; tests, builds, diagnostics, diffs, or independent review remain visible evidence. No provider, model, task type, or test command is fixed by the Goal engine.

Automations and headless workflows

The Desktop Automation workspace turns a trusted Project instruction into a manual or interval run while keeping the normal Agent, Session, Goal, permissions, recovery, and Run history. Use it for repeatable work such as repository health checks, regression review, or scheduled maintenance.

Shell scripts and CI systems can use the same runtime without opening an interface. The separate Headless and Automation guide contains the exec, loop, Automation, Provider, Skill, and Session administration commands. They are advanced integration surfaces—not a second way ordinary Desktop or CLI users must learn to talk to DeepCode.

Paper2Code

Paper2Code is the research origin of DeepCode and remains its specialized workflow for scientific code reproduction. The general coding Agent extends the product; it does not replace or flatten the original Paper2Code design.

Its central idea is unchanged: reproducing a paper is not a one-shot generation task. A central orchestrator coordinates distinct responsibilities for understanding the source, planning the reproduction, finding and indexing useful references, implementing the system, and verifying the result.

The original architecture

The specialist roles preserve the separation of concerns that made the original system effective:

Four ideas connect those roles into one system:

• Intelligent orchestration. The central Agent chooses and revisits phases according to task state instead of treating reproduction as a fixed prompt chain.
• Document and intent grounding. Papers, specifications, URLs, and attached files are converted into explicit implementation requirements before code is written.
• Memory and CodeRAG. Large documents and reference repositories are segmented, indexed, and retrieved as bounded context rather than repeatedly placed into the model window.
• Iterative verification. Execution, tests, and observed failures feed back into planning and implementation until the deliverable has supporting evidence.

The supporting tool layer follows the same division:

The modern product adds durable plans, explicit plan review, checkpoints, bounded retries, and interactive inspection around this workflow. Those additions make recovery and supervision stronger while preserving the Paper2Code architecture and its order of reasoning.

Research results

The original DeepCode study evaluates scientific code reproduction on PaperBench, which asks agents to reproduce 20 ICML 2024 papers across 8,316 gradable components.

These are PaperBench-specific results reported by the original study. They are not a general-purpose coding benchmark or a comparison against continuously updated products.

Read the paper for methodology, evaluation scope, models, and baseline details.

🎬 Live Demonstrations

These recordings show projects produced by earlier DeepCode workflows. They are output demonstrations rather than screenshots of the current Desktop UI.

📄 Paper2Code Research to implementation ▶ Watch demonstration Reproduce a research paper as an executable project.

🖼️ Generated vision project Image workflow example ▶ Watch demonstration See an earlier generated image-processing workflow in use.

🌐 Generated web project Frontend implementation example ▶ Watch demonstration Follow a complete frontend implementation from idea to result.

The project introduction remains available for a broader walkthrough.

Development

Source installation

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
uv pip install -e .

On Windows PowerShell, activate with .\.venv\Scripts\Activate.ps1.

Verification

To reproduce CI's Python environment and understand each check, see the CI guide.

uvx pre-commit run --all-files
python -m compileall -q app_server cli core tools workflows
deepcode --version
deepcode-app-server --verify-runtime

cd desktop
npm run lint
npm test -- --run
npm run build

Desktop packaging, Rust checks, signing, and release procedures are documented in desktop/README.md and the Desktop release runbook.

The pre-restructure README is preserved in docs/archive/README_LEGACY_2026-07-20.md. The empty product-image slots have a shared capture brief.

⭐ Star History

Community growth trajectory

🚀 Ready to build with DeepCode?

🙏 Appreciation

Thanks to everyone in the open-source community — your stars, issues, pull requests and discussions shape where DeepCode goes next.

Everyone who has opened a pull request is listed in CONTRIBUTORS.md, including contributions that predate the v2.0 rebuild and so are not reflected in the graph above.

📖 Citation

If DeepCode contributes to your research, 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