As of October 2026, a company replacing GitHub Copilot with something under its own control can pick from three kinds of still-maintained tool: open agents (Cline under Apache 2.0, MIT-licensed Kilo Code) that talk to a model server in your office; Tabby, an open server with an admin console; and commercial products deployed inside your network, namely GitLab Duo Self-Hosted, Tabnine Enterprise and Sourcegraph's Cody Enterprise. GitHub's Copilot CLI is a special case: pointed at a local model it can run offline, and then no code goes to a cloud.

The graphics card follows from the model; the tool itself barely changes the load. Models and their licences are covered in the article on a private coding assistant.

In brief

  • Both Cline (Apache 2.0) and Kilo Code (MIT) remain in active development; Roo Code ended on 15 May 2026 and its repository is archived, while Continue has been read-only since its final release, 2.0.0.
  • Tabby gives a team an admin console and usage reporting, with distinct model slots for chat, embeddings and completion; v0.32.0 from 25 January 2026 is its latest stable version, and in production the code under ee/ requires a Tabby Enterprise licence.
  • Copilot CLI accepts Ollama, vLLM and other OpenAI-compatible servers; once COPILOT_OFFLINE=true is set it does not try to sign in to GitHub, and GitHub advises a context of 128k tokens or more.
  • By our calculation, a 72 GB RTX PRO 5000 runs Qwen3-Coder-30B-A3B in FP8 with five 64K-token agent sessions (ten when the cache is FP8), while a pair of 96 GB RTX PRO 6000 cards keeps 57 sessions of Qwen3-Coder-Next in memory.
  • A network with no internet access has four documented routes: Tabby, Tabnine Enterprise installed in isolation, GitLab Duo Self-Hosted under an offline licence, and Copilot CLI running offline.

Which Copilot alternatives run on your own server in 2026

Two tools that older reviews still mention are no longer suitable for a new rollout.

Tool Type Status, Oct 2026 Licence Connecting your model
Cline coding agent: VS Code, JetBrains, CLI active, October 2026 releases Apache 2.0; JetBrains plugin is closed source Ollama, LM Studio or any OpenAI-compatible server
Kilo Code coding agent: VS Code, JetBrains, CLI under active development MIT Ollama plus other providers
Zoo Code community fork of Roo Code new fork Apache 2.0 see its provider list
Roo Code coding agent archived 15.05.2026 Apache 2.0 avoid for a new rollout
Continue IDE extensions plus CLI read-only since 2.0.0 Apache 2.0 avoid for a new rollout
Tabby own server with IDE plugins v0.32.0 of 25.01.2026 is the latest stable Apache 2.0, ee/ licensed separately vLLM, Ollama, llama.cpp
Tabnine Enterprise commercial product on your Kubernetes isolated installation available commercial runs inside your cluster
Cody Enterprise commercial, on your own Sourcegraph documentation version 8.1 commercial an OpenAI-compatible server
GitLab Duo Self-Hosted add-on for GitLab Self-Managed requires the Duo Enterprise add-on commercial vLLM from 0.18.1
GitHub Copilot CLI agent in the terminal offline mode documented GitHub terms Ollama, vLLM or an OpenAI-compatible server

Source: project repositories, release pages and READMEs, plus Tabnine, Sourcegraph and GitHub documentation, read 30.10.2026; JetBrains plugin status per the Cline README; GitLab Duo per GitLab documentation 19.6, read 25.10.2026; Tabby release year from the order of its releases page.

Roo Code and Continue: what happened and how to avoid extension lock-in

Roo Code's owner archived the repository on 15 May 2026. According to its README, the extension stopped working that day, and the suggested replacements are Cline and Zoo Code, a fork begun by Roo Code's community. Continue, after its final 2.0.0 release, is no longer actively maintained, and its repository is read-only for all users.

Only the extension stopped. Model server, models and gateway carried on; what stayed tied to it were the custom modes and prompts configured inside it. Since the server used a standard API, moving to another agent meant three new settings per laptop: base URL, key and model name.

Three habits keep such a move cheap:

  • Keep prompt files and coding rules inside the repository itself, so whichever tool comes next can read them.
  • Put vLLM or SGLang behind a gateway you own, which keeps keys, logs and model choice independent of any extension.
  • With Tabby, Tabnine or Sourcegraph, check before rollout how users, statistics and repository indexes can be exported, because those live in the product's own database.

Completion, chat and agents: one model or two

Completion writes code as the developer types, and each suggestion must arrive before the next keystroke. That calls for a small model trained to fill a gap (fill-in-the-middle) and a tool that sends it the code around the cursor. Tabby reserves a slot for this: with vLLM it expects the vllm/completion endpoint plus a model-specific prompt template. In Sourcegraph, an administrator gives a model the codeCompletion role.

Chat means questions about code: a few thousand tokens per request and an answer at reading speed. Every tool in the table can do this.

