Inferpal

An agentic developer assistant for Visual Studio 2026 and 2022 and VS Code, and through the Agent Client Protocol for Zed, the JetBrains IDEs, Qt Creator, Neovim and Emacs — powered entirely by local LLMs: Ollama, LM Studio, or any OpenAI-compatible server. Full tool calling, inline ghost-text completions, semantic codebase search, and zero required cloud dependency.

Inferpal for Visual Studio · Inferpal for VS Code
or download the latest release — Inferpal-vs2026-*.vsix for Visual Studio, inferpal-vscode-<platform>-*.vsix for VS Code (Windows x64, Linux x64 or Apple Silicon), inferpal-acp-<platform>-* for Zed, JetBrains IDEs, Qt Creator, Neovim and Emacs (setup).

---

What is Inferpal?

Inferpal turns a local model into a fully agentic coding assistant living inside your IDE. The model autonomously chains tool calls — reading and writing files, running commands, building, testing, and searching your codebase — to complete real tasks, while every write and every command stays behind an approval gate and a workspace sandbox. No API key, no telemetry, no cloud required.

It ships as a Visual Studio 2026 and 2022 extension (the primary target) and a VS Code extension on the same engine, and runs as an Agent Client Protocol agent in Zed, the JetBrains IDEs (Rider included), Qt Creator, Neovim and Emacs (setup) — one shared engine (Inferpal.Core), every editor.

Highlights

