Coda AI

An AI coding assistant with chat, agent workflows, and workspace-aware retrieval.
Chat, investigate, refactor, and ship using the model provider you choose.

Install from Marketplace · Report Issue · GitHub

Why Coda?

Most AI assistants only answer questions. Coda can also execute multi-step work through tools.

Give it a task — fix a bug, refactor a module, write tests, or set up CI — and it can inspect code, propose edits, run commands, and iterate. You stay in control with approval prompts for sensitive operations.

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

◆ 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 finishes, a pinned change summary shows exactly what was touched — with one-click Keep or Undo per 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 and a step-by-step activity log.

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.0-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 |

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

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

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 Lambda AI · MIT License}