Coda — AI Coding Agent - Visual Studio Marketplace

Coda AI

The open, auditable AI coding agent that ships real changes — not just suggestions.

Coda is a full-loop engineering agent for VS Code. It reads your codebase, plans the work, edits across files, runs your tests and builds, reviews its own diffs, and hands you a complete, human-approvable audit trail. You bring the model; Coda brings the leverage.

Install from Marketplace · Report Issue · GitHub

Coda AI workspace showing agent progress, tool activity, and run results

Coda keeps the agent's work visible from first tool call to verified result.

Coda in 30 seconds

Coda combines codebase chat, autonomous multi-file editing, inline completions, code review, test execution, and delivery workflows in one VS Code extension. It shows what the agent read, changed, and verified—so teams can move quickly without losing control.

Best for: debugging, refactoring, test generation, branch review, documentation, and shipping governed AI-assisted changes.

Bring your own model: use OpenAI, Anthropic, Gemini, Mistral, Groq, OpenRouter, DeepSeek, Bedrock, Ollama, Ollama Cloud, or another OpenAI-compatible endpoint.

Two ways in, one engine: the Coda panel (Activity Bar) is the full agent workspace — diffs, run summaries, artifacts, approvals. The @coda chat participant in VS Code's native Chat view is a lightweight entry point for quick questions (@coda how does auth work?) and one-shot runs (@coda /agent fix the failing test). Both route through the same backend — same tools, sessions, approvals, and change tracking — so anything the agent does from @coda can be reviewed and undone in the panel.

Why Coda?

Most AI assistants stop at suggestions. Coda runs the full engineering loop — understand the workspace, plan the work, make the edits, run the validations, produce the review artifacts, and leave you with a clear, auditable trail of what changed and why.

Give it a task — fix a bug, refactor a module, write tests, review a branch, or prepare a PR — and Coda inspects code, edits files, runs your toolchain, summarizes the evidence, and asks for approval before anything risky happens.

What sets Coda apart

Ships real changes, safely. Edits are applied to disk and shown as live diff cards you can accept per-file or per-hunk, with one-click keep/undo. Nothing is committed without you.
Auditable by design. Every run leaves a Run Summary — status, duration, files changed with line deltas, tool calls, validations, token cost, and linked artifacts.
Your model, your rules. Bring OpenAI, Anthropic, Gemini, or a local Ollama model. Route chat, agent, inline, and review work to different models. Keep durable project rules, architecture notes, and memory in the repo.
Offline-first retrieval. Coda finds relevant code with local BM25 search plus LSP symbol lookups — no embeddings, no vector DB, no extra token cost, works fully offline.
Gated autonomy. Sensitive operations (deletes, unsafe commands) pause for explicit approval. Delegate big tasks to an isolated git worktree so your working tree stays clean.

Built for real coding sessions

Experience	What you get
Chat + Agent mode	Ask questions or delegate multi-step implementation work
Operator Surface	Live workflow tree, context controls, artifacts, and recovery actions
Run Summary cards	A compact audit trail with status, duration, files changed, tool calls, validations, tokens, and artifacts
Granular diff review	Review changed files from chat, open VS Code diffs, and accept or undo per-file or per-hunk
Delivery artifacts	Generate commit messages, PR packages, execution reports, and review notes under `.coda/`
Smart model routing	Use purpose-specific models for chat, agent work, inline completions, and reviews
Broad provider support	37 providers — OpenAI, Anthropic, Gemini, Azure OpenAI, Google Vertex AI, AWS Bedrock, Mistral, Groq, xAI, Cohere, DeepSeek, Perplexity, Cerebras, Snowflake Cortex, OmniRoute, and many more, plus local Ollama and free tiers

Marketplace Highlights

Agentic coding with guardrails — Coda reads files, edits code, runs commands, inspects Git, and validates changes, while pausing for approval on risky operations.
Granular, reversible diffs — accept or undo edits per-file or per-hunk from the chat, with VS Code's own diff editor one click away.
High-trust, auditable UI — every run shows what changed, what tools ran, what validation happened, and which artifacts were produced.
Review-ready output — generate .coda/reviews/, .coda/execution-reports/, .coda/pr-package.md, and .coda/commit-message.md.
Offline-first retrieval — local BM25 + LSP symbol search; no embeddings, no vector database, no extra cost.
Project-aware memory — durable rules, architecture notes, task state, and cross-session memory live inside the workspace.
Bring your own model — local Ollama, Ollama Cloud, or any hosted OpenAI-compatible provider.

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 File 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 with pinned change summaries and one-click Keep / Undo controls. For surgical control, expand any diff and accept or reject individual hunks — so you can take the good parts of a change and leave the rest without reverting the whole file.

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