Agents are what most teams now mean when they say "Copilot". Agents such as Copilot CLI, Zoo Code, Kilo Code and Cline open files, execute commands once the developer approves, and go back to the model after every step, with prompts that reach tens of thousands of tokens. GitHub insists that the model behind Copilot CLI supports tool calls and streamed output. For Ollama, Kilo Code asks for "at least 32k" of context and warns that qwen3-coder:30b sometimes gets tool calls wrong; for local models, Cline suggests its "Use Compact Prompt" option.

A team wanting completion as well as agents therefore runs two models on the server, each in a separate engine instance: a small completion model (Qwen2.5-Coder-1.5B, for instance: 3.09 GB, Apache 2.0) plus an agent model like Qwen3-Coder-Next or Qwen3-Coder-30B-A3B. Agents and chat alone need just one.

Admin console, sign-in and usage reports for the team

With Cline, Kilo Code and Zoo Code, configuration sits in every developer's own IDE, and none of their READMEs describes an admin console for a self-run deployment. Kilo Code's documentation notes that its completion requests travel through the Kilo Gateway; where code may not leave the network, that function is switched off.

Control therefore moves to the server. An LLM gateway placed before vLLM hands every developer a key, records which person used which model and how many tokens went through, and decides which models are offered at all. Logs tied to a person are personal data under Law No. 2297-VI: their purpose and handling are fixed in an internal company regulation, which employees sign to confirm they have read it in advance (Art. 29 of the Labour Code). Check each extension's telemetry separately.

Tabby provides these functions itself. Its project news lists team management with secured access (v0.7), an admin interface (v0.9), usage reports (v0.10), GitLab SSO plus repository context from your own GitLab and GitHub instances (v0.12), LDAP announced for v0.24, merge request indexing as context (v0.30) and OAuth sign-in (v0.32.0). The README describes Tabby as self-contained, with no database server or cloud service required. Everything outside ee/ is Apache 2.0; inside ee/, development and testing are free of any subscription, whereas production requires a Tabby Enterprise licence covering your seats. The latest news item, from December 2025, introduces Pochi, another agent by the Tabby team; since v0.32.0 only nightly and alpha builds have appeared.

Tabnine Enterprise installs as a Kubernetes cluster on the customer's servers in a private network, which may be fully isolated. Tabnine staff have no access to your servers but help with setup and upgrades. Cody Enterprise on your own Sourcegraph takes your endpoint as an openaicompatible provider, and one model can serve both completion and chat. GitLab Duo Self-Hosted requires GitLab Premium or Ultimate plus the Duo Enterprise add-on.

GitHub Copilot with a local model

GitHub documents three routes, and only one is described as local.

Copilot CLI reads the COPILOT_PROVIDER_BASE_URL and COPILOT_MODEL variables and works with Ollama, vLLM and any server compatible with the OpenAI Chat Completions API. With your own provider keys (BYOK) no GitHub sign-in is required, although you then lose /delegate, GitHub code search and the GitHub MCP server. Setting COPILOT_OFFLINE=true makes the CLI skip authentication, send requests only to your provider and disable telemetry; GitHub points out that this amounts to full isolation only if the BYOK provider is local or inside the same isolated environment. The README requires an active Copilot subscription, and nothing on the BYOK pages clarifies whether that still applies with only your model, so ask GitHub.

The Copilot app has accepted your own keys since 23 June 2026, for LM Studio, Ollama or an OpenAI-compatible endpoint. On Business and Enterprise plans, an administrator has to allow Copilot CLI in the policies.

Copilot in the IDE lets enterprise administrators register their own models for Chat, the CLI and the IDEs, as a public preview. Whether completion uses them, and whether requests pass through GitHub, the page does not say, so regard this route as cloud-based. Claude Code, Codex and OpenCode are covered in the article on Claude Code with a local model.

Which setup suits a studio, a department or a regulated company

A studio of five developers manages with one workstation: Cline or Kilo Code on each laptop calls its model server, and a key-checking reverse proxy stops that endpoint from being exposed publicly. Ollama 0.35.0 or newer is enough for a pilot; when several people work at the same time, vLLM serves them more efficiently.

For a department of 50, plan a server running vLLM with prefix caching switched on, behind a gateway that gives every person their own key. Tabby combines an admin console and completion in one open product. If the company already runs GitLab Premium or Ultimate, Duo Self-Hosted keeps everything within GitLab, though the add-on licence is extra. Servers for this range are sized in the article on a server for coding agents.

A regulated company with an isolated network has the four routes listed under "In brief"; models, drivers and containers then reach the server without internet access. The rules for using such tools on company code are covered in the article on an AI coding assistant policy.

Which workstation or GPU server can run a Copilot alternative

We count agent sessions with our own rule: take 90% of the memory the driver reports, subtract 3 GiB per card and the weights, then divide what is left by the cache of one session. The RTX PRO 4500 (32 GB) is left with 25.7 GiB, the 72 GB RTX PRO 5000 with 61.5 GiB, and every 96 GB RTX PRO 6000 with 83.0 GiB. As the upper limit we assume one generating session per developer at peak hour.

