Inferpal 发布本地 LLM 驱动的 IDE 智能体编码助手

An agentic developer assistant for Visual Studio 2026 and 2022 and VS Code, and through the Agent Client Protocol for Zed, the JetBrains IDEs, 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, 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 at feature parity since 1.2.0, and runs as an Agent Client Protocol agent in Zed, the JetBrains IDEs (Rider included), Neovim and Emacs (setup) — one shared engine (Inferpal.Core), every editor.

Highlights

• Agentic loop — 29 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); 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, 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). Same chat, same seven-page settings window in both editors.
• 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 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.
• 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.
• Anchored diff review — /check reviews your pending diff against repo-versioned AI checks 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 at parity — 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).
• Zed, JetBrains IDEs, 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. Tested in Zed and against the protocol's conformance kit; setup for each editor in docs/acp.md.

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

Requirements

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 a 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/.

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.