Coda AI

A workspace-native AI coding agent for VS Code.
Chat with your codebase, delegate multi-step work, review every change, and ship with confidence using the model provider you choose.

Install from Marketplace · Report Issue · GitHub

Why Coda?

Most AI assistants stop at suggestions. Coda is built for the full engineering loop: understand the workspace, plan the work, make edits, run commands, produce review artifacts, and leave you with a clear audit trail.

Give it a task — fix a bug, refactor a module, write tests, review a branch, or prepare a PR — and it can inspect code, edit files, run validations, summarize evidence, and ask before sensitive operations.

Built for real coding sessions

Marketplace Highlights

• Agentic coding with guardrails — Coda can read files, edit code, run commands, inspect Git, and validate changes while keeping approval prompts for risky operations.
• High-trust chat UI — every run can show what changed, what tools ran, what validation happened, and which artifacts were produced.
• Review-ready output — create .coda/reviews/, .coda/execution-reports/, .coda/pr-package.md, and .coda/commit-message.md.
• Project-aware memory — keep durable rules, architecture notes, task state, and memory inside the workspace.
• Bring your own model — use local Ollama, Ollama Cloud with your Ollama key, or hosted providers.

Capabilities

Conversational Intelligence

Ask anything about your codebase. Coda understands project structure, dependencies, and context from your open files — no copy-pasting required.

Autonomous Agent

Switch to Agent mode and hand off multi-step tasks. Coda can:

• Navigate and understand your entire project structure
• Read, create, edit, and refactor files across your codebase
• Execute shell commands, build scripts, and test suites
• Trace code with go-to-definition, find references, and symbol search
• Manage version control — commits, diffs, branches, stash
• Browse external documentation and APIs
• Save and reuse lightweight session notes during agent workflows
• Ask you clarifying questions when needed

Run Summaries & Artifacts

Each agent run can produce a durable summary card in chat with:

• status, duration, model, and token usage
• files changed with line deltas
• tool-call and validation counts
• links to generated artifacts and diffs

The Artifacts panel collects responses, diffs, logs, execution reports, reviews, PR packages, and commit messages so important outputs do not disappear into chat history.

Delivery Workflow

Coda includes command-palette actions for turning agent work into reviewable delivery material:

• Coda: Generate Commit Message
• Coda: Commit Agent Changes
• Coda: Generate PR Package
• Coda: Review Current Changes
• Coda: Start Background Worktree

Project Rules

Initialize .coda/rules.md, .coda/architecture.md, and .coda/tasks.md so repository conventions, architecture notes, and durable task context are automatically included in Coda prompts.

Inline Completions

Ghost-text suggestions as you type — context-aware, powered by your configured model. Toggle on or off from the status bar.

Inline Chat

Press ⌘I to open a floating chat overlay right in your editor. Describe a change in natural language and apply it instantly.

Change Tracking & Review

Every modification is tracked. When the agent edits files, Coda shows inline diff cards, pinned change summaries, and one-click Keep or Undo controls.

Human-in-the-Loop Safety

High-impact operations (for example file deletion and non-safe commands) require your explicit approval. Allow / Skip controls appear directly in chat.

MCP Server Support

Connect any Model Context Protocol server and its tools become available to Coda's agent automatically. Add servers via settings or a .coda/mcp.json file in your workspace — hot-reloads on save.

Real-Time Visibility

Watch the agent work in real time with streaming responses, thought blocks for supported reasoning models, tool steps, file edit cards, and run summaries.

Reasoning Visualization

For models with a hidden reasoning channel (Claude with extended thinking, OpenAI o1/o3, Gemini 2.5/3.x, DeepSeek R1), Coda streams the model's thoughts into collapsible Thought blocks alongside the final answer — so you can see why the agent decided what it did, not just the result.

Supported Providers

Use the model that fits your workflow and budget:

Quick Start

1. Install

Install Coda AI from the VS Code Marketplace. After installation, the Coda icon appears in the Activity Bar on the left.

2. Open the Coda panel

Click the Coda icon in the Activity Bar, or run Coda: Open Chat from the Command Palette (⌘⇧P / Ctrl+Shift+P).

3. Configure your AI provider

