Coda AI

The open, auditable AI coding agent for VS Code.
Ships real changes, with a complete audit trail and a human in control.

Install · Marketplace · Publisher

Every tool call, edit, and validation is visible, from the first read to the verified result.

Overview

Coda is a full-loop engineering agent. It reads your codebase, plans the work, edits across files, runs your tests and builds, reviews its own diffs, and leaves a complete, human-approvable record of what it did and why.

You choose the model. Coda supplies the engineering loop, the guardrails, and the audit trail.

Why teams choose Coda

Real changes, safely applied. Edits are written to disk and shown as live diff cards. Accept or undo per file or per hunk. Nothing is committed without you.

Auditable by design. Every run produces a Run Summary: status, duration, model, files changed with line deltas, tool calls, validations, token usage, and linked artifacts.

Governed autonomy. Deletions and unsafe commands pause for explicit approval. Large tasks can run in an isolated git worktree so your working tree stays untouched.

Your model, your rules. Route chat, agent, inline, and review work to different models. Keep durable rules, architecture notes, and project memory versioned in the repository.

Offline-first retrieval. Local BM25 search plus VS Code language-service navigation. Optional embeddings can improve semantic ranking when configured; the core retrieval path requires no network connection or vector database.

Two ways to work, one engine

Both surfaces share the same backend: tools, sessions, approvals, and change tracking. Anything the agent does from @coda can be reviewed and undone in the panel.

Features

What the agent can do

• Navigate and understand your project structure
• Read, create, edit, and refactor files across the codebase
• Run shell commands, build scripts, and test suites
• Start and manage long-running processes and VS Code tasks
• Trace code with go-to-definition, find references, and symbol search
• Search and rewrite code structurally (AST), and resolve merge conflicts
• Read LCOV/Istanbul coverage and scan for hard-coded secrets
• Work with Git: commits, diffs, branches, stash
• Read external documentation and APIs
• Keep lightweight session notes across a workflow
• Ask you clarifying questions when the task is ambiguous

Run Summaries and artifacts

Each agent run can produce a durable summary card with status, duration, model, and token usage; files changed with line deltas; tool-call and validation counts; and links to diffs and generated artifacts.

The Artifacts panel collects responses, diffs, logs, execution reports, reviews, PR packages, and commit messages so important output doesn't disappear into chat history.

Delivery workflow

Project rules and memory

Run Coda: Initialize Project Rules to create versioned guidance that Coda injects into Chat and Agent prompts automatically:

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

Coda also keeps persistent project memory in .coda/memory.json, so decisions, conventions, and known issues carry across sessions. The agent manages it with memoryRead, memorySave, and memorySearch.

Git integration

• Coda: Review Staged Git Changes analyzes staged changes for bugs, security risks, and style regressions.
• Coda: Setup Pre-Commit Hook (PR Reviewer) installs a hook that runs Coda's analysis on every commit.

Built for teams and regulated environments

Coda is designed so that AI-assisted work can be reviewed, reproduced, and governed like any other change.

Quick start

1. Install Coda AI from the Marketplace. The Coda icon appears in the Activity Bar.

2. Open the panel by clicking the icon, or run Coda: Open Chat (⌘⇧P / Ctrl+Shift+P).

3. Configure a provider. Click the ⚙ icon in the panel, or run Coda: Configure AI Provider.

• Provider: choose from the dropdown
• API key: paste it when the provider needs one. It is stored in VS Code SecretStorage
• Model: leave blank for the provider default, or enter a model ID from the selected provider's current catalog. Model IDs and availability change frequently; use the provider's documentation for the current list

Coda asks for a custom base URL only where one is required: Azure OpenAI, OpenAI-compatible APIs, Cloudflare gateways, SAP AI Core, and Snowflake Cortex. Other providers use their standard hosted endpoints automatically.

4. Choose a mode. Chat answers questions about your code. Agent takes on multi-step tasks: reading, editing, running commands, and iterating.

5. Optional: initialize project guidance with Coda: Initialize Project Rules.

6. Optional: delegate safely with Coda: Start Background Worktree. Coda writes a task brief under .coda/background-tasks/ in the new worktree and opens it in a separate window, so the agent never touches your current checkout.

Supported providers

Coda supports a provider catalog through a provider-agnostic architecture in which each provider is a self-contained adapter. Provider catalogs, model IDs, tool support, and availability change frequently. Coda uses live catalogs where an endpoint provides them, and Agent mode admits only models whose tool capability is documented or verified for the selected provider and endpoint.

Note: GitHub Models was retired by GitHub on July 30, 2026 and is not supported by Coda. GitHub Copilot models are a separate provider. See GitHub's current documentation for the retirement status.

Where to get an API key

Running fully local with Ollama