Coda supports 37 providers — commercial clouds, open-weight hosts, local models, and free tiers — with one provider-agnostic architecture (each provider is a self-contained adapter). Pick the model that fits your workflow and budget:

Commercial & cloud platforms | Provider | Examples | |----------|----------| | OpenAI | GPT-4o, GPT-4o-mini, o1, o3-mini | | Anthropic | Claude Opus, Sonnet, Haiku | | Google Gemini | Gemini 2.5 Pro, 2.5 Flash, 2.0 Flash (built-in thinking) | | Google Vertex AI | Gemini models on Google Cloud | | Azure OpenAI | GPT-4o, GPT-4o-mini, GPT-4 Turbo on Microsoft Azure | | AWS Bedrock | Claude, Llama, Mistral via AWS | | Snowflake Cortex | Claude, Llama, and Snowflake-hosted LLMs via Cortex Inference | | GitHub Copilot | Copilot Chat models (GPT-4o, Claude, o1) | | GitLab Duo | GitLab AI gateway models | | SAP AI Core | SAP Business AI models | | Vercel AI Gateway | One key for hundreds of AI SDK models |

Open-weight & fast inference hosts | Provider | Examples | |----------|----------| | Mistral | Mistral Large, Codestral, Pixtral | | Groq | Llama, Mixtral, Gemma (ultra-fast) | | xAI | Grok-3, Grok-3-mini | | DeepSeek | DeepSeek-V3, DeepSeek-R1 | | Cohere | Command R+, Command R | | OpenRouter | 200+ models via one API key | | Together AI | Fast open-source model hosting | | Fireworks AI | Fast open-model inference | | Perplexity | Sonar, Sonar Pro (search-augmented) | | Cerebras | High-throughput Llama/Qwen inference | | DeepInfra | Open-weight models, OpenAI-compatible | | NVIDIA NIM | NVIDIA-hosted open models | | Alibaba (DashScope) | Qwen models | | Venice | Private, uncensored inference | | LLM Gateway | Unified API to many providers |

Local & free | Provider | Examples | |----------|----------| | Ollama | Run any model locally — no API key needed | | Ollama Cloud | Ollama's cloud-hosted models with an Ollama API key | | Pollinations | Completely free, no API key, no install | | GitHub Models | Free tier with your GitHub token (models:read) |

Bring your own / gateway | Provider | Examples | |----------|----------| | OpenAI Compatible | Any custom OpenAI-compatible endpoint | | Cloudflare AI Gateway | Cloudflare-routed model gateway | | Cloudflare Workers AI | Cloudflare edge inference | | Kilo / ZenMux / Dynamic | User-configured OpenAI-compatible proxies | | OmniRoute | Local http://localhost:20128/v1 or hosted https://cloud.omniroute.online/v1 |

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 when the provider needs one; 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)

Coda only asks for custom base URLs on providers that need an endpoint, such as Azure OpenAI, OpenAI-compatible APIs, Cloudflare gateways, SAP AI Core, or Snowflake Cortex. OpenAI, Anthropic, Gemini, Groq, Mistral, and similar providers use their normal hosted endpoints automatically.

OmniRoute: install and run OmniRoute locally, create an endpoint API key in its dashboard, then select OmniRoute in Coda. The default endpoint is http://localhost:20128/v1; use coda.providerBaseUrls.omniroute to point Coda at a hosted or custom OmniRoute instance. Models use OmniRoute's provider-qualified IDs, such as if/kimi-k2-thinking.

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 | | Azure OpenAI | https://portal.azure.com (Azure OpenAI resource keys) | | Google Vertex AI | https://console.cloud.google.com (service account / API key) | | Perplexity | https://www.perplexity.ai/settings/api | | Cerebras | https://cloud.cerebras.ai (API keys) | | Snowflake Cortex | https://app.snowflake.com (account host + PAT/keypair token) | | GitHub Copilot | Your GitHub Copilot subscription token | | Ollama | No key needed — runs locally | | Ollama Cloud | https://ollama.com/settings/keys | | Pollinations | No key needed — free | | GitHub Models | Retired by GitHub on 2026-07-30; kept only for legacy troubleshooting |

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