Click the ⚙ (settings) icon inside the Coda panel, or run Coda: Configure AI Provider. Enter:

• Provider — choose from the dropdown (OpenAI, Anthropic, Gemini, Ollama, etc.)
• API Key — paste your key; it is stored in VS Code's encrypted SecretStorage, never in plaintext
• Model — leave blank for the provider default, or specify one (e.g. gpt-4o, claude-sonnet-4-5, gemini-2.5-flash)

Provider API key sources: | Provider | Where to get your API key | |----------|---------------------------| | OpenAI | https://platform.openai.com/api-keys | | Anthropic | https://console.anthropic.com/settings/keys | | Google Gemini | https://aistudio.google.com/app/apikey | | Mistral | https://console.mistral.ai/api-keys | | Groq | https://console.groq.com/keys | | xAI | https://console.x.ai | | DeepSeek | https://platform.deepseek.com/api_keys | | Cohere | https://dashboard.cohere.com/api-keys | | OpenRouter | https://openrouter.ai/keys | | Ollama | No key needed — runs locally | | Ollama Cloud | https://ollama.com/settings/keys |

4. Start chatting or use Agent mode

• Chat mode — ask questions about your code
• Agent mode — hand off multi-step tasks; Coda can read, edit, run commands, and iterate autonomously

5. Optional: initialize project guidance

Run Coda: Initialize Project Rules to create .coda/rules.md, .coda/architecture.md, and .coda/tasks.md. Coda automatically injects these files into Chat and Agent prompts so repository conventions, architecture notes, and durable task context travel with the project.

6. Optional: delegate safely in a worktree

Run Coda: Start Background Worktree to spin up an isolated git worktree and branch for a delegated task. Coda writes a task brief under .coda/background-tasks/ in the new worktree, then opens that worktree in a separate VS Code window so the agent can work without touching your current checkout.

Configuration

MCP Server Setup

Model Context Protocol (MCP) servers expose tools that Coda's agent can call automatically — for example, reading GitHub issues, querying a database, or fetching web pages. Once connected, MCP tools appear alongside Coda's built-in tools with no extra configuration.

Method 1 — Workspace file (recommended)

Create .coda/mcp.json in your project root. Coda hot-reloads this file on every save.

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "package-name"],
      "env": {
        "SOME_TOKEN": "your-token-here"
      }
    }
  }
}

Multiple servers example:

