deepagent-code

DeepAgent Code is an AI coding workspace for work that lasts longer than one prompt. It combines a production coding-agent runtime with durable sessions, connected project memory, live planning, code intelligence, multi-agent collaboration, and human oversight.

You can ask for a small edit, guide a running task without interrupting it, hand over a migration with objective completion criteria, or bring several specialist agents into a decision. DeepAgent keeps the work coherent across turns, restarts, tools, people, and projects.

One Workspace, Three Ways to Work

Choose the collaboration style that fits the task:

Autonomy and permission are independent. Use Read-only, Request approval, or Full access without changing the collaboration mode.

Stay in Control While It Works

DeepAgent is built for active collaboration, not fire-and-forget automation.

• Live steering: send new guidance while a model turn or tool is running. The message is durably admitted and absorbed at the next safe provider-turn boundary without aborting in-flight work.
• Goal steering: guidance sent to an active goal is folded into the next tick, preserving the current tool and plan state.
• Hot plan editing: edit a running or paused goal. Stable step IDs, evidence, completed work, and the new plan version carry into the next tick.
• Explicit queueing: queue a future activity when the instruction should begin after the current activity instead of changing it.
• Pause, resume, take over, or roll back: every long-running workflow has a human control path and a durable audit trail.

Memory You Can Inspect and Govern

DeepAgent does not hide memory in an opaque prompt. Project state lives in typed, versioned documents with provenance, confidence, scope, status, and links.

• Session-private working context stays with the current conversation.
• Project-shared facts and decisions follow the repository.
• User-global preferences can travel across projects.
• Built-in skills and domain packs remain versioned system knowledge.
• Sealed evaluator material stays audit-only and never enters model context.

Learning follows a governed lifecycle: evidence creates a candidate, isolated review or a human decision changes its status, and regression/ablation gates publish a reproducible knowledge snapshot. Rejection reasons remain durable so discarded patterns are not silently relearned.

The Repo & Wiki view makes this system readable. Browse knowledge and execution archives, search across the repository, follow docs-to-code links, inspect lineage, and promote useful run evidence into governed knowledge.

Connected Context, Not a Larger Prompt

DeepAgent connects four views of the project:

1. Code graph: files, symbols, imports, calls, diagnostics, and references.
2. Knowledge graph: strategies, methodologies, facts, skills, and failure dossiers.
3. Project memory: decisions, constraints, environment facts, and learned conventions.
4. Document graph: plans, designs, worklogs, evaluations, run context, and evidence.

The Session V2 runner assembles context from explicit sources under a durable Context Epoch. It selects linked evidence within budget, records why each reference was admitted or rejected, and preserves the current goal, constraints, decisions, open questions, next steps, and relevant files during compaction.

Prompt caching remains effective across long runs: stable system instructions stay byte-stable, while plans, steering, budgets, round results, and other volatile state are appended in a dedicated tail block.

Built for Difficult Work

AI IDE

Query code by symbol and intent instead of guessing file locations. DeepAgent combines LSP definitions, references, call chains, type information, diagnostics, rename previews, and cross-file evidence. Unsaved editor buffers participate in LSP updates, so analysis follows the code you are actually editing.

Domain packs

Composable domain packs add language, framework, platform, hardware, business, and risk expertise without hardcoding it into the core. Packs activate from the problem profile, resolve conflicts with stricter-policy-wins semantics, and are snapshot-locked for reproducible runs.

Specialist agents and Expert Panel

DeepAgent can partition independent work across bounded, isolated workers. Delegated runs persist their identity, generation, owner, lease, phase, terminal state, result, and parent delivery, so an exact retry resumes the same work instead of silently starting another worker. Write-capable subagents receive dedicated worktrees, return compact summaries and artifact references, and leave their full transcripts available for inspection.

Automatic write collaboration follows a durable Git/PR path. Workers commit only their scoped changes; one Reviewer session checks each exact worker SHA, the coordinator performs serial --no-ff merges on the Session branch, and one Senior Reviewer examines the merged batch. Resume, timeout, cancellation, takeover, review feedback, and cleanup are generation-fenced so a stale worker cannot settle or overwrite newer work.

For high-risk decisions, convene an Expert Panel. Correctness, security, performance, architecture, and reproducibility lenses review the same frozen question, debate anonymously for up to three rounds, and feed a deterministic arbiter that preserves minority opinions and fails closed to human review.

Team and agent messaging

Project IM brings people and agents into the same thread. Mention an agent to start a scoped run with project context, stream its progress, inspect its artifacts, and keep the answer attached to the conversation that requested it.

Installation

Note: The deepagent-code npm package is not yet publicly published. Install via the desktop app or the install script below.

# Install script (macOS / Linux)
curl -fsSL https://deepagent.ltd/install | bash

Then run:

deepagent-code
# or use the alias:
deepagent

Adding a Provider

Before you can run a task, DeepAgent Code needs at least one model provider. It supports 75+ providers through the AI SDK and models.dev, plus any OpenAI- or Anthropic-compatible endpoint. Pick whichever path fits how you work.

Desktop app (recommended)

Open Settings → Providers:

• Official providers (OpenAI, Anthropic, DeepSeek, Google, xAI, ZhipuAI/GLM): click Connect, paste your API key.
• Any other provider or gateway: click Connect on Custom provider, paste the Base URL and API key. DeepAgent Code auto-detects the protocol (OpenAI-compatible or Anthropic) and discovers the available models from the endpoint's /models list — you don't have to fill anything else.

Model specs (context window, reasoning) are auto-filled by matching each model against the models.dev catalog. You can reopen a custom provider to override a model's context/reasoning/temperature; those overrides are best-effort and not guaranteed to keep the model working.

Terminal

# Log in to a provider (official providers, or a plugin auth flow)
deepagent auth login

# See what's connected
deepagent auth list

Config file

Providers also live in ~/.deepagent/code/config.jsonc. A custom OpenAI-compatible endpoint looks like this — set discovery: true to have models refreshed from the endpoint at runtime, or list them explicitly under models:

{
  "$schema": "https://deepagent-code.ai/config.json",
  "provider": {
    "myprovider": {
      "name": "My Provider",
      "npm": "@ai-sdk/openai-compatible",
      "discovery": true,
      "options": {
        "baseURL": "https://api.myprovider.com/v1",
        "apiKey": "sk-..."
      }
    }
  }
}

Official-provider keys added via the app/CLI are stored separately in ~/.deepagent/code/auth.json, not in the config file. See the providers guide for the full reference (base URL overrides, headers, per-model config, gateways).

All DeepAgent Code private filesystem data lives under ~/.deepagent/code/, including configuration, credential references, databases, Desktop state, logs, caches, and temporary files. Native secret values remain in the operating system's credential store. Tests use explicit isolated roots and cannot redirect production storage through ordinary environment variables.

Quick Example

Start the agent and give it a task:

deepagent-code run "add rate limiting to /api/users endpoint"

The agent will:

1. Use LSP to find the endpoint definition and understand its structure
2. Check project memory for existing middleware patterns
3. Activate the relevant domain packs (backend API, the project's language)
4. Implement rate limiting following project conventions
5. Run tests, capture diagnostics, and propose a candidate memory: "This project uses express-rate-limit