• Agentic loop — 30 built-in tools, plus user-defined shell tools and MCP servers (stdio or Streamable HTTP, of the 2026-07-28 revision or an earlier one) — a server too heavy for the context window, like an IDE's own, waits on demand and tool_search loads its tools; any tool can be turned off one by one (/tools off <tool>, or the Tools page of the settings); a server that needs a value from you — a repository, a date, a choice — asks on a card in the chat that you fill, checked before it is sent, answered by nobody but you; independent read-only tools run in parallel.
• Local-first — Ollama, LM Studio, or any OpenAI-compatible server (llama.cpp, vLLM); run the backend locally or on a remote GPU host.
• A chat you can read at a glance — an agent run's steps fold into one line (3 steps · read 1 file · edited 1 · build passed), the answer ends on a result bar with the files changed — what its commands, test runs and MCP tools changed in a git repository included — the last build or test check and Undo run, and approvals are cards inside the conversation (Allow once with Enter, Deny with Esc, Open diff for the whole change) — and when one narrow rule describes the call, Always: commands that start with dotnet test or writes under tests/, saved to your machine's rules, never a chain, a launcher or a program that deletes. Same chat, same seven-page settings window in both editors.
• Steer a running turn — type a correction while the agent works and press Enter: the run reads it before its next step, nothing stopped and nothing explained again; Ctrl+Enter queues a message for after the turn.
• Long runs you can leave — the machine stays awake while the model works (Windows, macOS, Linux) and may sleep while an approval waits; a card left unanswered in an unfocused editor flashes the VS taskbar or raises a VS Code notification; a turn stopped at its iteration or length limit ends with a Continue button.
• Inline ghost-text completions — Fill-in-the-Middle as you type (Tab / Esc), with three speeds: Fast, Balanced, Accurate.
• Semantic codebase search — background indexing with hybrid retrieval (cosine + BM25 fused with RRF) and per-turn auto-context.
• Smart Fix Protocol — after every edit, a polyglot build/typecheck (.NET / TypeScript / Rust / Go) feeds compile errors back so the agent fixes them in the same loop.
• Code actions & Inline Edit — Explain / Fix / Refactor / Add Tests / Add Docstring, plus Ctrl+Shift+I in Visual Studio to rewrite a selection in place.
• Safety by default — approval-gated writes/commands, a catastrophic-command hard denylist, force-prompt on indirect execution (iex, -EncodedCommand, …) and on anything a cloned repository authored (committed validators, permission overlays), committable permission rules, and a hardened SSRF guard.
• Invented packages refused before you are asked — local models invent package names (Apache.Parquet, ibantools on PyPI). A package a call adds — dotnet add package, npm install, pip install, uv add, or a dependency written into a .csproj, package.json, requirements.txt or pyproject.toml — is first looked up on its public registry (nuget.org, npm, PyPI); a name it does not have is refused before the approval card, and the model is told the close names that do exist. Only the added name is sent, and only to a public registry: a company feed or a registry that does not answer leaves the call to the card, unchecked. One setting turns it off.
• Files your repository keeps away from AI, kept away — .aiignore, .cursorignore, .geminiignore, .aiexclude and the other tools' ignore files (and Inferpal's own .inferpalignore) are read in the gitignore syntax and honoured by everything that reads for the model: tools, @-mentions and chips, the index, pinned files, ghost text, code actions and git diffs. Every exclusion is said — the file, the line and the pattern — so a model never concludes a file does not exist, and /check and /commit say what they did not read.
• Nothing written into your repository behind your back — Inferpal never edits your .gitignore. Before the agent changes a file it keeps a copy for /undo-run and /restore: in .inferpal/history/, which ignores itself in git, or — with Backups of changed files set to In my user folder — in Inferpal's local application data, one folder per repository, and nothing new is written into the project.
• Your repository's agent setup, read as it is — AGENTS.md, CLAUDE.md and the instruction files written for Copilot, Cursor, Cline, Roo and Continue go with your questions (always, or when the active file matches), and /instructions shows what each one sends; the commands written for Copilot, Claude Code and Continue become slash commands; skills (SKILL.md) are joined with /skill; the repository's MCP servers start only after you approve them. On a fixed 10-question bench, two local models followed a repository rule 8/10 and 10/10 with its instruction file, 0/10 without.
• Coming from Continue or Roo Code — /import continue reads your ~/.continue/config.yaml (or the older config.json), /import roo a Roo Code settings export: a card lists what Inferpal can take — the model server and the models by role, rules, prompts and custom modes as commands, MCP servers, documentation sites, command rules — and why every other part stays (a hosted provider is never imported). Nothing is written until you apply, and your settings are copied aside first. See Coming from Continue or Roo Code.
• Governance & knowledge — repo-versioned .inferpal/rules & AI checks, @Docs external-doc indexing, typed @-mentions, and 50+ slash commands.
• Built for the IDE — live debugger awareness, VRAM monitoring, VS theme adaptation, and 10 UI languages.
• Debugger loop — /debug [goal] lets the agent drive a real debug session from the chat: breakpoints, stepping, locals and call-stack inspection, in both editors (Visual Studio via an in-process driver, VS Code via a DAP bridge). Read-only, and starting a session always asks first.
• /tdd with a debugger — when a test fails, the loop stops guessing from the runner's text: the failing test is re-run under the editor's debugger and the exception, the stack and the expanded locals go into the fix prompt. Measured on a fixed 12-case bench with a local 27B model: 12/12 fixed against 10/12 without it. It asks once per run, degrades cleanly when no debugger is available — and says so instead of silently looping. Writing a test file during a /tdd run always asks, whatever the permission rules say.
• Compiler-backed code intelligence — analyze_code (its impact mode) and rename_symbol resolve C# symbols with the Roslyn compiler instead of name matching: real references, not homonyms — and rename_symbol no longer rewrites unrelated tokens that merely share the name. It follows the symbol into markup too (.razor, .cshtml, .xaml: bindings, Model.X, asp-for, a component's code, route and tag attributes) and lists every other occurrence instead of guessing; a file a generator writes is never edited by hand, and the refusal names where the change goes.
• Anchored diff review — /check reviews your pending diff — or a branch before its pull request (/check main..HEAD), or one commit — for any bug or regression, with your repo-versioned AI checks on top, and anchors every finding to a diff line (and says so when a location can't be confirmed); /commit drafts the message, /commit-exec runs it only after you've read it.
• Persistent plans — /plan save|list|next|done turns the current plan into a committable markdown file under .inferpal/plans/ that survives /clear, restarts and editors; a plan can never execute anything by itself.
• Background agent tasks — /task [goal] runs a read-only agent while you keep coding (serial queue behind the GPU scheduler); /task propose records the writes it would make, and /task apply replays each one through the normal approval prompt — never granted in advance.
• Project onboarding — a committable, non-privileged .inferpal/project.json profile plus /onboard (report, apply model-role recommendations, generate the project context file). Classified by allow-list: unknown keys are ignored, never interpreted.
• Multi-model toolkit — /bench scores your installed models per role, /arena runs blind A/B duels, and the Model Router sends background tasks (titles, commit messages, summaries) to a small utility model — never cold-loading one.
• Conversation branching — /branch <n> forks a conversation at any turn: the branch keeps turns 1..n and the conversation continues there, while the original is written back to disk first. /branch lists the branch points and the family tree, /branch <name> switches. Branches are plain session files, so nothing else had to learn about them.
• Transparency — the Context X-Ray panel breaks down the exact prompt sent to the model, layer by layer — the tool definitions each turn carries included — with per-layer toggles; /replay reconstructs an agent run post-mortem; /fix /refactor /doc show a per-hunk inline diff preview before touching your buffer.
• VS Code on the same engine — the same chat (markdown, tool bubbles, plan display, typed @-mentions, slash commands with autocomplete), the same settings, the same approvals and inline FIM completions, backed by a bundled self-contained host (no .NET install needed). A few editor features are Visual Studio-only for now — Edit with AI, the Build Failed banner, /fix-build among them: the list.
• Zed, JetBrains IDEs, Qt Creator, Neovim and Emacs — the same engine as an Agent Client Protocol agent: each release carries an archive per system (Windows x64, Linux x64, Apple Silicon) whose executable, run with --acp, is started by the editor. The real diff is shown before every change and asked for, a file with unsaved changes in the editor is never written over, the three modes and the model are session options, sessions are saved and reloaded, and the editor's MCP servers are started for the session. Where the editor shows them (Zed 1.25 and later, ACP 1.11), Inferpal's notices and conversation compactions arrive as such, out of the transcript. Its settings are the same seven pages as in Visual Studio and VS Code, opened in your browser — /settings in a thread, or a button at first setup — and what you save applies from your next question. Tested in Zed, Rider, Qt Creator, and Visual Studio through Code Wicket, and against the protocol's conformance kit; setup for each editor, and how to run it across machines safely, in docs/acp.md.

See docs/features.md for the full functional tour.

---

Requirements

Requirement	Details
Editor	Visual Studio 2026, or Visual Studio 2022 from 17.14 — Community / Professional / Enterprise, one package for both — or VS Code (Windows x64, Linux x64, or Apple Silicon on macOS 12 or later).
.NET SDK	.NET 10 (building from source only — the VS Code VSIX bundles its own runtime)
Model server	Ollama (default — full hardware-aware features), LM Studio, or any OpenAI-compatible server, local or remote

Tool calling is required: the models measured best as the agent are qwen3.8 and devstral-small-2 — every model's results in Models, with the setup that fits an 8, 12, 16 or 24 GB card (By graphics card). Inline completions work best with a model trained for them (Mellum2 or Qwen3.8, measured); semantic search works best with a dedicated embedding model.

---

Quick Start

1. Install the extension:

   • Visual Studio: search Inferpal in Extensions → Manage Extensions, or install it from the Marketplace;
   • VS Code: search Inferpal in the Extensions view, or install it from the Marketplace;
   • or from the latest release: double-click Inferpal-vs2026-<version>.vsix (close Visual Studio first — the merge that registers an extension gives up, silently, if any part of the configuration is in use), or code --install-extension inferpal-vscode-<platform>-<version>.vsix;
   • or build from source: dotnet build Inferpal/Inferpal.csproj — see Development.

2. Start a model server:

   ollama serve          # LM Studio / any OpenAI-compatible server also work
   ollama pull qwen3.8   # or devstral-small-2, faster

3. In Visual Studio open Tools → Inferpal (or Alt+B / Alt+O); in VS Code, open the Inferpal view in the Activity Bar.

4. Open Inferpal Settings, pick the provider, set the server URL, select a model, click Test, then start chatting. (Both editors share the same Inferpal configuration.)

Full walkthrough: Getting Started.

---

Documentation

Complete functional and technical documentation lives in docs/.

Functional	Technical
Getting Started · Providers · Models · Configuration	Architecture
Features · Slash Commands · Tools · Mentions	Development
Search & Indexing · MCP · Rules & Checks · Remote Inference · Zed, JetBrains, Qt Creator, Neovim (ACP) · Coming from Continue or Roo

---

Official sources

Inferpal is an independent open-source project (GPL v3) by EstaxNet. It runs on your machine, has no hosted version and no account, and is not affiliated with any cloud or API provider. The only official sources are this repository's releases and the two Marketplace listings, for Visual Studio and VS Code. An article that describes Inferpal as a cloud service is not about this project.

---

Contributing

Contributions are welcome — see Development for the build, the project layout, and how to add a tool or a language. Quick version: implement ITool, register it in ToolRegistry.cs, and add any new strings to all 10 .resx files and to Strings.cs.

---

License

Licensed under the GNU GPL v3.

Acknowledgments

Developed with the assistance of Claude (Anthropic).

---

Not finding Inferpal on Google?

As of October 2026, Google no longer returns any result for Inferpal — not this repository, not its releases, not its Marketplace listings — while other search engines, such as Bing, DuckDuckGo and Brave, still do. If a search brought you nothing, the official sources are the ones named above: this repository, its releases, and the Marketplace listings for Visual Studio and VS Code.