{
  "mcpServers": {
    "shadcn": {
      "command": "npx",
      "args": ["-y", "shadcn@latest", "mcp"]
    },
    "next-devtools": {
      "command": "npx",
      "args": ["-y", "next-devtools-mcp@latest"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

Method 2 — VS Code settings

Add to your settings.json (user or workspace scope). This is useful for servers you want available across all projects:

{
  "coda.mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

Priority: coda.mcpServers (settings) takes precedence over .coda/mcp.json. Servers with the same name in both places use the settings version.

Method 3 — Guided setup via Command Palette

Run Coda: Add MCP Server (⌘⇧P / Ctrl+Shift+P) and follow the prompts. Coda writes the entry to .coda/mcp.json automatically.

Popular MCP servers

Verifying servers are connected

1. Open the Command Palette (⌘⇧P / Ctrl+Shift+P)
2. Run Coda: MCP Server Status — lists every configured server, its connection state, and the number of tools discovered
3. If a server shows as stopped, run Coda: Restart MCP Server and select it
4. For detailed logs, open View → Output and select MCP Manager or MCP: server-name from the dropdown

Troubleshooting

Slash Workflows

Use / in the input box to trigger high-leverage agent workflows quickly:

These commands are available in the chat panel autocomplete and route directly to Agent mode.

For /run, /parallel, and /resume, Coda also provides structured mini-forms in the chat input area so you can fill fields instead of typing raw args.

Agent Evals & Model Comparison

Every completed agent run writes a markdown execution report to .coda/execution-reports/ and a normalized JSON trace to .coda/eval-traces/. Traces include the prompt, provider/model, final response, tool calls, tool results, edited files, validation evidence, and quality outcome inputs.

Score captured runs:

npm run build
npm run eval:traces

Use the same task prompt with different configured models, then rerun npm run eval:traces to compare provider/model pass, unverified, and failed rates. Deterministic benchmark scenarios live in eval/agent-benchmarks.json and can be checked with npm run eval:bench.

The chat composer also includes a quick command dock and a keyboard-driven Command Center (⌘K / Ctrl+K) for fast workflow access.

Delivery Workflow

Use the command palette for reviewable delivery artifacts:

• Coda: Generate Commit Message writes .coda/commit-message.md and copies the suggested message.
• Coda: Commit Agent Changes previews the message, asks whether to stage all changes, then commits after confirmation.
• Coda: Generate PR Package writes .coda/pr-package.md with summary, changed files, risks, rollback plan, release notes, diff stat, and links to recent execution reports.
• Coda: Review Current Changes writes .coda/reviews/<timestamp>.md with findings-first review notes, changed files, recent execution reports, and diff context.

Project Rules

Coda can keep durable project guidance in versioned Markdown files:

• .coda/rules.md for coding standards, validation rules, and safety constraints.
• .coda/architecture.md for system shape, conventions, and risky modules.
• .coda/tasks.md for durable active/backlog/done work.

Use Coda: Open Project Rules to edit them at any time.

The chat view also includes an Operator Surface with:

• workflow execution tree (live phase/task visibility)
• artifact panel (diff/log/PR/response outputs)
• context controls (auto/focused/broad workspace context profiles)
• recovery actions (pause, resume, replay, fork, rollback)

Git Integration & Pre-Commit Hooks

Coda integrates deeply with Git to ensure code quality before it reaches your repository:

• Review Staged Changes: Run Coda: Review Staged Changes (Pre-Commit) from the Command Palette to analyze your staged changes for potential bugs, security risks, and style regressions before committing.
• Automated Pre-Commit Hook: Run Coda: Setup Pre-Commit Hook (PR Reviewer) to install a git pre-commit hook. This hook automatically runs Coda's analysis on your staged changes, acting as an automated gatekeeper to keep your main branch pristine.

Persistent Project Memory

Coda features a built-in Persistent Project Memory system that allows the agent to remember project-specific insights across sessions:

• How it works: Coda stores project insights in .coda/memory.json within your workspace.
• Automatic usage: During agent workflows, Coda automatically reads and writes to this memory to recall architecture decisions, coding conventions, known issues, or user preferences.
• Manual tools: The agent can use memoryRead, memorySave, and memorySearch to manage these insights, ensuring that lessons learned in one session are carried over to the next.

Keyboard Shortcuts

Workspace Context & Token Limits

Auto-Context Injection (Agent Mode Only)

In Agent mode, Coda automatically injects relevant code snippets from your workspace into the AI's context window. This enables the AI to make more intelligent decisions without you copy-pasting code.

• 8 code chunks (up to 30K characters) retrieved via hybrid search (BM25 + embeddings)
• Intelligent fallback: If embeddings index isn't ready, BM25-only search is used
• Graceful degradation: If workspace is too large, context injection is automatically disabled with a warning

Provider-Specific Token Limits

Different AI providers have different maximum token limits per request. Coda automatically accounts for these and gracefully degrades if your codebase is too large:

When You See "Workspace Too Large" Warning

This means your codebase is larger than the AI provider's context window can accommodate. Coda will:

1. Disable auto-context injection — the AI won't have relevant code snippets
2. Still work normally — you can still chat, use agent mode, and run tools
3. Solution options:
   • Use a model with a larger context window (Gemini, Claude)
   • Create a .codaignore file to exclude large generated/build folders
   • Split your codebase into smaller logical modules and work on one at a time

Disabling Context Injection

If you prefer to opt-out of automatic context injection, you can:

1. Use Chat mode instead of Agent mode (context injection only works in Agent)
2. Explicitly include files via @filename syntax instead
3. Provide inline code snippets in your messages

Privacy & Security

• Your API key is stored in VS Code's encrypted SecretStorage — never in plaintext settings
• Your code is sent only to your configured AI provider — nowhere else
• No telemetry, no analytics, no tracking
• Fully local when used with Ollama — nothing leaves your machine

_{Built by Express Genix · MIT License}