I need a coding assistant that can be self-hosted and does not share telemetry.

Yes. If “self-hosted + no telemetry” is a hard requirement, I’d shortlist these:

• Tabby — probably the best fit if you want a central coding-assistant server for yourself or a team. It is open-source, self-hosted/on-prem, and its current privacy policy explicitly says “No telemetry” and that Tabby does not phone home or send analytics.
• Continue — excellent if you primarily want a VS Code/JetBrains assistant or terminal agent. Its current 2.0 release states that anonymous telemetry was removed entirely, and Continue documents running completely offline with local models.
• Aider — a strong choice if you prefer a terminal-based coding agent. It supports local LLMs and works directly against your Git repository.

My recommendation

If your requirement is:

“My source code must never leave my infrastructure, and I don't want the assistant itself phoning home.” I'd choose Tabby + a local model for a server-based setup, or Continue + Ollama/another local inference server for an individual developer workstation.

The important distinction is that self-hosting the assistant isn't enough by itself. If you connect it to OpenAI, Anthropic, OpenRouter, etc., your code/context can still leave your machine. With a local model, you can keep the entire inference path inside your network. Continue specifically documents an air-gapped configuration using local models.

If you tell me your hardware (CPU/GPU/RAM), IDE (VS Code/JetBrains/etc.), and whether this is for one developer or a team, I can recommend a concrete stack and model that stays completely offline.

To build a completely private, self-hosted coding assistant with zero telemetry and zero cloud dependencies, the gold-standard architecture relies on pairing a local inference engine with an open-source IDE extension.

The most robust and popular stack for this setup combines Ollama, Continue , and a dedicated coding model like Qwen2.5-Coder.

The Recommended Open-Source Stack

- **What it does:** Runs large language models locally on your hardware (Mac, Linux, or Windows).
- **Privacy/Telemetry:** Completely offline-capable, open-source, and does not phone home or track usage.
- **Quick setup:** Download via Ollama Downloads and pull a specialized coding model in your terminal:  

ollama run qwen2.5-coder (or a specific size like qwen2.5-coder:7b)

