A powerful AI coding assistant for VS Code that gives you complete control over how you use AI. Connect your favorite providers — NVIDIA NIM, OpenAI, Anthropic Claude, Google Gemini, Groq, and Sarvam AI — with your own keys in your OS keychain, run a fully local coding agent against your own models, or start instantly with no key at all. Chat, explain, refactor, debug, and edit files without leaving the editor: inline suggestions as you type, @ to point at exactly the code you mean, and a 42-tool autonomous agent that plans before it acts, checkpoints every step so you can always undo, runs in the background, and remembers your project across sessions.
Whether you prefer fully local AI, your own cloud API accounts, or a combination of both — you're always in control.
Set up your own local coding agent powered by local models. Point NIM Code at Ollama, LM Studio, or llama.cpp — one-click presets in NIM Code: Switch LLM Endpoint — and keep your code on your machine, working without relying on cloud APIs. Local servers need no key at all.
Use your own NVIDIA NIM, OpenAI, Anthropic Claude, Google Gemini, Groq, or Sarvam AI account. Each provider's credentials are stored securely in your operating system's keychain via VS Code SecretStorage — never in settings files, never on disk, never sent to us.
No API key? No problem. Start instantly with Auto mode — a free AI agent with real tool support and file editing, backed by automatic multi-provider failover so it stays up even when one backend is busy. No sign-up required.
The free tier is 5 requests a day, resetting every midnight — so it's there whenever you want it. Once you've used today's, add your own API key and keep coding with your preferred provider at no cap. No vendor lock-in, and nothing to cancel.
Chat, explain code, generate code, refactor, debug, fix bugs, and edit files — all without leaving VS Code. One sidebar panel that tracks your editor theme, so there's no context switching and no copy-paste.
Choose the best model for every task — Nemotron Super 120B, GPT-5, Claude Sonnet 5, Gemini 2.5 Pro, Sarvam 105B, and more — all from a single dropdown. Add any other model id with the + button, no extension update needed.
A focused, fast assistant that lives in your sidebar and tracks your editor theme — no context switching, no copy-paste.
Start working the moment you install — no sign-up, no key, no credit card. Auto runs a real agent loop (file edits and terminal included) through a built-in gateway that fails over across providers automatically, so the free tier stays up even when one backend is busy. It carries a focused 17-tool roster to stay inside the gateway's limits, and gives you 5 requests a day.
Auto always uses the free tier — it ignores the model picker and any keys you have set. To run your own model with no daily cap, switch to Chat or Agent and pick it from the dropdown.
Pick from curated models across six providers — NVIDIA NIM, OpenAI, Anthropic, Google, Groq, and Sarvam AI — from one dropdown, or add your own model ID with the + button. Each provider uses its own API key; only the key for your selected model's provider is needed.
Hand off multi-step tasks to a 42-tool agent. It reads, searches, writes and refactors files, runs terminal commands, queries git, and opens files in your editor — showing each tool call as it works. Independent reads run in parallel; edits and shell commands stay strictly one at a time so approval prompts can never race. Four approval modes decide how much it may do unattended, a diff preview gates every file write, checkpoints let you undo an entire run, and Plan mode blocks every mutating tool outright — including tools from connected MCP servers.
In Plan mode the agent investigates read-only, then publishes a structured, numbered plan for you to review. Approve to let it execute automatically, or dismiss and refine — no filesystem or shell access until you say go.
Dispatch a task and keep working — it runs asynchronously while you switch sessions or keep coding. Multiple runs go at once; a status-bar item and per-session badges show progress, with a notification when one finishes or needs approval.
Line up several tasks and run them one at a time, each starting only once the previous finishes — ideal when one step depends on the last (refactor → update call sites → update tests).
Every turn loads CLAUDE.md, a git-committed .nimcode/memory.md shared with your team, and a personal cross-workspace memory the agent maintains itself — so context and conventions persist without repeating yourself.
Connect your own local MCP servers and their tools merge straight into the agent's roster, namespaced per server — bring your own integrations alongside the 42 built-ins. Each server carries a trust level, because nothing in the protocol says whether a third-party tool reads or writes: the default confirms every call and blocks them in Plan mode, and only a server you mark read-only runs unattended.
Type / for context-aware actions on your selection — explain, fix, review, refactor, test, document, and more.
Drop a Markdown file with frontmatter into .nimcode/skills/ and it appears in the / menu for everyone who clones the repo. Placeholders pull in your selection or input, and a machine-global folder holds the ones you want everywhere.
Run your own shell commands around tool calls and turn completion — block risky edits, auto-format on write, or force the agent to keep going until your build passes.
Token-by-token streaming with mid-generation cancel, pasted-screenshot image attachments, rendered Mermaid diagrams, a live context-budget bar, and auto-summarized long conversations.
Every provider's API key — NVIDIA NIM, OpenAI, Anthropic, Google, Groq, Sarvam AI — lives in the OS keychain via VS Code SecretStorage, never in settings files or on disk.
Every conversation is saved locally. Rename, delete, and switch between sessions from the history list anytime.
Two things that keep you out of the panel entirely — suggestions inline in your file, and a way to say exactly which code you mean.
Ghost-text suggestions as you type, in any language. Tab to accept. Requests are debounced, superseded the moment you keep typing, and cached near the caret, so retyping a line costs nothing. A suggestion that would duplicate the code after your cursor is discarded rather than shown.
It ships off by default, on purpose. Completion sends a request on nearly every keystroke, so switching it on for you would quietly spend your provider credits. It uses your own API key and never the free Auto quota — turn it on with NIM Code: Toggle Inline Completion, and point it at the fastest, cheapest model you have.
@-mentions — say exactly what to look atType @ anywhere in the composer to attach context explicitly instead of hoping retrieval guesses right. The menu completes in place, so explain @src/auth.ts against @tests/auth.test.ts works mid-sentence.
Mentions are parsed from your message rather than tracked as you click, so a pasted path behaves identically to one picked from the menu. What you attach outranks automatic retrieval — a mentioned file is attached in full, and the auto-context block skips it instead of spending its budget echoing the same file back.
The agent loop calls these one at a time, reasoning between each step — so it stays grounded in your actual codebase. Independent reads batch and run concurrently; edits, deletes, and shell commands always run one at a time. Connect your own MCP servers to add more.
Undo any run, catch what a fix silently broke, and hand off work too large for one chat turn — architected pipelines, not just a bigger prompt.
The agent snapshots your workspace before any step that may change files, using a private shadow git repo that never touches your own .git, index, or branches. Rewind to any point in a run, or compare what changed — works even in a folder with no repository at all.
A turn that changed files runs your project's own build, lint, and test commands before it's allowed to end. Anything newly broken is fed straight back to the agent to fix; failures your repo already had are reported, never gated on — so it never gets conscripted into someone else's bug.
Field a role-scoped pipeline for one substantial goal: an architect explores once and hands its brief down, a coder and tester then work in parallel inside their own path leases, and a reviewer checks the result — sequenced by host code, not a prompt instruction a model can forget. One approval covers every writer's scope up front.
Give the agent one goal and a budget, and it runs a fixed pipeline — understand → plan → implement → test → fix → security & review → commit — as a guaranteed order rather than something a full context window makes it forget. Every stage's cost is metered against the ceiling you set, unmetered local calls are reported honestly rather than shown as $0.00, and one prompt approves the scope up front with a second just for the final commit.
Ask for a diagram, chart, or interactive page and it renders as a card you can expand into a full editor-area panel — Markdown, SVG, Mermaid, HTML, or React. Executable kinds run sandboxed with no connect-src of their own, so generated content can never phone home.
Deterministic answers, not model guesses: a failing stack trace resolves to a source line by arithmetic, co-change history shows what really changes together, and known failure patterns are recognized instantly — attached straight to the failing tool result, no extra round-trip to find out why.
Every one of 56 settings in one searchable editor tab, plus what VS Code's own settings UI can't do: per-provider key status, custom-model and MCP server management, and hooks validated against your live tool roster.
Highlight code, type a slash command, and the right system prompt is sent automatically with your selection attached.
Pick a mode for what you're doing, then a Plan/Manual/Edit/Auto level for how much it can do without asking.
No API key required. A real agent — file edits and terminal included — on a focused 17-tool roster, through a gateway that fails over across providers. Always the free tier, so the model picker doesn't apply.
5 free / dayAny model, any provider, no tools — quick questions, explanations, and code review without touching your files.
Requires API keyAll 42 tools plus any connected MCP servers — multi-step tasks, file edits, terminal commands, delegation.
Requires API keyCurated models from every provider ship in the dropdown. Add any other model ID via the + button — or point the extension at a local server and run entirely offline. No extension update needed either way.
Each provider has its own API key (NIM Code: Set API Key), stored in the OS keychain. Going local? Run NIM Code: Switch LLM Endpoint, pick a preset or type your own URL — loopback addresses skip the key requirement entirely, and every feature works identically.
From zero to your first answer in under two minutes — or skip straight to step 4 for Auto mode, free, no key required.
For Chat/Agent mode: get a key from any of six providers — build.nvidia.com, OpenAI, Anthropic, Google AI Studio, Groq, or Sarvam AI. Skip this for Auto mode, or if you're running local models.
Search "NIM Code" in the Extensions panel, or grab it from the VS Code Marketplace.
Run NIM Code: Set API Key, pick a provider, and paste your key. Going local instead? Run NIM Code: Switch LLM Endpoint and pick Ollama, LM Studio, or llama.cpp — no key needed. Skip both to stay on Auto mode.
Click the N icon in the Activity Bar or press Ctrl+Shift+N. The mode toggle defaults to ✦ Auto — done. Want suggestions inline as you type too? Run NIM Code: Toggle Inline Completion (needs a key).
Agent mode loads three sources of memory into its system prompt on every turn, so you stop repeating yourself.
A CLAUDE.md at your workspace root — build commands, architecture, conventions — is read and injected automatically. You author it; the agent never writes to it.
Git-committed and structured by category (architecture, decisions, TODOs). The agent writes to it via the project_memory tool, auto-captures decisions on compaction, or you add entries from the memory panel or right-click menu.
A machine-global memory the agent maintains itself — facts and preferences that carry over to other projects on this machine, separate from any one repo.
Sensible defaults out of the box, with full control over models, timeouts, and where your data goes.
{ // Endpoint — swap for a local server to run fully offline: // Ollama http://localhost:11434/v1 // LM Studio http://localhost:1234/v1 // llama.cpp http://localhost:8080/v1 (no API key required) "nimcode.baseUrl": "https://integrate.api.nvidia.com/v1", // Default model for Agent mode — use a strong tool-use model "nimcode.defaultAgentModel": "nvidia/nemotron-3-super-120b-a12b", // Self-correction: feed fresh errors/warnings back after every edit "nimcode.autoDiagnostics": true, // Auto-pull relevant snippets from the semantic index into every request "nimcode.autoContext": true, // Git-committed, team-shared project memory (.nimcode/memory.md) "nimcode.projectMemory.enabled": true, // Inline ghost-text completion — off by default, uses your own key "nimcode.completion.enabled": false, // Empty = your chat model. Pick the fastest one you have. "nimcode.completion.model": "", // Bring your own models "nimcode.customModels": [ { "id": "meta/llama-3.3-70b-instruct" } ] }
.. traversal above the project root are refused.Perfect for developers who want the flexibility to use local models, their own AI provider accounts, or a built-in free agent — all from one modern VS Code extension. Install and run your first prompt in minutes.