Level Hardware Agent model Who it suits Sessions of 64K
Starter one RTX PRO 4500, 32 GB gpt-oss-20b in MXFP4 a small team, chat and light agent tasks 8
Starter one RTX PRO 5000, 72 GB Qwen3-Coder-30B-A3B in FP8 from 5 to 10 developers using agents 5 (10)
Mid-size two RTX PRO 6000, Workstation Edition or Max-Q Qwen3-Coder-Next in FP8, TP=2 from 20 to 40 developers 57 (110) fit in memory; 40 (77) at 50 tokens/s
Large four RTX PRO 6000 Server Edition Qwen3-Coder-Next as two pairs from 40 to 70 developers 70 (136) at 50 tokens/s

Source: our calculation rule, BF16 cache (FP8 cache in brackets; gpt-oss-20b with BF16 only); weights from Hugging Face, read 30.10.2026: gpt-oss-20b 13.76 GB, Qwen3-Coder-30B-A3B FP8 31.2 GB, Qwen3-Coder-Next FP8 80.4 GB; cache per 64K from config.json: 1.5 GiB (gpt-oss-20b, Coder-Next), 6 GiB (Coder-30B-A3B); speed is an upper limit by our estimate for 1,792 GB/s per Workstation Edition or Max-Q and 1,597 GB/s per Server Edition (NVIDIA); TP=2 means one copy of the model split over two cards.

On the RTX PRO 4500, gpt-oss-20b (21B parameters, 3.6B active, Apache 2.0) copes with chat and short agent tasks, but test its tool calls on your own repositories first. Putting a completion model on the same card costs agent sessions: by our calculation, the 3.09 GB taken by Qwen2.5-Coder-1.5B cut the 72 GB RTX PRO 5000 from 5 (10) sessions to 4 (9), before the second engine's cache is counted. Newer models need far less cache: by the same rule, that card fits ten 128K sessions of Qwen3.6-35B-A3B (Apache 2.0).

The mid-size level can be built as a workstation or in a rack. For the Workstation Edition (600 W, flow-through cooling), two cards are the practical limit. Three or four Max-Q cards belong only in a chassis designed for them, with strong directed airflow: in July 2025 Puget Systems found that Max-Q cards mounted side by side are short of air, and Exxact, on a page last revised in March 2026, says four neighbouring cards throttled without special cooling. In a rack running round the clock, we advise the Server Edition.

Our power estimate is around 1.8 kW for a pair of cards on two AMD EPYC 9135 processors and around 3.4 kW for four cards on two EPYC 9355. A 230 V 16 A circuit at a sustained 80% load supplies about 2.9 kW, so four cards need more than one circuit, and because of power cuts in Ukraine such a server is planned together with a UPS and a generator. ETE calculates the configuration for your number of developers from the real load, and Vixen.UNO engineers set up the model server, gateway and agents when needed.

The same model server can also document private repositories through DeepWiki on your own server.

FAQ

Which self-hosted GitHub Copilot alternative should a company choose?

In the IDE and terminal, agents such as Cline (Apache 2.0) and Kilo Code (MIT) fit, working with Ollama or an OpenAI-compatible server. For a central server with an admin console, reports and completion, Tabby is the open choice, while GitLab Duo Self-Hosted, Cody Enterprise and Tabnine Enterprise are the commercial ones.

Is there a Copilot equivalent that works with no internet at all?

Yes: Tabby without cloud services, Tabnine Enterprise installed in isolation, GitLab Duo Self-Hosted under an offline licence, and Copilot CLI running offline. In every case the model runs on your server inside the isolated network.

Can GitHub Copilot be connected to a local model?

Copilot CLI can: it works with Ollama, vLLM and other OpenAI-compatible servers, and in offline mode it does not sign in to GitHub. Your own keys have worked in the Copilot app since June 2026. For models added in the IDE, GitHub does not state whether requests pass through its servers.

What replaces Roo Code and Continue in 2026?

The README of the archived Roo Code recommends Zoo Code (a community fork) and Cline. Continue has been read-only since release 2.0.0. If the model server spoke a standard API, switching means a new address, key and model name in the IDE.

What hardware does an assistant for 20 developers need?

Two 96 GB RTX PRO 6000 cards, Workstation Edition or Max-Q, running Qwen3-Coder-Next in FP8 fit 57 sessions of 64K tokens in memory, and at 50 tokens/s each, by our estimate, up to 40; two Server Edition cards give about 35. A team of 5 to 10 people can start with a 72 GB RTX PRO 5000.

May we keep request logs for each developer?

Yes, but they are personal data under Law No. 2297-VI. The purpose and retention period are fixed in an internal regulation that employees sign, and staff decisions are not taken on automated analysis of the logs alone (Art. 8(2)(13) of Law No. 2297-VI). Your lawyer will confirm the details.

What ETE supplies for this

Planning your own Copilot for developers?

Tell us how many developers you have, which Git platform you use and whether the network must be isolated. ETE will calculate the configuration, and Vixen.UNO engineers can install vLLM, the gateway and Cline or Kilo Code if needed.

Discuss your project

Author: ETE Engineer