IDE Plugins That Connect to Air-Gapped LLMs — A 2026 Practical Guide

Why "Air-Gapped LLM + IDE Plugin" Matters Now

The AI coding assistant market has exploded. Cloud-based tools like GitHub Copilot and Cursor have gone mainstream, yet development in finance, defense, healthcare, and government still takes place inside air-gapped networks — environments completely isolated from the public internet, designed to ensure that classified code and sensitive data never leave the perimeter.

The tension is clear: AI coding tools have proven productivity gains of 30% or more, but organizations that cannot send code to external servers are locked out of those benefits. The answer emerging across the industry is a new architecture — deploy local LLMs on internal servers and connect them to IDE plugins so developers get the same AI-powered experience without a single byte leaving the network.

This article walks through the core components of building an LLM-based coding assistant in air-gapped environments: definitions, architecture, a comparison of the leading tools, real-world use cases, and what lies ahead.

---

How It Works: The Air-Gapped LLM + IDE Plugin Architecture

The entire stack breaks down into three layers.

Layer 1 — LLM Inference Server

An inference server hosts and serves the LLM inside the isolated network. The most common options are Ollama, vLLM, and NVIDIA NIM. Ollama is lightweight and developer-friendly; NVIDIA NIM provides enterprise-grade GPU acceleration with official air-gap deployment support. Model files are downloaded on an internet-connected machine, then transferred to the air-gapped server via physical media such as USB drives or portable disks.

With Ollama, for example, you would run ollama pull qwen2.5-coder:14b on an external machine, then copy the entire ~/.ollama/models/ directory to the air-gapped server.

Layer 2 — OpenAI-Compatible API Proxy

Most IDE plugins communicate using the OpenAI API format (/v1/chat/completions). Ollama natively exposes an OpenAI-compatible endpoint. For teams that need finer-grained authentication and logging, LiteLLM can be placed in front as a proxy. LiteLLM supports per-user API key issuance, request logging, and multi-model routing — useful for managing access across teams.

Layer 3 — IDE Plugin

