CodicoYour autonomous AI coding agent inside VS Code. An autonomous coding agent embedded directly in VS Code. Connect directly to major providers with your own keys — Anthropic, OpenAI, Google, Groq, DeepSeek, Mistral, Grok, and Cerebras — access many additional providers through OpenRouter, or run fully offline with Ollama. The agent reasons through problems, reads and writes files, runs terminal commands, searches code, applies targeted edits, and iterates autonomously — all from a sidebar chat panel. ProvidersDirect Provider ConnectionsCall AI providers directly with your own API keys — no OpenRouter account required:
Direct models appear in the model picker under a 🔑 section. Each provider stores its key independently in VS Code's encrypted Claude Code (your Claude login)Use the Claude models of your Claude plan with no API key: Codico runs your installed
ChatGPT (your ChatGPT login)Use the GPT models of your ChatGPT plan with no API key: Codico runs OpenAI's
OpenRouterAccess hundreds of models through a single API key — including free-tier models from Qwen, Google, NVIDIA, Poolside, Cohere, and more. Set your key via Local Models (Ollama)Run entirely offline. Prefix any model ID with Give the model a large enough context window. Ollama loads a model with a small context (often 4096 to 8192 tokens) unless told otherwise, and an agent's conversation is longer than that: Ollama then silently drops the start of it, and the model forgets the task, repeats itself or stops using its tools. Either set ACCO context optimization (optional)Codico can send its provider-facing request copy through a local ACCO — AI Coding Context Optimizer service before the request reaches the provider. This applies to OpenRouter and to the direct providers (your own key: Anthropic, OpenAI, Google, DeepSeek, Groq, Mistral, Grok, Cerebras). Codico keeps the canonical chat history, agent loop, file mutations, and verification state unchanged.
Then enable The integration is deliberately fail-open: if ACCO is unavailable, times out, or declines a transform, Codico sends the original request unchanged. Non-loopback ACCO URLs are rejected. Ollama, Claude Code and ChatGPT requests are not optimized: ACCO has no request shape for them. ACCO works on tool results and tool definitions, so it changes little when a model falls back to Codico's text tool format. A paired frozen holdout on the FeaturesAgentic LoopAfter each response the agent executes any tool calls, feeds the results back to the model, and keeps working until the task is complete — without requiring follow-up from you.
Live Thinking VisualizationFor reasoning models (DeepSeek R1, Qwen3, etc.) the agent's internal chain-of-thought is shown in a collapsible "Reasoning trace" panel above each response, streamed in real time. Hide these blocks with Token EfficiencyLong agent tasks resend the conversation with every step, so Codico keeps what is resent small and cacheable:
Built-in Tools
Every tool that modifies files or runs code shows a permission card — Allow, Allow all writes / commands this task, Edit (for writes) or Deny. Permissions reset with each new message; after the agent has read web or MCP content, commands are asked about again even when allowed for the task. Your own changes are never silently overwritten: if you edit a file while its approval card is open, an edit is re-applied to the current content (and a whole-file write is not made); files open with unsaved changes are read from and written through the editor; Undo, Redo and accepting an Edits-mode proposal ask before overwriting a file that changed since. File content passed to Local Model Support (Ollama)Run the agent entirely offline with any Ollama model:
Live Terminal OutputWhen the agent runs a shell command, output streams directly into the chat panel in real time — no waiting for the process to finish:
Live Task List (Todo Tracker)The agent can declare and update a live task checklist using the
Inline Diff View (File Changes)Every file write and edit shows a colored diff before and after the change:
Auto-Commit After TaskA 📥 Auto-commit toggle in the chat header triggers an automatic
Proactive Error DetectionWhen you open a file that has errors in the Problems panel, a banner appears in the chat panel:
Debugger IntegrationThe agent can drive the debugger itself, to find the cause of a failure from the running program rather than from the source and the terminal output. The
While a debug session you started is active, the agent can also read it with three tools:
The tools fail gracefully with a clear message when no debug session is running. Everyday Conveniences
SearchOne search for the conversation that is open and for all of them. Press This thread
All threads
NotificationsWhen a reply finishes, or Codico waits for your approval (a file change, a command, a "continue?" pause), and you are not looking at the chat:
Code SearchThe agent has a ranked search of the whole repository,
This is separate from the optional embeddings index used by Project MemoryCodico can keep what it learns about a project for the next session: the command that really runs the tests, a convention, where something non-obvious lives, a mistake it made and should not repeat.
Web SearchThe agent can look something up without being given an address: current documentation, an error message, a release note.
Background TasksHand a task to Codico and keep working: the task runs in a git worktree and a branch of its own, so it cannot disturb the files you are editing. By default it runs right here, in this window, next to your conversation.
Things to know: a fresh worktree has no installed dependencies, build output or untracked files such as Across repositoriesA team can change several repositories at once — a backend, the shared SDK it uses, a frontend — test them together and open linked pull requests.
AutomationsCodico can take work from GitHub by itself and see it through: an issue or a CI failure becomes a fix, the fix a pull request, and feedback on that pull request more work, until it is merged.
Without the editor:
|
| Option | Allows |
|---|---|
| (none) | reading and searching the folder |
--allow-edits |
creating and changing files in the folder |
--allow-commands |
terminal commands (and edits) |
--allow-web |
fetching pages and web search |
--allow-hooks |
the project's hooks in .codico/hooks.json |
--plan makes the task a plan: the agent can only read and search, changes nothing whatever else is allowed, and its reply is a numbered step-by-step plan (a task starting with /plan does the same). --ollama-context <tokens> loads an Ollama model with that context window for the run.
Other options: --cwd <dir>, --model <id>, --max-steps <n>, --timeout <seconds> (default 1800), --json (one JSON object per line: text, steps, results, what was declined, the end). The agent's reply goes to standard output; steps and the summary go to standard error.
| Exit code | Meaning |
|---|---|
0 |
the task finished |
1 |
the run failed (no model answer, VS Code did not start, timeout) |
2 |
the agent asked a question it needs answered |
3 |
finished, but something it wanted to do was not allowed |
- Keys come from the environment:
OPENROUTER_API_KEY,DEEPSEEK_API_KEY,OPENAI_API_KEY,ANTHROPIC_API_KEY,GOOGLE_API_KEY,GROQ_API_KEY,MISTRAL_API_KEY,XAI_API_KEY,CEREBRAS_API_KEY. - A run is isolated from your editor. It uses a profile of its own, created for the run and removed afterwards: your settings, extensions, threads and stored keys are not used, and the folder is treated as trusted because you pointed the command at it.
- A VS Code unpacked from an archive (CI caches, portable installs) cannot use Chromium's process sandbox; the command notices, says so, and starts it with
--no-sandbox. Extra arguments for VS Code can be given inCODICO_VSCODE_ARGS. - Unattended commands are not confined unless you also turn on the command sandbox for that machine. In CI, a throwaway runner is the usual boundary.
Pull Requests
- Open one. Codico: Create Pull Request publishes the branch checked out in your window; in Codico: Background Tasks, Open a pull request does the same for a task's branch (after committing what the task left uncommitted). A confirmation shows the repository, the branches, the title and the changed files first, with Create Draft and Create Pull Request; only then is the branch pushed to
originand the pull request opened. The description quotes the task and says an agent wrote it. If one is already open for the branch, the push updates it. - Work through a review. Codico: Address Review Comments reads the unresolved review threads of your branch's pull request and gives them to the agent as a task: for each, decide whether it asks for a change, make it, and report per comment. The comments are passed as quoted outside text, not as instructions. Nothing is posted back to GitHub: you read the result, commit and push.
- Read one.
/pradds the pull request of the current branch (description, files, recent comments) to the conversation, as before. - Access. A GitHub token set with Set GitHub Token, or the GitHub CLI's when you are signed in with
gh auth login. Repositories on github.com only.
Command Sandbox
Approvals decide whether a command runs. The sandbox decides what it can touch once it does, enforced by the operating system and not by reading the command.
Set codico.commandSandbox to auto or required. A sandboxed command:
| Can read | the machine: tools, compilers, libraries, other projects |
| Can write | the workspace folders (and the repository a git worktree belongs to), package caches such as ~/.npm and ~/.cache, temporary folders, and anything in codico.commandSandboxWritablePaths |
| Cannot read | credential folders and files: ~/.ssh, ~/.aws, ~/.gnupg, ~/.kube, ~/.azure, ~/.netrc, ~/.config/gh, ~/.config/gcloud, ~/.docker/config.json, ~/.git-credentials |
| Network | allowed, unless codico.commandSandboxNetwork is false |
- Where it works. Linux with bubblewrap installed (
bwrap), and macOS with its built-in sandbox. Windows has none:autothen runs commands as before, andrequiredrefuses them. - What the agent is told. When a command fails in a way that looks like the sandbox's doing, the result says so, and tells the agent to report what the command needed, not to look for a way around.
- Differences you may notice.
git pushover SSH fails (the key is hidden); a command's background processes end with the command; temporary files are private to each command. - Settings are per machine. A project's own settings file cannot switch the sandbox off or widen it.
The sandbox applies to the agent's terminal commands. Approvals, remembered commands and hooks work as before on top of it.
Checkpoints
When you send a message, Codico records the workspace as it is, before the agent does anything. Rewinding to that message restores exactly that.
- Where they are kept. In a git repository of Codico's own, in the extension's storage, one per workspace folder. Your project's
.gitis never read or written, your branches and history are untouched, and nothing is added to the project folder. Git must be installed; without it, rewind falls back to the edits Codico itself made in the current session. - What they hold. Every file your
.gitignoredoes not exclude, except two kinds that are left out whatever.gitignoresays: folders that are rebuilt (node_modules, virtual environments), and files that hold credentials (.envand.env.*,*.pem,*.key, SSH keys,.npmrc,.netrc,credentials.json, Terraform state and the like). A checkpoint is therefore never a second copy of a secret; the price is that a rewind does not restore those files. - How long. 14 days by default (
codico.checkpointRetentionDays;0keeps them until you clear them). Older checkpoints are deleted together with the file contents only they held. - Who can read them. The store is created readable by your user only.
- What runs. Nothing of your git setup: no hooks, no commit signing, no line-ending conversion. Files come back byte for byte.
- Cost. The first checkpoint of a workspace reads every file once; later ones only what changed. Storage grows with what changes between messages.
- Commands: Codico: Undo Last Rewind, and Codico: Clear Checkpoints to free the space (earlier messages can then rewind the conversation but not the files).
codico.checkpoints: falseturns them off.
Remembered Commands
The approval card of a terminal command has a second row, Always allow in this workspace, with the command itself and, for well-known build and test tools, the command with any arguments:
npm test -- --watch=falseoffersnpm test -- --watch=falseandnpm test *;git statusoffersgit statusandgit status *;pytest tests/unitofferspytest *.- Anything else (
rm -rf build,node -e "…",python manage.py migrate, a command with&&or a pipe) is offered only as written, and then allowed only when it is exactly that. - A rule with
*covers further arguments to that one program and nothing else:npm test; rm -rf ~,npm test && …,npm test | …,npm test > fileandnpm test $(…)still ask. - Codico: Remembered Commands lists the rules; untick one to be asked again.
- The rules are per workspace, are not read from any file in the repository, and do not apply once the agent has read web or MCP content in the current turn (the same exception as "Allow all commands this task").
Lifecycle Hooks
A project can run its own checks around what the agent does. Put them in .codico/hooks.json (Codico: New Hooks File writes a starting one):
{
"hooks": [
{ "event": "beforeEdit", "match": "migrations/**", "name": "migration rules", "command": "node scripts/check-migration.js" },
{ "event": "afterEdit", "match": "**/*.ts", "name": "lint", "command": "npx eslint {file}" },
{ "event": "beforeCommand", "match": "git push*", "command": "exit 1" },
{ "event": "afterCommand", "match": "npm test*", "command": "node scripts/coverage-floor.js", "timeoutSeconds": 120 }
]
}
| Event | Runs | If the hook exits with a code other than 0 |
|---|---|---|
beforeEdit |
before write_file / edit_file changes a file (and before you are asked to approve it) |
the edit is refused; the agent is given the hook's output as the reason |
afterEdit |
after the change is on disk | the output is added to the edit's result, so the agent sees it and can fix it |
beforeCommand |
before run_terminal runs a command |
the command is refused, with the hook's output |
afterCommand |
after the command has finished | the output is added to the command's result |
match(optional) narrows a hook: for edits a glob on the file's path in the workspace (**/*.ts,migrations/**; a pattern without/is a file name in any folder), for commands the command line with*as the wildcard (git push*,*npm test*). Without it the hook runs for every edit or command.- What a hook is told.
{file}in the command is replaced by the quoted file path. The environment hasCODICO_HOOK_EVENT,CODICO_HOOK_TOOL,CODICO_HOOK_FILE,CODICO_HOOK_COMMANDand, after a command,CODICO_HOOK_EXIT_CODE.CODICO_HOOK_INPUTis the path of a JSON file with the whole call: the new content or the old and new text of an edit, or the command with its exit code and output. - What the agent is told. Whatever the hook prints, up to 4,000 characters. A hook that passes and prints nothing adds nothing to the conversation.
- Limits. A hook runs in the workspace folder with the same reduced environment as the agent's commands, and is stopped after
timeoutSeconds(default 30, at most 600); abeforehook that is stopped refuses the call. At most 20 hooks are loaded. The file is read again when it changes, and an entry with a mistake is reported and skipped. - Trust. A hook is a command from the repository, so it never runs in a folder VS Code has not been told to trust, and Codico shows you each command and asks once before running it. Approval is for that exact command in that workspace: a hook that is changed is asked about again. A hook you do not allow is skipped, and the agent's edit or command goes ahead as it would without hooks.
Getting Started Guide
On first install Codico opens a short guide (provider, first task, staying in control, finding things) — reopen it with Codico: Get Started. Until a provider is set up, the empty chat lists the ways to do it: an OpenRouter key, your Claude Code or ChatGPT login (marked when the command is found on your machine), your own provider key, or local Ollama.
Named Chat Threads
Manage multiple independent conversations per project:
- A thread list groups sessions into Pinned / Today / Yesterday / This week / Older, with a preview line, pin (📌), rename (✏), duplicate (⧉) and delete (🗑) buttons, and each thread's total tokens and cost on hover
- Duplicate (⧉) copies a thread's whole conversation — as the panel shows it and as the model sees it — into a new unpinned thread named " (copy)" and opens it. The original is untouched and the two are fully independent; duplicating is refused while a reply is running
- Click + to create a new thread; click 🔍 to search across all threads
- The first message in a new thread auto-names it immediately
- Reopening a thread — or reloading the window — restores the full conversation exactly as it streamed: text, reasoning, tool steps, diffs and terminal output (about 400k characters per reply are stored; threads saved by older versions show short summaries)
- If the window closed while the agent was mid-task, a Session was interrupted — resume? banner offers to continue it
- Messages show when they were sent ("2m ago", full date on hover)
Rewinding, Editing, Deleting and Regenerating Messages
Each of your messages has its actions next to its time:
- ↺ Rewind to here — takes the conversation back to just before that message and puts the files back as they were when it was sent. Codico takes a checkpoint of the workspace with every message, so this covers everything that changed since: its own edits, what terminal commands created, changed or deleted, and your own edits. A dialog lists the files first and also offers to rewind the conversation only. The message returns to the input box so you can change it and send it again. Codico: Undo Last Rewind brings back the files as they were just before the rewind. Checkpoints are kept on disk, so rewinding still works after VS Code is restarted. See Checkpoints below for what they hold.
- ✎ Edit and resend (or press
↑in an empty input to edit your last one) — the conversation is cut back to that message and the edited text is sent. For a Plan-mode message you edit the goal. - 🗑 Delete — removes the message and everything after it, after a confirmation.
- ↻ Regenerate on the latest reply runs its message again and replaces the reply.
The panel, the saved thread and the history the model sees are always cut at the same point. Messages already folded into a compaction summary cannot be changed.
- Threads are persisted to
workspaceState(per-project) orglobalState(cross-window) depending oncodico.globalHistory
Keyboard Shortcuts
| Shortcut | Action |
|---|---|
Ctrl+Shift+L / Cmd+Shift+L |
Focus the chat panel and input box |
Ctrl+I |
Inline Chat: edit selected code with AI |
Ctrl+Enter |
Accept inline diff |
Esc |
Reject inline diff (editor) · stop the reply (chat panel) |
↑ (empty chat input) |
Edit and resend your last message |
Enter / Shift+Enter |
Send / new line |
Slash Commands
| Command | Effect |
|---|---|
/fix |
Fix bugs in the active file (auto-injects Problems panel diagnostics) |
/explain |
Explain the active file or selected code step by step |
/doc |
Add JSDoc/TSDoc comments to the active file |
/tests |
Write unit tests for the active file or selection |
/review |
Structured code review of the active file |
/plan |
Create a step-by-step plan for a goal, then approve to execute |
/test |
Detect the project's test command, run it, and fix failures until the suite passes |
/compact |
Summarize the conversation history to reduce context size |
/background <task> |
Run the task in its own git worktree, branch and window while you keep working here |
/pr |
Fetch the open GitHub PR for the current branch and review it |
/coverage |
Parse the coverage report and generate tests for uncovered lines |
/new <description> |
Scaffold a new file or project from a natural-language description |
Type / in the input box to see the autocomplete popup.
Extension Commands
| Command | Effect |
|---|---|
codico.openChat |
Focus the chat panel (Ctrl+Shift+L) |
codico.setApiKey |
Set your OpenRouter API key |
codico.setDirectApiKey |
Set a direct provider API key (Anthropic, OpenAI, Google, Groq…) |
codico.gettingStarted |
Open the Get Started guide |
codico.newSkill |
Create a project skill in .codico/skills |
codico.newAgent |
Create a project agent in .codico/agents |
codico.newHooks |
Create .codico/hooks.json for project hooks |
codico.rememberedCommands |
Review and remove the terminal commands always allowed in this workspace |
codico.startBackgroundTask |
Start a task in its own git worktree and window |
codico.createPullRequest |
Push the current branch and open a pull request for it, after a confirmation |
codico.addressReview |
Give the agent the unresolved review comments of the current branch's pull request |
codico.copyCliCommand |
Copy the command that runs Codico from a terminal (codico run …) |
codico.openMemory |
Open the project's memory file (.codico/memory.md) |
codico.undoRewind |
Put the files back as they were just before the last rewind |
codico.clearCheckpoints |
Delete this workspace's checkpoints to free disk space |
codico.setWebSearchKey |
Store or remove the Brave Search API key used by web_search |
codico.backgroundTasks |
List background tasks: review, merge or discard their work |
codico.setOllamaUrl |
Set the Ollama server base URL |
codico.setGithubToken |
Store a GitHub token for PR context features |
codico.toggleInlineCompletions |
Toggle ghost-text inline completions on/off |
codico.indexWorkspace |
Build the semantic workspace index (embeddings) |
codico.clearWorkspaceIndex |
Clear the semantic workspace index |
codico.undoLastChange |
Undo the last AI-applied file change |
codico.redoLastChange |
Redo the last undone AI change |
codico.generateCommitMessage |
Generate a commit message from the staged diff |
codico.showPrContext |
Show the GitHub PR context for the current branch |
codico.generateTestsFromCoverage |
Generate tests for uncovered lines in a coverage report |
codico.suggestRename |
Suggest a better name for the symbol under the cursor |
codico.askAboutDiffHunk |
Ask about a changed file or diff hunk (SCM / editor context menu) |
codico.explainTerminalError |
Explain the selected terminal output (terminal context menu) |
codico.inlineChat |
Inline Chat: edit the selection with AI (Ctrl+I) |
codico.acceptInlineDiff / codico.rejectInlineDiff |
Accept or discard an inline edit (Ctrl+Enter / Esc) |
codico.codeLensExplain / codico.codeLensFix |
Explain or fix a function (used by the CodeLens actions) |
@ Agent Mentions
| Agent | What it does |
|---|---|
@workspace |
Searches the workspace index (semantic + keyword), injects file tree and active file |
@terminal |
Injects npm scripts and git status — best for shell/build questions |
@vscode |
Reads .vscode/ configs and extension metadata — best for Extension API questions |
@github |
Searches GitHub issues, PRs, and repos using your stored token |
Type @ in the input box to see the autocomplete popup.
Context Injection
Attach live workspace context to any message via the toolbar above the input box:
- 📄 File — injects the full content of the currently open file
- 📁 Files — opens a multi-select picker to attach one or more workspace files
- ✂️ Selection — injects only the selected text (with file path and line range)
- ⚠️ Problems — injects all current workspace errors and warnings
Auto selection injection — when you highlight code in any editor, a ✂ filename:line-range chip automatically appears in the input area and the selected code is included in the next message context. The chip disappears when you deselect. No click required.
Context chips appear as removable badges before sending, with their size; a chip warns when a file was cut to its first 20,000 characters.
Drag and drop — drop files onto the chat to attach them: text files as file context, images as image attachments. From VS Code's Explorer, hold Shift while dragging (a VS Code requirement); workspace files excluded by .codicoignore are refused.
Images — attach screenshots or diagrams with the 📎 button, by pasting, or by drag-and-drop (requires a vision-capable model).
Reading Replies
- File paths open the file —
src/app.ts:42in a reply, or a path in a tool step (Reading / Editing / Written), opens the file at that line - Grouped steps — when a reply finishes, runs of three or more tool steps collapse into one line ("12 steps · read 7 files, searched 3×, ran 2 commands"); failed steps, terminal output and diffs stay visible
- Long code blocks start as a preview with an Expand button; the header shows the line count
- Long replies get an outline of their headings and a ↓ Summary link
- Scrolling — scroll up while a reply streams to read; it stops following, and ↓ Jump to latest takes you back
- Density —
codico.chatDensityswitches between comfortable and compact spacing - An empty panel offers suggestions to start from, including fixing the errors in the Problems panel
Chat Modes
The toggle under the input box switches how the next message is handled:
- 💬 Ask — read-only: the agent searches and answers; file writes, edits, terminal commands, browser actions and MCP calls are blocked
- 📋 Plan — the agent first produces a step-by-step plan, then waits: nothing is changed until you click ▶ Approve & Execute (same as
/plan). While planning it can only read and search, enforced like Ask mode, so it can ground the plan in your code without modifying it. - 🤖 Agent — fully autonomous with all tools (default)
While a response is streaming, Send becomes Queue →: your next message is given to the agent at its next step, or sent automatically when the response finishes if there is no next step.
When a request is ambiguous, the agent may ask a clarifying question rendered as clickable options (with optional free-text input) before it starts.
Workspace Diagnostics Auto-Injection
When codico.autoInjectDiagnostics is enabled (default: true), all current Problems panel errors and warnings are automatically prepended to every AI request. A live badge in the header shows the current error/warning count and updates in real time.
Completion Notifications
When the agent finishes a long task while the VS Code window is not focused, a notification pops up:
Codico finished: "your message…" [Open Chat]
Configurable via codico.completionNotificationsEnabled and codico.completionNotificationThresholdMs (minimum task duration before notifying, default 5 s).
CodeLens: Explain / Fix
Two CodeLens actions appear above every function/method definition across all languages:
- ✨ Explain — sends the function body to the AI for a clear step-by-step explanation
- 🔧 Fix — sends the function body plus any overlapping diagnostics
Toggle with codico.codeLensEnabled.
Inline Chat
- Press
Ctrl+Ior right-click → Inline Chat: Edit with AI - Pick a command:
/fix,/doc, or a custom instruction — these stream a diff directly into the editor buffer with red/green highlighting /explainand/testsroute to the sidebar chat- Press
Ctrl+Enterto accept the diff orEscto discard - Needs an OpenRouter model (as do Next Edit Suggestions, Suggest Rename and commit message generation)
Inline Completions (Ghost Text)
As you type, the agent suggests completions inline (grey ghost text). Press Tab to accept. Works with OpenRouter and Ollama models; with a direct-provider model selected Codico says it is not supported instead of sending requests. Configure with:
codico.inlineCompletionsEnabled— enable/disable (default:true)codico.inlineCompletionsDebounceMs— delay before triggering (default:600)
Edits Mode (Multi-file Diff Review)
Click the ✏ Edits toggle in the header to enter Edits Mode:
- The agent queues all file changes as proposals rather than writing them immediately
- Each proposal appears as a diff card with Accept and Reject buttons
- An edit with several separate changes lists them under the file ("Change 2 of 3 · line 14 · +1 −1" with the removed and added lines), each with its own ✓ and ✗: accepting one writes only that change to the file and leaves the others to decide; rejecting one drops it and touches nothing. A new file is accepted or rejected whole
- Use Accept All / Reject All for bulk operations
- Undo / Redo (↩ ↪) let you reverse any accepted AI change
Context Compaction
Keep long sessions efficient:
- ↓↑ Compact context button — summarize the conversation history immediately to reduce token usage
- ↙ Auto-compact toggle (on by default) — automatically compact when prompt tokens exceed
codico.autoCompactThreshold(default: 60,000 tokens), including between steps of a running task - Compaction preserves key decisions, files changed, errors resolved, and outstanding tasks; the most recent messages are kept verbatim for continuity
- The chat display is not affected — reopening a thread still shows the full conversation
Follow-up Suggestions
After each response, 3 context-aware follow-up suggestion chips appear below the message. Click one to send it instantly. Toggle with codico.followUpSuggestionsEnabled.
Coverage-Based Test Generation
Run Codico: Generate Tests from Coverage Report (or /coverage):
- Discovers
lcov.info,coverage-final.json, or other common formats - Lets you pick a file with the lowest coverage
- Annotates uncovered lines and sends a targeted "write tests for these lines" prompt
PR Context (/pr)
Fetches the open GitHub PR for the current branch and injects the title, description, changed files, review comments, and commit messages. Requires a GitHub token stored via Codico: Set GitHub Token.
Ask about a Git Diff Hunk
Right-click a changed file in SCM → Ask Codico about this diff to explain, review, or improve a specific diff hunk.
Commit Message Generation
Click the Codico button in the Source Control panel header to generate a commit message from the current staged diff. Needs an OpenRouter model (the agent's own auto-commit works with every provider).
Workspace Semantic Search Index
Run Codico: Index Workspace to build a vector embedding index of all source files (up to 600 files, 60-line chunks). Used by @workspace for semantic retrieval:
- Index is persisted across sessions and incrementally updated as files change
- Falls back to keyword search when no API key is set or embeddings are unavailable
- Configure the embedding model via
codico.embeddingModel
Suggest Rename
Right-click any symbol → Suggest Rename — the agent proposes a more meaningful name based on context and usage. With codico.renameSuggestionsEnabled, the built-in rename box (F2) is also pre-filled with an AI-suggested name.
Next Edit Suggestions
After you make a change, the agent predicts the next related edit and shows it as a suggestion; press Tab to accept. Toggle with codico.nextEditSuggestionsEnabled.
Explain Terminal Errors
Select failing output in the integrated terminal, right-click → Explain Error with Codico to send it to the chat for a diagnosis.
Excluding Files (.codicoignore)
Add a .codicoignore file (gitignore syntax) to any workspace root to exclude matching files from Codico's semantic index and agent file surfaces. The policy is enforced for read_file, list_directory, search_files, find_files, write_file, edit_file, and diagnostics, and changes are picked up automatically. Multi-root workspaces keep separate rules per root.
Existing .copilotignore files are still read for compatibility; .codicoignore is the Codico-specific policy and its later rules can override legacy matches. Terminal commands are a separate permission boundary: an approved shell command can still access files that the operating system allows, so do not treat ignore rules as a shell sandbox. Terminal subprocesses no longer inherit arbitrary VS Code process secrets by default.
Marketplace
Codico: Marketplace lists community packages — skills, agents, MCP servers and hooks — from a registry, searchable by name, description, tag or publisher. A package is installed into the project (.codico/skills, .codico/agents, .codico/hooks.json, .mcp.json), so it is shared with everyone who opens it, like the project's own.
- What was reviewed is what is installed. The registry (ehk2509/codico-registry;
codico.marketplaceRegistryto use another, such as a company's own) pins each version to a commit of the publisher's GitHub repository and a hash of its content. Codico downloads that commit and refuses it if the content differs. - Publisher. A package's id starts with its publisher's GitHub account and must come from a repository of that account; verified publishers are confirmed by the registry's maintainers.
- Before installing, you see what it adds (skills, agents, each MCP server's command line, each hook's command), the permissions it declares (commands, network, environment variables), and a security scan of every file: commands that download and run code, reads of keys or credentials, text written to steer the agent against you or around its approvals, hidden or encoded code, binaries, MCP servers without a fixed version, and commands or addresses it did not declare. Nothing in a package runs at install time; its MCP servers and hooks still ask before they first run.
- Updates and removal are exact. What was installed is recorded in
.codico/packages.json. Codico tells you once a day when an installed package has a new version; updating shows the same review. Uninstalling removes what the package added — files you have changed since are kept. - Publishing. Put a folder with a
codico-package.jsonin a public GitHub repository, runcodico package check <folder>(validation, scan, and the registry entry with the commit and the content hash), and open a pull request to the registry, whose CI runscodico registry verify. The registry's README has the format.
MCP (Model Context Protocol) Servers
The catalog. Click 🔌 MCP in the chat header for a short list of known servers, each checked to connect with Codico and pinned to a version:
| Server | By | What it adds |
|---|---|---|
| Playwright | Microsoft | Drive a real browser: open pages, click, fill forms, read the page and its console |
| Chrome DevTools | Inspect a page in Chrome: network, console, performance traces, screenshots | |
| Context7 | Upstash | Current documentation and examples for a library |
| Memory | Model Context Protocol | A small knowledge graph the agent keeps across conversations |
| Sequential Thinking | Model Context Protocol | A scratchpad for working through a problem in steps |
Each card shows the exact command the server runs. Add… opens a VS Code dialog with that command, what it requires and how many tools it adds, and asks where to put it: this project (.mcp.json, shared with everyone who opens the project) or all projects (your user settings). Nothing is written or started until you choose. Remove takes it out again. These servers need Node.js; a server that needs an API key is not in the catalog yet — add those by hand as below.
Each tool a server adds is described to the model on every request, so a 30-tool server costs tokens even when unused: add what you use.
Connect any MCP-compatible tool server via settings or a .mcp.json file in the workspace root. Connected tools appear in the system prompt and can be called with mcp_call blocks.
- Workspace-defined servers need your approval the first time; an invalid
.mcp.jsonis reported instead of silently ignored - Results are treated as untrusted content and capped at 20,000 characters
- ■ Stop cancels a running MCP call (and tells the server); calls may otherwise run up to 5 minutes
Repo-Level Custom Instructions
The agent reads and applies instructions from any of these files (all found files are merged):
.codico-instructions.md(workspace root).github/codico-instructions.md.github/copilot-instructions.md
Changes to these files invalidate the cache immediately — no reload required.
Provider, Model & Thinking Effort
The chat header has two menus. Provider chooses where the model runs and whose key is used: OpenRouter, Claude Code or ChatGPT (your own login, no key), a direct provider (your own key) or local Ollama. Providers without a key are marked "no key", and picking one asks for its key. Model then lists only that provider's models, and each provider remembers the model you last used with it.
If the selected model needs an OpenRouter key that is not set but you have a direct provider key, Codico switches to that provider and tells you.
The models, by provider:
🔑 Direct (your own keys)
- Anthropic: Claude Opus 4.5, Sonnet 4.5, Haiku 4.5, Claude 3.5 Sonnet
- OpenAI: GPT-6.1 Sol, GPT-6 Sol, GPT-6 Astra, GPT-6 Luna, GPT-5.5, GPT-5.4 Mini (reasoning effort follows the header selector)
- Google: Gemini 3.8 Flash, Gemini 3.5 Flash, Gemini 3.5 Flash Lite, Gemini 3.1 Pro, Gemini 2.5 Pro, Gemini 2.5 Flash (thinking shown; thinking level follows the header selector)
- Groq: Llama 3.3 70B, Llama 3.1 8B Instant, DeepSeek R1 70B
- DeepSeek: DeepSeek V4.1 Flash, DeepSeek V4 Pro (thinking shown; reasoning effort follows the header selector)
- Mistral: Mistral Large, Codestral, Mistral Small
- Grok (xAI): Grok 3, Grok 3 Mini
- Cerebras: Llama 4 Scout 17B, Llama 3.1 70B
🆓 Free (via OpenRouter) — zero-cost models only
- Qwen, Google (Gemma), NVIDIA (Nemotron), Poolside (Laguna), Cohere, Thinking Machines, InclusionAI and more, plus the OpenRouter free router
💎 Premium (via OpenRouter)
- Anthropic (Claude), OpenAI (GPT), Google (Gemini), DeepSeek, Qwen, xAI (Grok), Mistral, MoonshotAI (Kimi), Z.ai (GLM) and more
- The default model, DeepSeek V4 Flash ★, is in this group — it is inexpensive but not free
Ollama (local)
ollama/qwen2.5-coder:7b,:14b,:32bollama/qwen3:8b,:14b,:30b-a3bollama/deepseek-r1:7b,:14b,deepseek-coder-v2ollama/codellama:13b,llama3.1:8b,mistral:7b,gemma3:4b,:12b
Adjust the thinking effort (High / Medium / Low) for reasoning models via the header selector. The default is Medium: High spends noticeably more reasoning tokens on every step.
End-to-end Verification
For a feature or a bug fix, Codico checks that the request is met, not only that the code builds:
- Acceptance criteria first. The agent states what the user will be able to see or do (AC1, AC2…); they are shown in the change report.
- Reproduce, then fix. For a bug, it shows the failure before changing the code; the report marks the criterion reproduced.
- Run the app and use it. The
apptool starts the dev server in the background (npm run dev,vite,rails s…), waits until its address answers, and stops it when the task ends. The browser may open that local address (and only that one) without the usual confirmation. The agent clicks, types and navigates as a user would. - Assertions Codico runs itself.
browser_expectchecks the page — an element shows a text, is visible, hidden or absent — waiting for the page to update. Its result is recorded as evidence (E1, E2…), as are test, build and type-check commands. Console errors, page errors, failed requests and server errors are reported after each step and kept. - Each criterion, on its evidence. The agent names the evidence that shows each criterion. A criterion is verified only when that evidence passed after the last code change; evidence from before a change is stale, and a criterion with no observed evidence is only claimed. While a criterion is not verified, the agent is reminded (twice at most) before it may finish, and told to say plainly what is not met.
- Independent review. One more model request, with no tools and none of the agent's reasoning, reads the criteria and the recorded evidence (assertions, page text after each step, console errors, files changed) and agrees or disputes each criterion. A disputed criterion is not counted as accepted. Turn it off with
codico.acceptanceReview. - Evidence on disk.
.codico/evidence/<when>/holds a screenshot of every browser step and assertion,replay.png(the steps as an animated image) andreport.md; the folder is ignored by git. The change report links to the report, the replay and each assertion's screenshot.
Not done: video recording (it needs a separate ffmpeg download with the Chrome Codico uses; the replay is the screenshots in order), and assertions on screenshots' pixels. Turn the whole workflow off with codico.acceptanceChecks.
Setup
1. Install and compile
npm install
npm run compile
2. Choose your provider
Option A — Direct provider (your own key, no intermediary):
Ctrl+Shift+P → Codico: Set Direct Provider API Key
Pick a provider (Anthropic, OpenAI, Google, Groq, DeepSeek…), paste your key. Then select a 🔑 model from the dropdown.
Option B — OpenRouter (one key, many models):
Ctrl+Shift+P → Codico: Set OpenRouter API Key
Or click ⚙ in the chat panel → OpenRouter API Key.
Option C — Local Ollama (no key, fully offline):
Ctrl+Shift+P → Codico: Set Ollama Base URL
Then select any ollama/ model from the dropdown.
3. Optional: enable cloud semantic indexing
Semantic indexing is off by default because embedding requests send source-code chunks to OpenRouter. You can still use Codico without it; workspace search falls back to local keyword/tool-based retrieval.
To opt in:
Settings → Codico: Auto Index
You can also run Codico: Index Workspace (Semantic Search) manually when you want to build an index.
4. Open the panel
Ctrl+Shift+L — focus chat directly
Or click the Codico icon in the Activity Bar.
Configuration
| Setting | Type | Default | Description |
|---|---|---|---|
codico.model |
string |
deepseek/deepseek-v4-flash |
Model ID: OpenRouter ID, direct:provider/model, or ollama/model |
codico.ollamaBaseUrl |
string |
http://localhost:11434 |
Ollama server URL |
codico.ollamaContextLength |
number |
0 |
Context window (tokens) to load Ollama models with; 0 leaves the server's own setting. Above 0, requests use Ollama's native /api/chat |
codico.systemPrompt |
string |
"" |
Optional prefix prepended to the system prompt |
codico.autoInjectContext |
boolean |
true |
Auto-include active file path as context |
codico.maxIterations |
number |
0 |
Max agentic loop iterations per message (0 = no limit) |
codico.taskTokenBudget |
number |
0 |
Pause and ask whether to continue each time a task uses this many more tokens (0 = no budget) |
codico.terminalTimeoutSeconds |
number |
300 |
Kill a terminal command and its child processes after this many seconds |
codico.streamStallTimeoutSeconds |
number |
300 |
Treat a response that sends nothing for this long as a dropped connection and reconnect |
codico.verificationGraceIterations |
number |
4 |
Extra steps allowed to verify a change after the step limit is reached |
codico.mutationGraceIterations |
number |
3 |
Extra steps allowed to make a required code change after the step limit is reached |
codico.nativeToolCalling |
boolean |
true |
Prefer provider-native structured tools; disable to force fenced compatibility mode |
codico.browserAllowPrivateNetwork |
boolean |
false |
Allow browser automation to access localhost/private/internal destinations |
codico.inlineCompletionsEnabled |
boolean |
true |
Enable ghost-text inline completions |
codico.inlineCompletionsDebounceMs |
number |
600 |
Debounce delay (ms) before requesting a completion |
codico.commandSandbox |
string |
"off" |
Confine terminal commands with an OS sandbox: off, auto (when available) or required |
codico.commandSandboxNetwork |
boolean |
true |
Whether sandboxed commands may use the network |
codico.commandSandboxWritablePaths |
string[] |
[] |
Further folders sandboxed commands may write to |
codico.memory |
boolean |
true |
Let the agent keep notes about the project in .codico/memory.md and read them at the start of each session |
codico.checkpointRetentionDays |
number |
14 |
Days a checkpoint is kept before it is deleted (0: until cleared) |
codico.checkpoints |
boolean |
true |
Take a checkpoint of the workspace with each message, so rewinding restores every file and works after a restart |
codico.webSearch |
string |
"duckduckgo" |
Search engine of the web_search tool: duckduckgo, brave (needs a key) or off |
codico.backgroundTasksDirectory |
string |
"" |
Folder for the worktrees of background tasks (empty: ~/.codico/worktrees) |
codico.openTabsContext |
boolean |
true |
Tell the agent which other files are open in tabs (their names; contents are read only when the task needs them) |
codico.globalHistory |
boolean |
false |
Persist threads across all workspaces |
codico.autoInjectDiagnostics |
boolean |
true |
Auto-inject Problems panel errors/warnings |
codico.completionNotificationsEnabled |
boolean |
true |
Notify when agent finishes while window is unfocused |
codico.completionNotificationThresholdMs |
number |
5000 |
Minimum task duration before notifying (ms) |
codico.proactiveErrorDetection |
boolean |
true |
Offer to fix errors when opening a file with problems |
codico.followUpSuggestionsEnabled |
boolean |
true |
Show follow-up chips after each response |
codico.symbolContextEnabled |
boolean |
true |
Include LSP symbol info for the symbol under cursor |
codico.codeLensEnabled |
boolean |
true |
Show Explain / Fix CodeLens above functions |
codico.embeddingModel |
string |
nomic-ai/nomic-embed-text |
Model used for workspace index embeddings |
codico.autoIndex |
boolean |
false |
Opt in to automatic semantic indexing. Cloud embeddings send code chunks to OpenRouter |
codico.mcpServers |
array |
[] |
MCP server configurations |
codico.nextEditSuggestionsEnabled |
boolean |
true |
Show AI-predicted next edit suggestions (Tab to accept) |
codico.renameSuggestionsEnabled |
boolean |
true |
Pre-fill the rename input (F2) with an AI-suggested name |
codico.responseSummaryEnabled |
boolean |
true |
Append a short Summary and Conclusion block to AI responses |
codico.autoCompactThreshold |
number |
60000 |
Token count that triggers auto-compaction (when enabled) |
codico.claudeCodePath |
string |
"" |
Path to the claude command for the Claude Code provider (empty: PATH, then the Claude Code VS Code extension) |
codico.codeSearchMaxFiles |
number |
5000 |
Files indexed by the local code search (search_code) |
codico.subagentMaxSteps |
number |
10 |
Requests a subagent may make before it must write its report |
codico.changeReport |
boolean |
true |
Show a change report after a reply that changed files |
codico.notifications |
string |
"whenAway" |
Notify when Codico finishes or needs you while you are not looking at the chat (off to disable) |
codico.codexPath |
string |
"" |
Path to the codex command for the ChatGPT provider (empty: PATH, then OpenAI's VS Code extension) |
codico.chatDensity |
string |
comfortable |
Chat panel spacing: comfortable or compact |
codico.showReasoning |
boolean |
true |
Show the model's reasoning blocks in the chat |
Project Structure
codico/
├── src/
│ ├── extension.ts # Activation, command registration
│ ├── agentProvider.ts # The panel's view provider: messages from the panel, a turn's setup and its end
│ ├── agentTurn.ts # The agent loop: model requests, tool calls, recovery, stop rules (no editor UI)
│ ├── workspaceTools.ts # write_file, edit_file, search_files, find_files, run_terminal, background processes
│ ├── approvals.ts # Pending approvals: file changes, commands, token-budget checkpoints
│ ├── threads.ts # Thread list: create, open, rename, delete, duplicate, saved metadata
│ ├── compaction.ts # Summarising the earlier part of a long conversation
│ ├── panelCommands.ts # Context attachments, review, run-and-fix tests, auto-commit
│ ├── turnSetup.ts # The model and its key, the system-prompt prefix
│ ├── agentPrompts.ts # Plan-mode and code-review prompts
│ ├── agentPhasePrompt.ts # Phase guidance (act, verify), sent as conversation notes
│ ├── explorationController.ts # Exploration/verification phases of a task
│ ├── iterationBudget.ts # Whether another autonomous step may run
│ ├── toolLoopGuard.ts # Repeated-call detection that ignores repeats after changes
│ ├── contextPreamble.ts # The [Context] block sent with each message
│ ├── contextProjection.ts # Shortens older/duplicate tool results sent to the model
│ ├── historyCompaction.ts # Compaction planning; plan-approval context slimming
│ ├── threadEditing.ts # Edit / delete / regenerate: cut the thread at a turn
│ ├── taskUsage.ts # Per-task token and cost accounting and budget
│ ├── chatFiles.ts # Dropped files, file links, change diffs
│ ├── workspaceText.ts # Reads/writes that respect unsaved editors and later changes
│ ├── lineDiff.ts # Line diffs for approval cards and results
│ ├── editorModel.ts # Which models the editor features can use
│ ├── externalToolRuntime.ts # Browser/network/MCP/LSP/debug tool handlers
│ ├── chatProtocol.ts # Shared extension↔webview message contracts
│ ├── webviewAssets.ts # Webview asset preload, CSP and URI rendering
│ ├── evaluationMetrics.ts # Test-host coding benchmark metrics contract
│ ├── agentRouter.ts # @workspace / @terminal / @vscode / @github context builders
│ ├── openRouterClient.ts # OpenRouter SSE streaming client + system prompt
│ ├── ollamaClient.ts # Ollama OpenAI-compatible streaming client
│ ├── directProviderClient.ts # Direct provider streaming (Anthropic, OpenAI-compat, Google)
│ ├── deepseekAdapter.ts # DeepSeek's differences from the OpenAI protocol (thinking, reasoning replay, cache hits)
│ ├── claudeCodeClient.ts # Claude Code as a provider: runs the claude command as a model, parses its stream
│ ├── claudeCodePath.ts # Finds the claude command (setting, PATH, Claude Code extension)
│ ├── modelFallback.ts # Provider of a model, key status, fallback when a key is missing
│ ├── toolParser.ts # Tool-call fence scanner/parser (handles nested code blocks)
│ ├── nativeTools.ts # Provider-neutral JSON schemas + native tool-call decoding
│ ├── providerConversation.ts # OpenAI/Anthropic/Gemini native tool history serializers
│ ├── agentHistory.ts # Provider-aware assistant/tool-result history mutation
│ ├── workspaceDiagnostics.ts # Workspace Problems summary/count helpers
│ ├── streamCompletion.ts # Stream cutoff detection and resume helpers
│ ├── networkSecurity.ts # Public-address/DNS validation (incl. IPv4 embedded in IPv6) and pinned lookups
│ ├── untrustedContent.ts # Marks web/browser/MCP content as untrusted for the model
│ ├── browserNetworkPolicy.ts # Browser public/private-network request policy
│ ├── urlFetcher.ts # Secure public URL fetch + redirect/text handling
│ ├── terminalProcess.ts # Cross-platform command/process-tree lifecycle + scrubbed environment
│ ├── mcpEnvironment.ts # Minimal environment policy for MCP child processes
│ ├── testOrchestrator.ts # Test-command detection and the /test fix loop prompt
│ ├── indexPersistence.ts # Workspace index storage (vectors + hashes, no raw source)
│ ├── fileManager.ts # File writes routed through centralized workspace policy
│ ├── workspaceSecurity.ts # Multi-root confinement + .codicoignore enforcement
│ ├── codeLensProvider.ts # Explain / Fix CodeLens above function definitions
│ ├── coverageProvider.ts # LCOV / Istanbul JSON parser, coverage prompt builder
│ ├── prContextProvider.ts # GitHub PR context fetcher + formatter
│ ├── workspaceIndex.ts # Semantic search index (embeddings + keyword fallback)
│ ├── inlineCompletionProvider.ts # Ghost-text completions
│ ├── inlineChatProvider.ts # Inline chat widget + editor diff accept/reject
│ ├── commitMessageProvider.ts # Commit message generation from staged diff
│ ├── renameProvider.ts # AI-powered rename suggestion
│ ├── nextEditProvider.ts # Next-edit prediction completions
│ ├── browserManager.ts # Playwright browser wrapper
│ ├── mcpClient.ts / mcpManager.ts # MCP server connection management
│ ├── undoRedoStack.ts # AI change undo/redo history
│ ├── editProposalManager.ts # Edits Mode diff queue
│ ├── symbolProvider.ts # LSP symbol context builder
│ └── ignoreRules.ts # Per-root .codicoignore + legacy .copilotignore policy
├── tests/ # node:test regression + architecture/holdout integrity tests
├── eval/ # Frozen historical coding holdout + VS Code benchmark driver
├── scripts/eval/run.js # Worktree runner, hidden verifier injection, scorecard output
├── .github/workflows/ci.yml # CI: compile/tests on 3 OSes + VSIX packaging gate
├── .github/workflows/release.yml # Tag/release-branch GitHub release + manual Marketplace/Open VSX publishing
├── .github/workflows/eval.yml # Manual-only frozen coding holdout
├── media/
│ ├── chat.html # Small structural webview shell
│ ├── chat.css # Webview presentation layer
│ ├── chat.js # Main webview behavior
│ ├── markdown.js # Extracted Markdown/tool-fence renderer
│ ├── streamNotices.js # Extracted cutoff/error/continue UI
│ ├── models.json # Model list for the dropdown (free / premium / direct / local)
│ └── icon.svg # Activity bar icon
├── out/ # Compiled JS (git-ignored)
├── package.json
└── tsconfig.json
Security
- Centralized workspace confinement — agent file paths are normalized through one multi-root-aware policy before reads, listings, searches, writes, edits, or file-scoped diagnostics; paths that lead outside the workspace through a symbolic link (or a dangling one) are refused
- Open tabs — only the names of other open tabs are sent with a message, never their contents, and a tab outside the workspace or excluded by
.codicoignoreis not named .codicoignoreenforcement — per-root gitignore-style rules hide matching paths from Codico file tools and diagnostics;.copilotignoreremains supported as a compatibility source- Background tasks — a task's edits are made in its own git worktree, never in the files of the window that started it; nothing is merged without a confirmation that shows the changes, and a conflicting merge is undone. Its window is subject to workspace trust like any other. Commands a task runs are not confined to the worktree, which the choice to run them unattended says
- Agent teams — a worker's file tools are confined to its own git worktree (a path outside it is refused, and the workspace's
.codicoignorerules apply there too) and it has no web, browser or MCP tools; merging its work into your workspace waits for your approval like a command, and "Allow all" given to the orchestrator does not extend to workers - Remembered commands — a terminal command runs without asking only if you chose "Always allow" for it on its approval card. A rule is either one whole command, matched exactly, or a build/test command with any arguments (
npm test *), which never matches a command that chains, pipes, redirects or substitutes (npm test; …,&&,|,>,$( ), backticks). Rules live in the workspace's private state, not in a settings file a repository could ship, do not apply in an untrusted folder, and are set aside for the rest of a turn once the agent has read web or MCP content - Permission dialogs — file writes and terminal commands require approval; network fetches, browser actions, and MCP tool calls are separately gated before they can affect external systems
- Terminal secret scrubbing — approved shell commands inherit only an execution/toolchain allowlist (PATH, HOME, Java/Go/Python/Node toolchain roots, temp/system paths, locale), not arbitrary VS Code process secrets
- Secret storage — all API keys (OpenRouter, direct providers, GitHub token) are stored in VS Code's encrypted
SecretStorage, never in plainsettings.json - Content Security Policy — the webview uses a strict CSP with per-session cryptographically random nonces; the extracted webview module is loaded only through a VS Code
asWebviewUriresource - Workspace trust — Codico declares untrusted workspaces unsupported and will not start workspace-defined MCP servers without explicit approval
- MCP trust boundary —
.mcp.json/mcp.jsonservers require first-run approval; persistent approval is tied to the exact command/config fingerprint, and MCP child processes inherit only a minimal runtime environment unless variables are explicitly configured - Project hooks — commands in
.codico/hooks.jsonrun only in a trusted workspace and only after you approved that exact command; they get the reduced terminal environment, a timeout, and no way to widen what the agent may do: a hook can refuse a call or add text to its result, never approve one - Headless runs — the
codicocommand grants only what its options name: with none, the agent can read and nothing else; every approval that was not granted and every dialog is declined and reported, and the exit code says when something was declined; the run uses a temporary profile, so the user's keys and settings are not exposed to it; headless mode exists only in an editor started for it, never in an ordinary window - Pull requests — pushing a branch and opening a pull request always shows a confirmation naming the repository, the branches and the changes; the token is sent to
api.github.comonly, and a remote counts as GitHub only when its host isgithub.com; review comments reach the agent wrapped as untrusted content; Codico posts no comments and resolves no threads - Command sandbox (optional) — terminal commands run under bubblewrap (Linux) or the macOS sandbox with the machine read-only except the workspace, package caches and private temporary folders, credential folders unreadable, and optionally no network; the command is passed as a single argument to the wrapper; the settings are machine-scoped so a repository cannot disable them; a configured writable path can never uncover a credential folder
- Project memory — notes are a file in the workspace, written only through the approved file-change path and visible in the diff; they reach the model as reminders to verify, not as instructions; text that looks like a secret is refused; after web or MCP content was read in a turn, saving a note always asks, so a page cannot plant an instruction for later sessions unseen; not loaded in an untrusted workspace
- Checkpoints — snapshots are stored in Codico's own git repository outside the project, readable by the user only, and never sent anywhere; credential files (
.env, key files,.npmrc, cloud credentials, Terraform state) are never copied into it, whether or not.gitignorelists them; checkpoints are deleted after 14 days by default; a store made under older exclusion rules is deleted on first use; the snapshot commands run with hooks, signing and the user's git configuration switched off; only a commit id is accepted as a checkpoint - Web search — a search sends only its query, to the engine named in the consent dialog; the Brave key is kept in
SecretStorage, sent in a header to Brave only and never passed on through a redirect to another host; result addresses other thanhttp(s)are dropped; results are wrapped as untrusted content - Network SSRF protection —
fetch_urlrejects private/loopback/link-local/reserved DNS answers (including IPv6 forms that embed such an IPv4 address, such as[::ffff:127.0.0.1]), pins the socket to the validated address set to resist DNS rebinding, and repeats validation on every redirect hop - Browser network boundary — browser automation rejects malformed and non-HTTP(S) schemes and validates every HTTP(S) navigation, redirect, subresource and WebSocket against the public-network policy by default. Set
codico.browserAllowPrivateNetwork=trueonly when you intentionally need localhost/internal apps - Semantic-index privacy — cloud semantic indexing is opt-in by default; persisted indexes store vectors/metadata and hashes, not raw source text
- No telemetry — no usage data is collected; model/API calls go directly from your machine to the configured provider
Validation
Every pull request runs the regression suite on Ubuntu, Windows, and macOS, activates Codico inside a real VS Code Extension Host, packages a VSIX, and smoke-installs that packaged extension into a clean VS Code profile.
For autonomous coding quality, Codico also ships a frozen 30-task historical coding holdout. Every task is proven valid: its hidden test fails without a change and passes with the historical fix. The current agent is run against exact pre-fix Codico commits and the relevant regression test is injected only after the agent finishes, so the verifier is hidden during the task. The holdout records success, duration, agent steps, tool calls, changed files, and provider token usage. A quality scorecard covers regressions in the project's own tests, testing after the last change, recovery, edit precision, false completion, pass@1 against pass@k, and cost per verified success. The same tasks can be run by Claude Code or by an oracle that applies the historical fix, and two runs can be compared task by task.
The coding holdout is intentionally manual-only and never consumes model credits on ordinary pushes or pull requests. See eval/README.md for the methodology and reproduction commands.
Development
# Watch mode — recompiles on every save
npm run watch
# Run the compile + regression suite
npm test
# Chat panel UI tests in headless Chrome (set CHROME_PATH if Chrome isn't auto-detected)
npm run test:ui
# Live agent scenarios: the real agent loop in VS Code against a local fake model server
# (no API key, no cost; Linux/macOS)
npm install --no-save @vscode/test-electron@2.5.2
npm run test:live
# Press F5 in VS Code to launch the Extension Development Host
CI runs compile/regression tests on Linux, Windows, and macOS, then launches Codico inside a real VS Code Extension Host and smoke-installs the packaged VSIX before uploading it as an artifact.
To package locally:
npx @vscode/vsce package --out codico.vsix
Releases
- The 0.3.x line added task token/cost tracking, read-only Plan mode, prompt caching and leaner context, safer file handling, MCP and network-security fixes, and the chat features above (message actions, grouped steps, progress header, file links, drag and drop). See CHANGELOG.md for each release.
- Push a tag matching the package version (for example
v0.2.0) to run the release workflow, rebuild/test the extension, run the Extension Host and VSIX-install smoke gates, createcodico.vsix, and attach it to a GitHub Release. - Maintainers can also create a
release/vX.Y.Zbranch at the validated release commit. The workflow validates the package version, creates the matching tag, packages the VSIX, and creates/updates the GitHub Release. - Release-branch runs create the validated Git tag and GitHub Release from the exact release commit.
- Manual workflow dispatch remains the explicit path for Visual Studio Marketplace (
VSCE_PAT) and Open VSX (OVSX_PAT) publication. - Release automation rejects a version/ref mismatch instead of publishing an ambiguously versioned package.