- **What it does:** An open-source autopilot/chat extension for VS Code and JetBrains that acts like a local GitHub Copilot.
- **Privacy/Telemetry:** Fully open-source with telemetry explicitly disabled or configurable out-of-the-box. It connects directly to your local Ollama instance via `localhost`.
- **Configuration:** Point `config.json` inside Continue to your local Ollama endpoint, letting you chat, highlight code to refactor, or use inline tab-completions locally.[](https://google.com/goto?url=CAESTgHrOzAVQ-jrYlL8KwkGs3Cha0sbgB84kDULVrVhNxWCooipOBepOnXR5muEOVTZy4gWCZIK5xfxIbtNohPmwgeTLPFdhUX40hwKnGXugg) [[1]](https://google.com/goto?url=CAESTgHrOzAVQ-jrYlL8KwkGs3Cha0sbgB84kDULVrVhNxWCooipOBepOnXR5muEOVTZy4gWCZIK5xfxIbtNohPmwgeTLPFdhUX40hwKnGXugg)

- **What it does:** Available in various sizes (from 1.5B up to 32B parameters), Qwen2.5-Coder matches or beats many proprietary mid-tier models specifically for code generation, multi-file reasoning, and debugging.
- **Hardware requirement:** A 7B or 14B parameter version runs smoothly on standard developer machines (with 16GB–32GB RAM/VRAM), while larger models benefit from dedicated GPU acceleration.

Would you like help with:

• Writing the exact config.json to wire Continue and Ollama together?
• Sizing the right model based on your specific computer's hardware (GPU/RAM)?

To set up a completely private, self-hosted coding assistant with zero telemetry and no cloud dependencies , you need to split the stack into two parts:

1. The Backend Engine: Runs the local LLM on your hardware.
2. The Front-End Interface: Integrates into your editor or terminal.

The best open-source tools to build this zero-telemetry stack are organized below by workflow.

Phase 1: The Local LLM Backend (Choose 1)

• Ollama: The easiest way to run models locally. It runs as a lightweight local daemon, has zero telemetry, and exposes an OpenAI-compatible API. Download it from Ollama . Run models like deepseek-coder or qwen2.5-coder.
• llama.cpp / LlamaServer: Great for lower-level, highly optimized hardware control, especially if you are managing explicit GPU/CPU offloading.
• LM Studio: A desktop application with a local server mode that lets you search, download, and serve GGUF models locally with a clean GUI.

Phase 2: The Coding Assistant Interface (Choose based on workflow)

1. Continue (Best for VS Code / JetBrains day-to-day coding)

• What it is: An open-source, Copilot-style IDE extension for chat, inline editing, and autocompletions.
• Privacy & Telemetry: Fully open-source (Apache 2.0) and configurable to point directly to your local Ollama or llama.cpp instance. It does not send data anywhere outside your localhost unless you explicitly configure an external API key.
• Get started: Install via the Continue Documentation and point its config.json to your local Ollama port.

2. Tabby (Best for an all-in-one, self-hosted team server)

• What it is: A self-hosted, all-in-one open-source alternative to GitHub Copilot that runs via Docker. It handles code completion, has its own management dashboard, and serves models on your own hardware.
• Privacy & Telemetry: Entirely self-contained, runs on-premises, requires no internet connection after setup, and features zero external telemetry.
• Get started: Deploy via docker using the Tabby GitHub Repository and plug in their VS Code or JetBrains extensions.

3. Aider (Best for terminal-driven multi-file refactoring)

• What it is: A command-line AI pair programmer that edits code in your local git repository, creates automatic commits, and handles heavy multi-file logic.
• Privacy & Telemetry: Operates locally in your terminal and connects natively to any OpenAI-compatible local endpoint (like Ollama running deepseek-coder ). No cloud connection or telemetry.
• Get started: Install instructions and configuration guides are available at Aider Chat.

To help narrow down the exact setup, let me know:

• What IDE or editor do you use (VS Code, JetBrains, Neovim, or terminal)?
• What are your hardware specs (specifically, do you have a dedicated GPU and how much VRAM)?

Yes. If “self-hosted + no telemetry” is a hard requirement, I’d shortlist these:

• Tabby — best fit for strict privacy. It is open-source, self-hosted, and designed to run on your own infrastructure. Tabby explicitly states that it has no telemetry, does not phone home, and doesn't collect personal/device identifiers.
• Continue — best for VS Code/JetBrains. Its current 2.0 release removed anonymous telemetry, and its documentation describes an offline/air-gapped setup using local models. Continue Docs Continue Docs One caveat: Continue's broader ecosystem has had development-data collection features, so for a strict environment I'd explicitly disable telemetry and use a local model/backend.
• Cline — best if you want an autonomous coding agent. It can operate in VS Code, JetBrains, or the terminal and can connect to a locally hosted/OpenAI-compatible model endpoint.

What I'd choose

If your requirement is literally “my source code must never leave my network, and the assistant must not phone home”, I'd go with:

Tabby + a local model + network egress blocked.

That gives you defense in depth: even if a future component unexpectedly tries to make an outbound request, your firewall can prevent it. Tabby can be deployed with Docker and supports consumer-grade GPUs.

If you tell me your OS, GPU/RAM, and whether you want autocomplete, ChatGPT-style coding, or an autonomous agent, I can recommend a specific completely-local stack.

To build a completely private, self-hosted coding assistant with zero telemetry and zero external network calls, you need a decoupled two-part stack:

1. The Local Model Backend / Runtime : Runs the actual AI weights on your own hardware.
2. The IDE or Terminal Assistant : Connects locally to your runtime and edits your files.

Phase 1: The Local Inference Backend (Choose One)

• Ollama : The gold standard for running local models effortlessly. It runs as a lightweight local daemon, exposes an OpenAI-compatible API on localhost:11434 , and contains no telemetry. Get it from Ollama.
• LM Studio : Provides a graphical user interface to download, manage, and run quantized open-weights models. It features a local server toggle and an advanced "Bionic" agent mode for local file inspection. Get it from LM Studio.

Recommended local coding models to pull:

• Qwen2.5-Coder (7B or 32B) or DeepSeek-Coder-V2 (if you have sufficient VRAM/RAM) for powerful, multi-language code generation.

Phase 2: The Coding Assistant Interface (Choose One)

• Cline (formerly Claude Dev) : A highly capable autonomous agent extension for VS Code and JetBrains. It supports "Plan/Act" loops, edits files directly, runs terminal commands (with your permission), and connects natively to Ollama or LM Studio on localhost.
• Aider : A powerful command-line pair-programming tool that integrates tightly with Git. Every AI-suggested change is cleanly committed into your local Git history. You can point it straight at your local backend using an OpenAI-compatible environment variable.
• Tabby : A turnkey, self-hosted code-completion server written in Rust/TypeScript designed explicitly for air-gapped or private environments. It hooks straight into VS Code and JetBrains via dedicated plugins.

Recommended Quick-Start Stack

For the fastest and most private setup in VS Code:

1. Download and install Ollama.
2. Pull a local coding model via your terminal: ollama run qwen2.5-coder.
3. Install the Cline extension in VS Code.
4. Open Cline's settings, set the API Provider to Ollama , and point the Base URL to http://localhost:11434.

Would you like help sizing this based on your hardware specifications (GPU VRAM and system RAM) , or do you prefer an editor-based extension vs. a terminal tool like Aider?

Yes. If self-hosting + no telemetry are hard requirements, I’d shortlist these:

🥇 My pick: Tabby

TabbyML's Tabby is probably the closest match to your requirements. It's open source, self-hosted, and designed as an on-premises alternative to Copilot. Its current privacy policy explicitly says “No telemetry” and that it doesn't collect personal data or phone home.

The important distinction is that your model provider can still receive code if you configure Tabby to use a cloud LLM. For maximum privacy, run the model locally as well. Tabby's server can run with consumer GPUs.

🥈 Best flexible option: Continue + Ollama

Continue gives you a VS Code/JetBrains experience with chat, autocomplete, and codebase context. Pairing it with Ollama and a local model means your code and prompts can remain on your machine.

This is what I'd choose if you want something more like modern Copilot/Cursor while retaining control over the model.

🥉 Best coding agent: Aider + local model

Aider is excellent if you're comfortable with a terminal. It edits multiple files, understands Git repositories, and can use local Ollama models.

For example, the architecture would be:

VS Code → Aider → Ollama → local LLM

No code needs to leave your machine.

For autonomous development: OpenHands

OpenHands is more ambitious: it can actually plan, modify code, run commands/tests, and work across a repository. Its platform supports self-hosted/private deployments where your code stays in your environment.

The tradeoff is complexity: it's much more of an AI software-engineering agent than a lightweight Copilot replacement.

What I'd deploy

If your requirement is literally “the source code must never leave my network, and I don't want telemetry”, I'd use:

VS Code / JetBrains
        │
        ▼
   Continue or Tabby
        │
        ▼
      Ollama
        │
        ▼
 Local coding model

Then firewall the machine/server so the assistant has no outbound Internet access except whatever you deliberately allow for updates.

One important caveat: “self-hosted” doesn't automatically mean “zero telemetry.” For example, some projects have local event/usage logging even though the data doesn't leave your infrastructure. That's why I'd verify the actual network behavior and, for a high-security deployment, enforce it at the firewall/container level rather than relying solely on a vendor's privacy setting.

If you tell me your OS + GPU/RAM (e.g. Ubuntu + RTX 4090, Mac M-series, etc.), I can recommend the best local model + assistant combination for your hardware.

Yes. If self-hosted + no telemetry is a hard requirement, I’d narrow it to these:

My recommendation: Continue + Ollama

If you want something closest to Cursor/Copilot, I'd use Continue as the coding interface and Ollama as the local model server.

• Continue gives you VS Code/JetBrains integration and agentic coding.
• Ollama keeps inference on your own machine.
• No API key or cloud model is necessary.
• Continue 2.0 specifically states that anonymous telemetry was removed.

If you want a more server-oriented setup for a team, choose Tabby instead. Tabby is explicitly designed as a self-hosted coding-assistant server, supports IDE extensions, and can run entirely on infrastructure you control.

If you prefer CLI/agent workflows, choose Aider. It works directly against your Git repository and supports local models as well as cloud providers.

Important distinction: "self-hosted" doesn't automatically mean "no data leaves the machine." For a strict zero-telemetry setup, run the assistant and the LLM locally, and ideally firewall the container/server from outbound Internet access. That gives you a much stronger guarantee than simply trusting a vendor's telemetry policy.

If you tell me your OS + GPU/RAM (e.g. Ubuntu + RTX 4090 24 GB, MacBook M-series, etc.), I can recommend a specific local model and give you a minimal Docker setup.

To set up a completely self-hosted, zero-telemetry AI coding assistant that keeps your code and context entirely on your local infrastructure, you will want to combine a local model runtime with an open-source extension or agent client.

The most effective, privacy-first open-source stacks available are organized below by how they integrate into your workflow:

• Continue (IDE Extension) : Integrates directly into VS Code or JetBrains. It handles inline autocomplete and sidebar chat entirely locally by pointing to a backend like Ollama or llama.cpp . Because it is open source (Apache 2.0) with no cloud dependency or telemetry, your code never leaves your machine.
• Tabby (Self-Hosted Server) : An open-source, self-contained alternative to GitHub Copilot that deploys easily via Docker or a standalone binary. It features repository-level indexing and context for your local IDE plugins without any external cloud dependencies.
• Aider (Terminal Pair Programmer) : A powerful git-native command-line tool that lets you run local coding models to edit files in your repository directly. Every change the AI makes is automatically structured into a clean local git commit.
• Cline / RooCode (Agentic IDE Extension) : Advanced VS Code extensions that support deep multi-file editing and tool usage. You can configure them to talk strictly to your local model endpoint with zero external tracking.
• Ollama or LM Studio (Model Backend) : The local engine that actually runs open-weight coding models like Qwen2.5-Coder or Devstral on your hardware (CPU, Apple Metal, or NVIDIA/AMD GPU).

To help narrow down the best setup for your environment, let me know:

• What IDE or editor do you primarily use (VS Code, JetBrains, or the terminal)?
• What are the hardware specs (RAM and GPU VRAM) of the machine you will be hosting this on?

The ideal open-source, telemetry-free stack for an individual developer is Ollama paired with the Continue extension inside VS Code or JetBrains, running a local model like Qwen2.5-Coder . For a self-hosted team or enterprise setup that requires a unified server, Tabby provides a self-contained, Docker-deployable alternative.

Recommended Telemetry-Free Stacks

How to Set Up an Individual Local Stack

1. Install the Runtime: Download and run Ollama on your local machine.
2. Pull a Coding Model: Open your terminal and download a dedicated programming model via command line:bash``` ollama run qwen2.5-coder:7b-instruct

Use code with caution.
3. **Install the IDE Plugin:** Install the **Continue** extension from your editor's marketplace.
4. **Disable Telemetry & Connect:** Open the `config.json` inside your `.continue` folder, ensure anonymous telemetry is disabled (`"allowAnonymousTelemetry": false` ), and point the model provider to your local Ollama endpoint (`http://localhost:11434`).[](https://danubedata.ro/blog/self-host-ai-coding-assistant-2026) [[1]](https://danubedata.ro/blog/self-host-ai-coding-assistant-2026)[[2]](https://www.youtube.com/watch?v=DIbVdatFl6I)[[3]](https://www.sitepoint.com/openclaude-with-deepseek-v4-running-a-fully-private-ai-coding-engine/)[[4]](https://medium.com/@walterdeane/running-a-local-llm-for-code-assistance-dea64748041a)

If you tell me your **hardware specs (RAM and GPU VRAM available)** , I can recommend whether you can run a **7B, 14B, or larger parameter model** for the best balance of speed and accuracy.

If zero telemetry / no data leaving your environment is the requirement, I’d narrow it to these:

My pick: Tabby

TabbyML's Tabby is probably the cleanest match. It's explicitly open-source and self-hosted, and its server can run your coding model on infrastructure you control. It doesn't require a cloud service or external database.

If you want an agent rather than autocomplete: Continue 2.0

The interesting option is Continue 2.0. The project says its final 2.0 release removed anonymous telemetry and authentication, and it can be configured for completely offline operation with local models.

One caveat: the Continue project is now no longer actively maintained, so I wouldn't choose it for a new long-lived deployment unless its feature set is exactly what you need.

Aider

Aider is excellent if you prefer a terminal workflow. Its analytics are not inherently zero-telemetry, but you can permanently disable them with:

aider --analytics-disable

Aider states that its analytics don't include your code, chats, API keys, or personal information.

Important distinction

Self-hosted doesn't automatically mean zero telemetry. For maximum privacy, I'd use:

Tabby/agent → local LLM (e.g. Ollama) → no external network access

Then enforce the last part at the firewall/container level. That gives you a technical guarantee rather than relying solely on a vendor's telemetry setting.

If you tell me your hardware (CPU/GPU/RAM) and whether you use VS Code, JetBrains, or terminal, I can recommend the best specific stack and model.