Developers install a plugin in VS Code, JetBrains, or their IDE of choice and point the endpoint to the internal server address (e.g., http://192.168.1.100:11434). The plugin sends code context to the inference server, which returns completions. All data circulates exclusively within the internal network, satisfying security requirements.

---

Comparing the Leading IDE Plugins

1. Continue.dev — Open Source, Model-Agnostic Flexibility

Continue is an Apache-2.0 licensed open-source project supporting both VS Code and JetBrains IDEs. Its standout feature is a model-agnostic architecture: a single config.yaml lets you switch freely between local models (Ollama, LM Studio, llama.cpp) and cloud providers (OpenAI, Anthropic). It offers four modes — Chat, Autocomplete, Edit, and Agent. The 2025–2026 updates significantly strengthened the Agent mode, which can now autonomously read/write files, execute terminal commands, and search codebases.

For air-gapped environments, disable telemetry and point the endpoint to a local Ollama server — that is all it takes for fully offline operation. It is free for individual developers, and the Teams plan costs just $10/developer/month.

# ~/.continue/config.yaml example
models:
  - title: "Qwen2.5-Coder-14B"
    provider: ollama
    model: qwen2.5-coder:14b
    apiBase: http://internal-server:11434
tabAutocompleteModel:
  title: "StarCoder2-3B"
  provider: ollama
  model: starcoder2:3b
  apiBase: http://internal-server:11434

2. Tabby — Self-Hosted, All-in-One Solution

Tabby is an open-source, self-hosted coding assistant with over 33,000 GitHub stars. Unlike Continue, Tabby ships both the server and the client as a single package. A single Docker container spins up the inference server, and VS Code, JetBrains, or Vim plugins connect directly. It requires no external DBMS or cloud services and runs on consumer-grade GPUs.

Enterprise features include team management, usage analytics, SSO integration, and audit logging. Repository indexing lets the AI learn your project's unique context. Recent versions added an Answer Engine (Q&A) and inline chat, extending Tabby well beyond simple code completion.

# Launch Tabby server (Docker, GPU environment)
docker run -it \
  --gpus all -p 8080:8080 -v $HOME/.tabby:/data \
  tabbyml/tabby \
  serve --model StarCoder-1B --device cuda --chat-model Qwen2-1.5B-Instruct

3. Tabnine Enterprise — The Commercial Enterprise Leader

Tabnine has been in the market since 2018 and was named a Visionary in the September 2025 Gartner Magic Quadrant for AI Code Assistants. The Enterprise plan ($39/user/month) supports SaaS, VPC, on-premises Kubernetes, and fully air-gapped deployments. Notably, Tabnine partnered with Dell to offer a turnkey bundle — Dell PowerEdge servers with NVIDIA GPUs — providing a hardware-to-software package ready for deployment.

It supports over 20 IDEs (VS Code, JetBrains, Eclipse, Visual Studio, Neovim, and more) and allows organizations to register private endpoints for their own LLMs, including Llama 3, Claude, and Gemini. Governance features such as license conflict detection, a code review agent, and Jira integration make it well-suited for regulated industries. Tabnine holds SOC 2 Type II, ISO 27001, and GDPR certifications, addressing the strictest compliance requirements.

4. DevoxxGenie — Lightweight, JetBrains-Native

DevoxxGenie is an IntelliJ IDEA plugin that connects to multiple local LLM backends — Ollama, LM Studio, GPT4All, and llama.cpp. It communicates with air-gapped internal servers via a Custom OpenAI URL. Features include code review, test generation, and code explanation. Recent additions include security scanning (Gitleaks, OpenGrep, Trivy) and Spec Driven Development, where the agent autonomously implements tasks defined in a backlog. A solid free, open-source option for teams deeply embedded in the JetBrains ecosystem.

5. Sourcegraph Cody — Built for Massive Codebases

Cody sits on top of Sourcegraph's code search engine, combining AI with deep code intelligence. Its key advantage is cross-repository context — it indexes dozens to hundreds of repositories simultaneously, understanding inter-service dependencies. Self-hosted deployment is fully supported with guarantees that code never leaves your infrastructure. It works with VS Code, JetBrains, Visual Studio, Web, and CLI interfaces. Note that as of mid-2025, individual free plans were discontinued; only the Enterprise plan ($49/user/month) remains.

6. Pieces for Developers — Air-Gapped, On-Device Processing

Pieces emphasizes on-device LLM processing at its core. Through the VS Code plugin, data flows over local HTTP/gRPC connections. When using on-device models like Mistral or Llama 3, context never leaves the local environment. Its unique Workstream Pattern Engine understands developer workflows on a temporal basis — tracking when, where, and how you work to provide contextually grounded assistance.

---

Tool Comparison Summary

License	Apache-2.0	Open Source	Commercial ($39/user/mo)	Open Source	Commercial ($49/user/mo)
Air-Gap Support	✓ (via Ollama)	✓ (built-in server)	✓ (turnkey bundle)	✓ (local LLM)	✓ (self-hosted)
IDE Support	VS Code, JetBrains	VS Code, JetBrains, Vim	20+ IDEs	JetBrains	VS Code, JetBrains, etc.
Separate Server Required	Yes (Ollama, etc.)	No (all-in-one)	Yes (K8s / Dell bundle)	Yes (Ollama, etc.)	Yes (Sourcegraph)
Model Flexibility	High	Medium	High (BYOM)	High	Medium
Agent Capabilities	✓	△ (beta)	✓	✓	✓

Criteria Continue.dev Tabby Tabnine Enterprise DevoxxGenie Cody

---

Real-World Use Cases

Case 1: Finance — Algorithmic Trading Team A development team building algorithmic trading systems in an air-gapped environment deployed Ollama with Qwen2.5-Coder-14B on an internal server. Each developer's VS Code was equipped with the Continue plugin. Code completion and refactoring suggestions reportedly boosted team-wide productivity by roughly 30%.

Case 2: Defense — Classified Code Projects In a documented case from Germany, an Ollama container was deployed in an air-gapped environment using Podman (a Docker alternative). Volume export/import was used to securely transfer model files across the air gap. Developers connected via VS Code extensions to get AI-assisted coding on secret-classified codebases.

Case 3: Enterprise — Tabnine + Dell Turnkey At NVIDIA GTC 2025, Tabnine and Dell showcased a GPU-accelerated air-gapped deployment solution designed for organizations in finance, defense, and healthcare that cannot send code to the cloud — a fully integrated hardware-software package.

---

Recommended Model Combinations

In air-gapped environments, model selection directly determines the quality of the experience. Here are recommended combinations by use case:

• Chat / Code Review: Qwen2.5-Coder 14B or DeepSeek-Coder-V2 (strong reasoning capabilities)
• Autocomplete: StarCoder2 3B or Qwen2.5-Coder 7B (optimized for speed)
• Embeddings: nomic-embed-text (lightweight, for vector search)

If VRAM is sufficient (24 GB+), the most effective strategy is to assign a larger model for chat and a smaller, faster model for autocomplete — splitting roles to balance quality and latency.

---

What Lies Ahead

Accelerating Model Compression: Quantization techniques are advancing rapidly. 4-bit quantized 14B–33B models now run at practical speeds on consumer GPUs. The hardware barrier for air-gapped AI continues to fall.

Standardization of Agent Capabilities: Beyond simple code completion, agents that can modify files, run tests, and automate builds are becoming standard even in open-source plugins. Both Continue and Tabby are actively strengthening their agent modes.

BYOM (Bring Your Own Model) Goes Mainstream: Even commercial tools like Tabnine now let customers register their own LLM endpoints. The flexibility to choose models without vendor lock-in is becoming an industry norm.

Stronger Evaluation and Audit Frameworks: Regulated industries need to track the quality and license compliance of AI-generated code. Audit logging, license conflict detection, and usage analytics are quickly becoming baseline requirements.

---

Conclusion

The ecosystem for running AI coding assistants in air-gapped environments is already mature. On the open-source side, Continue.dev + Ollama is the fastest path to getting started. For teams that want a single self-contained server and client package, Tabby is the right fit. When enterprise-grade governance and compliance are non-negotiable, Tabnine Enterprise deserves serious consideration.

The guiding principle is simple: "Keep the code inside; maximize AI productivity." Choose the combination that matches your organization's security requirements, hardware infrastructure, and team size — and run a pilot to see the results firsthand.