The codebase can never leave the building. That is the requirement, and it changes which AI coding tools you are allowed to install. Most coding assistants in 2026, from GitHub Copilot to Cursor, work by shipping your prompt, surrounding files, and sometimes half your repository to a datacenter, getting tokens back, and promising the fine print holds. For regulated industries, government work, classified environments, or that one client contract with the terrifying NDA, the promise is not the deliverable. The absence of a network path is.
So here is the honest version of the air-gapped stack in September 2026: Ollama as the runtime, Cline as the IDE bridge, and Qwen3.8-27B as the model. If you have read an older guide on this topic, two of the three names in your bookmarks are probably wrong now. The stack you were told to build, Ollama plus Continue.dev plus DeepSeek-Coder, has aged badly, and the reasons why are themselves instructive.
What changed since the classic guides
Two things. First, Continue.dev is gone. Cursor acquired the team in June 2026, the final release shipped June 19, the hosted Hub was switched off a month later, and the GitHub repository is now read-only. The extension still installs because the Apache 2.0 code is still on the marketplace, but it is a frozen artifact: no security patches, no fixes when VS Code or model APIs change. You do not build a compliance workflow on a dead project.
Second, DeepSeek-Coder, the model every 2024 guide recommended, has been overtaken by roughly two model generations. The single-GPU crown in September 2026 belongs to Qwen3.8-27B, Alibaba's dense 27B released in August 2026 under Apache 2.0. On the vendor's own numbers it scores 61.7 on SWE-bench Pro and 73.0 on Terminal-Bench 2.1, and it fits on one 24GB consumer card. To put the jump in perspective: the previous best open model in that size class scored 38 on the comparable benchmark family. DeepSeek's current open models are excellent, but the ones topping leaderboards are 284B-parameter-plus affairs that need a server rack, not a desk.
There is a third, sneakier change that older guides miss entirely: Ollama itself is no longer automatically local. Since late 2025 it has offered cloud model tags that run on ollama.com's infrastructure. Convenient, but it quietly breaks the one guarantee this whole article exists for. Ollama ships a kill switch for exactly this: set OLLAMA_NO_CLOUD=1 (or disable_ollama_cloud in settings) and cloud models are off, full stop. On an air-gapped box you never pull a cloud tag anyway, but if your machine has any network access, the flag is how you make "local" a policy instead of a habit.
Layer 1: Ollama, the runtime
Ollama is the model server. It downloads open-weight models, keeps them in a local library, and exposes an API on localhost:11434, including an OpenAI-compatible endpoint. Almost every coding tool in this ecosystem knows how to talk to it, which is why it anchors the stack. On a truly air-gapped machine you install it from media, copy the model files in, and it never needs to phone home.
One behavior bites everyone eventually: Ollama allocates a small runtime context window by default, regardless of what the model supports. Qwen3.8-27B natively handles 262,144 tokens, but a coding agent that has read fifteen files will silently lose the first ten unless you raise the context length explicitly. Budget for it, because context, not the model weights, is what fills your memory first.
Layer 2: Cline, the IDE bridge
Cline is what Continue.dev was: an open-source, Apache 2.0 coding agent that lives inside VS Code (or JetBrains), and where the model is yours to choose. It did not just survive Continue's death, it is the designated successor, actively maintained, with native Ollama support in its official docs.
The wiring is deliberately boring, and Cline's local-models documentation walks it end to end:
- Install Cline from the VS Code marketplace.
- Open Cline settings, set the API provider to Ollama.
- Point it at
http://localhost:11434. - Select your model.
- Set the context window to at least 32K tokens, per Ollama's integration notes, and enable Use Compact Prompt, a Cline feature that trims its prompt size by about 90% for local models.
That last item matters more than it sounds. Local models pay per token in a way cloud users never notice: every token in the context has to fit in VRAM alongside the weights and be processed at your GPU's speed, not a datacenter's. A leaner prompt is not cosmetic, it is the difference between a session that runs and one that falls over.
If you do not want a full agent, there is a lighter option: Ollama's own VS Code extension surfaces local models directly in VS Code Chat, no agentic file-editing loop, good for "explain this function" but insufficient for "refactor this module."
Layer 3: Qwen3.8-27B, the model
On a single 24GB GPU (RTX 3090/4090 class) or a 32GB unified-memory Mac, ollama run qwen3.8:27b pulls an 18GB quantized build. Apache 2.0 means the license survives audits, and being open weights means the model file is just a file: it moves on install media into the air-gapped network like any other artifact.
The hardware floor, in practical tiers:
| Hardware | What runs well |
|---|---|
| 8GB VRAM / 16GB Mac | qwen2.5-coder 7b class: single-file help, slow and literal |
| 16GB VRAM / 24-32GB Mac | qwen2.5-coder 14b, or heavy compression of the 27B |
| 24GB VRAM / 32GB+ unified memory | qwen3.8:27b, the target setup |
Below about 12GB of fast memory, quantization artifacts start to matter for code, where mis-tokenizing one identifier in twenty quietly corrupts edits. An agent that edits code needs more headroom than one that chats. Full model details and download tags live on the official qwen3.8 library page.
The compliance framing
Here is what the local stack actually buys you in a regulated environment, and it is worth stating precisely because cloud vendors now offer impressive-looking privacy tiers.
Copilot Business and Enterprise carry contractual commitments that your code and prompts are not used to train their models, backed by GitHub's data protection agreement. Those terms govern what happens to your code after it is uploaded. They do not, and cannot, prevent the upload: the product's mechanism is sending your prompt and surrounding context to GitHub's infrastructure. A nearby open file can ride along in the completion request regardless of what the contract says about it afterward. For a lot of companies that trade is fine, audited, and defensible.
The local stack inverts the argument. There is no upload to constrain, no vendor in the data-processing chain, no cross-border transfer to document, no retention window to negotiate, no telemetry to enumerate in a privacy impact assessment. The answer to "where does our code go during inference" is "into the GPU on that machine," and you can prove it with a firewall log. That is a materially different compliance posture from "we trust the vendor's certifications," and for classified networks, some healthcare and defense contracts, and jurisdictions with data-residency rules, it is not a preference, it is the requirement.
The auditability extends to the components. Ollama and Cline are open source, so a security team can read exactly what the tools do, and Qwen3.8's weights are open, so the model cannot be silently changed under you. No subscription on an air-gapped network means no license server to call home, either.
If you are weighing this generally for documents and chat rather than code specifically, the same local-first logic and tool choices apply, and our guide to private and local AI tools for sensitive documents covers that case. For the runtime itself, our LM Studio vs Ollama vs Jan comparison is still the quickest way to pick.
What you give up versus cloud agents
Being honest about the trade is what makes the compliance case credible.
Qwen3.8-27B's 61.7 on SWE-bench Pro is remarkable for a model on one card, but frontier cloud agents sit in the 70s, and you feel the difference on cross-cutting changes across a large codebase, the kind of task where the model needs to hold architecture in its head. Context is the bigger constraint: on 24GB you realistically run 16-32K tokens before the KV cache crowds the weights, while cloud agents hold 200K and up. An agent that has read a dozen files has already spent your budget.
Speed is a middle-class problem: 60-95 tokens per second on a used RTX 3090 is usable for interactive work, and thinking mode (on by default in Qwen3.8, tunable with reasoning_effort) means the model pauses before answering. You also inherit the maintenance: you are now the inference team, choosing quants, setting context, updating the runtime from media.
What you get back: no rate limits, no per-token costs, no data boundary, no retention policy to read, and a stack that keeps working when the network is down because there is no network. For an air-gap requirement none of that is a bonus, it is the deliverable.
The verdict
Build this stack if the constraint is real: regulated data, classified environments, client contracts that prohibit third-party processing, or a security posture where "we verified the vendor's controls" does not clear the bar. The Ollama plus Cline plus Qwen3.8-27B combination is the first time an air-gapped setup has been genuinely competitive rather than a consolation prize, and with a used 24GB card it costs less than a year of one cloud subscription.
Skip it if your code is ordinary and your reason is vague privacy anxiety. The honest math for most teams: cloud agents are better at hard things, and the enterprise no-training tiers are contractually solid. Paying that cost in capability to solve a problem you do not have is not diligence, it is theater.
The practical middle path most regulated teams land on: route by task. Local lane for anything with sensitive data in it, cloud lane for open-source work and gnarly debugging, with the router deciding, not developer willpower. The harness does not change. Only the base URL does, and on the sensitive lane, the URL is localhost.
Frequently asked questions
Can I still use Continue.dev? The final release installs and runs with local models, but the repository is read-only and unmaintained. Cline is the actively maintained replacement with the same local-first design, and switching takes minutes.
Does Qwen3.8-27B work on a 16GB machine? Comfortably on 16GB VRAM with heavier compression, but quality tradeoffs near the smallest quants are a real risk for code editing. If you cannot reach 24GB of fast memory, a 14B coder model is often the better experience than a badly squeezed 27B.
Pricing and plan details are as published by the vendor around September 2026 and can change, confirm on the official site.