Setting	Description
`coda.provider`	AI provider
`coda.model`	Model name (leave empty for provider default)
`coda.modelRouting.enabled`	Enable purpose-specific model overrides
`coda.modelRouting.chatModel`	Model override for normal chat
`coda.modelRouting.agentModel`	Model override for agent mode
`coda.modelRouting.inlineModel`	Model override for inline completions and inline chat
`coda.modelRouting.reviewModel`	Model override for review workflows
`coda.temperature`	Response creativity (0–2)
`coda.maxOutputTokens`	Max output tokens per response
`coda.systemPrompt`	Custom instructions appended to the system prompt
`coda.inlineCompletions`	Enable/disable ghost-text completions
`coda.mcpServers`	MCP server configurations

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

Server	Package	What it does
Filesystem	`@modelcontextprotocol/server-filesystem`	Read/write local files outside the workspace
GitHub	`@modelcontextprotocol/server-github`	Issues, PRs, repos (needs `GITHUB_PERSONAL_ACCESS_TOKEN`)
Fetch	`@modelcontextprotocol/server-fetch`	Fetch any URL
Memory	`@modelcontextprotocol/server-memory`	Persistent key-value memory across sessions
shadcn/ui	`shadcn@latest mcp`	Add and configure shadcn/ui components
Next Devtools	`next-devtools-mcp@latest`	Inspect and control a Next.js dev server

Verifying servers are connected

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

Troubleshooting

Symptom	Fix
Server shows 0 tools	Check the package name and args; run `npx -y <package>` in a terminal to confirm it installs
Server won't start	Check Output → MCP: server-name for the startup error
Tools not appearing in agent	Run `Coda: Restart MCP Server` then start a new agent task
`env` variable not picked up	Restart VS Code after adding env vars to `.coda/mcp.json`

Slash Workflows

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

Command	What it does
`/plan <goal>`	Builds an execution plan with todo tracking before implementation
`/run <command>`	Runs a command and summarizes outcome + next action
`/ship`	Runs quality gates (typecheck/lint/test/build) and reports ship-readiness
`/eval`	Shows how to score captured agent traces and compare models
`/pr [focus]`	Generates a complete PR package (title/body/risks/tests/release notes)
`/codebase <q>`	Performs deep architecture/risk analysis across the workspace
`/parallel <task>`	Splits work into parallel sub-agent investigations and merges results
`/swarm <task>`	Splits work across multiple coordinated sub-agents
`/init <stack>`	Scaffolds a new project from requirements
`/preview <req>`	Generates and renders a UI prototype in a live webview panel
`/commit`	Generates a high-quality commit message from staged changes
`/test <file>`	Generates comprehensive unit tests for a specific file
`/fix [focus]`	Finds and automatically fixes all workspace errors and diagnostics
`/explain`	Explains selected code or the current file in detail
`/review`	Reviews the current git diff for risks, bugs, and regressions
`/checkpoints`	Lists saved agent checkpoints from recent runs
`/resume [id]`	Resumes from a saved checkpoint without repeating completed work
`/help`	Shows all available slash commands and usage

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 (developer mode)

The Evals tab is hidden by default. Enable it with the coda.devMode setting — it's intended for Coda contributors comparing models, not day-to-day use.

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 File 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 Git Changes 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

Shortcut	Action
`Enter`	Send message
`Shift+Enter`	New line
`⌘L` / `Ctrl+L`	Clear chat
`⌘K` / `Ctrl+K`	Open Command Center
`⌘I` / `Ctrl+I`	Inline chat (rebindable — may conflict with Copilot/Cursor)
`@filename`	Include a file in context

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 BM25 over symbol-boundary chunks plus workspace-symbol (LSP) lookups
No embeddings: Retrieval is fully local and offline — no embedding model, no network calls, zero token cost
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:

Provider	Input Limit	How Coda Adapts
Google Gemini	1,000,000 tokens	Reserves 900K for safety; disables context if needed
Anthropic Claude	200,000 tokens	Reserves 150K for safety; compacts old messages
OpenAI (GPT-4o/o1)	128,000 tokens	Reserves 96K; prunes history progressively
Mistral	32,000 tokens	Keeps only recent messages + current query
Ollama (local)	8,192 tokens	Very limited; context rarely injected

When You See "Workspace Too Large" Warning

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

Disable auto-context injection — the AI won't have relevant code snippets
Still work normally — you can still chat, use agent mode, and run tools
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:

Use Chat mode instead of Agent mode (context injection only works in Agent)
Explicitly include files via @filename syntax instead
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}