Ollama can keep model requests on your machine, but tool calling is model-dependent. Before selecting a local model for Agent mode, verify that the model exposes the tools capability (ollama show <model>). Configure a context size appropriate for your hardware; larger contexts use more memory, and Ollama recommends a large context for coding tools when the machine permits it. Coda still applies its own context budget so tool calls and results have room to complete.

Set OLLAMA_CONTEXT_LENGTH to a value appropriate for your hardware before starting ollama serve; see Ollama's current context guidance for the trade-off between context size and memory.

Ollama Cloud models run at their maximum context length by default.

OmniRoute

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

Slash workflows

Type / in the input box to browse and autocomplete commands. Most commands start an agent task with the current preset; a few act directly (/mode, /plan-mode, /compact, /undo, /checkpoints, /eval, /help). /run, /parallel, and /resume also provide structured forms, and ⌘K / Ctrl+K opens the Command Center.

Workspace-specific slash-command prompt templates can be placed in .coda/commands/<command>.md. Templates support {{args}} and {{command}}; without a template, Coda uses its built-in prompt.

MCP servers

Model Context Protocol servers expose tools the agent can call automatically, such as reading issues, querying a database, or fetching pages. Connected tools appear alongside Coda's built-in tools.

Option 1: workspace file (recommended). Create .coda/mcp.json. It hot-reloads on save.

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token" }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

Option 2: VS Code settings. Add servers under coda.mcpServers for availability across all projects. If a server name appears in both places, the settings entry wins.

Option 3: guided setup. Run Coda: Add MCP Server and follow the prompts.

Verify: run Coda: MCP Server Status to see each server's state and tool count. Use Coda: Restart MCP Server for a stopped server, and open View → Output → MCP Manager for logs.

Skills and instruction packages

Coda can load instruction-only skills from SKILL.md files. Run Coda: Import Skill and choose either a public GitHub repository or a local skill package. Coda resolves GitHub imports to a commit, previews the discovered skills, and copies only the selected ones into the workspace's .agents/skills/ directory. Coda records the package name, version, source metadata, resolved commit, and content hashes in .coda/skill-imports.json.

Example: import anti-slop

1. Open the Command Palette and run Coda: Import Skill.
2. Choose GitHub repository.
3. Paste https://github.com/miqdadbadjuber/anti-slop#main.
4. Select the skills you want, then approve the import.
5. Start a new Coda session and ask Coda to use the relevant anti-slop skill.

The importer downloads GitHub archives over HTTPS only. It copies files as data only, never runs plugin manifests, installers, scripts, or arbitrary package code, and rejects unsafe archive paths. MCP remains the integration path for executable external tools.

Skills are loaded on demand by the agent's skill tool. Start a new Coda session after importing a package. You can also add trusted skill directories directly with coda.skills.paths.

Configuration

Keyboard shortcuts

Workspace context

In Agent mode, Coda automatically retrieves relevant code, up to 8 chunks (about 30K characters), using BM25 over symbol-boundary chunks plus VS Code language-service lookups. Optional embeddings can improve ranking when enabled; targeted definitions, references, call hierarchy, and type hierarchy are available when the workspace language server supports them.

Coda budgets context to the model in use, reserving headroom for output and tool results and compacting older messages as a session grows. If a workspace is too large for the active model, auto-context is disabled with a warning and everything else keeps working.

If you see the Workspace Too Large warning:

1. Use a model with a larger context window.
2. Add a .codaignore file to exclude generated and build directories.
3. Work on one module at a time.

To opt out of automatic context, use Chat mode, or include files explicitly with @filename.

Privacy and security

• Provider API keys entered through Coda are stored in VS Code's encrypted SecretStorage, never in plaintext settings. The optional coda.webSearch.apiKey setting is a plaintext fallback; prefer SecretStorage where available.
• Model requests go to the AI provider you configure. Optional web search, URL fetching, and MCP tools can contact their configured external services when enabled.
• Network egress is policy-controlled. fetchUrl and httpRequest honor coda.network.allowedDomains / blockedDomains on every redirect hop and route through coda.network.proxy when set; private-network hosts stay blocked.
• No telemetry, analytics, or tracking.
• Local model traffic can stay on your machine with Ollama; separately enabled web search, URL fetching, MCP, or other external tools may still make network requests.
• Approval gates protect against destructive operations.

To report a security concern, contact the publisher through the Coda Marketplace listing.

Agent evaluation (contributors)

Enable the Evals tab with coda.devMode. Every completed run writes a markdown execution report to .coda/execution-reports/ and a normalized JSON trace to .coda/eval-traces/, including the prompt, provider and model, tool calls, edited files, and validation evidence.

npm run build
npm run eval:traces   # score captured runs
npm run eval:bench    # deterministic benchmark scenarios
npm run build:prod    # production build

Run the same task against different models and re-run eval:traces to compare pass, unverified, and failure rates by provider and model.

Support

• Coda Marketplace listing

_{Built by Express Genix · MIT License}