Navy AI Coder

An autonomous AI coding assistant for VS Code. Navy works with any AI provider — local or cloud — to read your project, edit files, run commands, search the web, and manage dev servers, all with your approval before anything touches disk.

Preview release — core features are stable. Report bugs at github.com/zrnge/navy-coder/issues.

• Agentic tool loop — Navy reads files, searches the codebase, runs commands, and applies edits autonomously until the task is done, remembering what it actually did (files read, commands run and their exit code) across the whole conversation, not just what it said it did
• Diff approval gate — every file change is shown as a side-by-side diff; you approve or reject before it's written
• Multiple projects, multiple chats — a tab strip holds several conversations per project (a running turn keeps streaming in a background tab while you work in another), and Navy remembers every project you've ever opened in a small catalog (~/.navy/projects.json) so you can jump back into one without re-browsing for its folder — picking one offers to replace the current workspace or add it alongside what's already open
• 11 AI providers — Ollama, LM Studio, OpenAI, Anthropic Claude, DeepSeek, Google Gemini, xAI Grok, z.ai, Groq, OpenRouter, and any custom OpenAI-compatible endpoint — with a native path for Anthropic extended thinking and Gemini's thinking/tool-call signatures, not just an OpenAI-compatible shim
• Per-provider API keys — switch providers without losing other keys; keys live in VS Code's OS keychain, never on disk
• Opt-in cross-provider failover (navy.providerFallbacks) — an ordered list of backup providers Navy falls through to on a genuinely transient failure (rate limit, outage, network error) — never for an auth/quota/context-length problem, and every fallback attempt is announced in the chat before it runs
• Running cost estimate — a cumulative token counter with an approximate $ cost for well-known hosted models, priced per turn using whichever provider actually served it; local models always show $0
• Deep retrieval — find_relevant_files blends keyword search with semantic embeddings (chunked per-file, not truncated to the first slice) and real LSP symbol matches, and the repository map the model sees is enriched with a one-line function/class outline per file, not just a bare file tree
• delegate_research — the model can spin off an isolated, read-only sub-agent for a broad investigation, getting back only the written conclusion instead of filling the main conversation with every file it looked at
• Opt-in Docker sandboxing (navy.sandboxMode) — run commands, tests, and dev servers inside a container built from the project's own .devcontainer/Dockerfile, as a second layer of isolation on top of the approval gate (macOS/Linux hosts in this release — see Safety)
• Opt-in persistent background processes (navy.persistBackgroundProcesses) — let a dev server survive a window reload instead of being killed, with its output logged to a file and Navy offering to stop it if you reopen the project with one still running
• MCP tool servers — plug in any Model Context Protocol server, local (stdio) or remote (streamable HTTP), same config format as Claude Desktop (navy.mcpServers)
• Prompt caching on Claude — repeated agent steps reuse the cached prefix: several times cheaper and faster
• Web search — built-in search via DuckDuckGo (no key needed), Brave Search, or Tavily
• Terminal cards — every command shows an IN/OUT card in the chat with live output, exit status, and expandable logs
• Dev server management — start, monitor, and stop your dev server from the chat, with live server-URL detection
• Git integration — status, diff, log, and blame tools available to the agent
• Independent syntax verification (check_syntax) — real parsers/toolchains (JSON, node --check, and Python/Go/Rust/TS/Ruby/PHP/Bash when installed), not just whatever language extensions happen to be installed
• Multi-root workspace aware — search and file tools can target a sibling folder explicitly in a multi-root workspace, not just the active project root
• Rename & delete are undoable — transactional undo/redo across edits, renames, and file deletions; structural rename_symbol uses the real language server when one's available
• Inline completions — ghost-text suggestions as you type (opt-in, can use a separate faster model via navy.completionModel), with real fill-in-middle context from both sides of the cursor
• Code Lens — "Ask Navy" buttons above functions in the editor
• No telemetry, zero runtime dependencies — nothing is sent anywhere except to the AI provider you configure; the shipped extension has no npm packages bundled in besides the code in this repo

From the VS Code Marketplace (recommended)

Search for Navy AI Coder in the Extensions panel (Ctrl+Shift+X) and click Install.

From a VSIX file

1. Download the .vsix from the Releases page
2. Open the Extensions panel, click ··· → Install from VSIX…, and select the file

1. Install Ollama and pull a model:

   ollama pull qwen2.5-coder:7b
   

2. Open VS Code, click the Navy anchor icon in the activity bar
3. The provider defaults to Ollama — start chatting

1. Open the Navy sidebar and click the Settings gear
2. Set Provider to your provider (e.g. openai)
3. Paste your API key — it's stored in VS Code's encrypted secrets, never on disk
4. Set the Model (e.g. gpt-4o, claude-sonnet-5, deepseek-coder) — leave it empty to auto-select the first available model for that provider
5. Start chatting

Model lists are fetched live from each provider's API where supported, so new models show up automatically.

Navy runs an autonomous tool-use loop. The full tool set:

Every file-mutating tool goes through the diff approval gate (unless navy.approvalMode is set to auto-approve), and every edit is undoable.

• Workspace trust — in an untrusted workspace, Navy still reads files and answers questions, but every tool that executes code or sends data off the machine (shell commands, tests, dev servers, MCP servers, embedding upload) refuses at runtime.
• Approval gate — navy.approvalMode defaults to ask-always: every edit is a diff you approve, every shell command is a confirmation dialog. auto-approve removes that gate — use it deliberately.
• Opt-in Docker sandboxing (navy.sandboxMode) — a second, independent layer under the approval gate; refuses to guess at a generic container image if the project has no devcontainer/Dockerfile of its own. macOS and Linux hosts only in this release: on Windows, Navy writes commands in cmd.exe dialect and runs them via cmd /c, which does not exist inside a Linux container, so sandboxed commands fail — leave it off on Windows.
• Cross-provider failover is opt-in and narrow — only ever triggers for a transient failure (rate limit, outage, network error), never for anything that would just fail again with the same account, and every attempt is announced in the chat before it runs since it can spend money on a different provider account.
• check_syntax runs in isolation — checkers execute outside the project directory with hardened interpreter flags, so verifying a file can't execute code from the repository being inspected.

Open via File → Preferences → Settings and search for navy, or click the gear icon in the Navy sidebar.

API keys are not stored in settings — they are stored in VS Code's encrypted secrets store (same as your GitHub token). Set them via the Navy sidebar's Settings panel.

Also available and only reachable via the Command Palette (Ctrl+Shift+P / Cmd+Shift+P → search Navy): Undo Last Edit, Generate PR Description, Ask About This Function, Explain Terminal Error, Export Conversation, Review Pull Request.

• Your code is sent to whichever AI provider you configure. With Ollama or LM Studio, everything stays local.
• API keys are stored in VS Code's OS keychain — never written to disk or sent anywhere except the configured provider.
• Semantic search (navy.embeddingModel) is opt-in and off by default; enabling it sends file content to your configured embedding provider — see that setting's description for exactly what's excluded.
• Navy has no telemetry. Diagnostic logging (failed background saves, provider errors) stays local to the "Navy Coder" output channel (View → Output) and is never sent anywhere.

npm install
npm test    # 700+ tests: mocked-provider unit tests, no network or API keys needed
npm run build

npm run eval drives the real agent loop against a real configured model in a temp repo and scores the result — a capability check, not a unit test; see eval/README.md.

MIT — see LICENSE