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

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

1. TabbyML — best fit

• Fully self-hosted and open source.
• Can run models on your own hardware, including consumer GPUs.
• Tabby’s current privacy policy explicitly says “No telemetry” and that it does not phone home or send analytics.
• Supports IDE integrations and an OpenAPI interface.
• Good choice if you want a central coding-assistant server for a team.

2. Aider — best for terminal/agent workflows

• Open-source, Git-oriented coding agent.
• Can use locally hosted models, so you can keep code and prompts on your infrastructure.
• Analytics are opt-in, and you can permanently disable them with aider --analytics-disable.
• Particularly good if you prefer a CLI rather than an IDE plugin.

3. Continue — good IDE option, with an important caveat

• Supports completely offline/air-gapped operation with local models.
• Its documentation explains how to disable anonymous telemetry and configure a local model.
• However: the project now says the repository is no longer actively maintained and that the final 2.0 release removed anonymous telemetry/authentication.
• I'd therefore favor Tabby for a new deployment.

4. Cline — powerful agent, but not my first choice for your requirement

• Open source and can work with local models.
• Telemetry is optional and can be disabled.
• Because you're specifically asking for no telemetry, I'd choose something with a simpler privacy story rather than relying on an opt-out.

My recommendation

If you mean “I want the entire coding assistant, including the model, running on my own machine/server with zero outbound telemetry”, I'd go with:

Tabby + a local coding model + network egress blocked by default.

That last part is important: even when an application promises no telemetry, a firewall/egress policy gives you an additional technical guarantee. Tabby itself is designed to be self-contained and doesn't require an external cloud service.

If you tell me your hardware (CPU/GPU/RAM) and whether you want VS Code, JetBrains, or terminal, I can recommend a specific self-hosted stack and model.

To build a completely private, self-hosted, zero-telemetry coding assistant stack, you need a three-layer setup:

1. The Model Runner: Hosts and serves open-weights AI models locally.
2. The Coding Model: Specialized code-generation and chat models (like Qwen 2.5 Coder or DeepSeek).
3. The IDE Client: An extension inside your editor (VS Code, JetBrains) that connects to your local runner.

Phase 1: Choose Your Model Runner & Models

• Ollama (Easiest & Most Popular): Runs smoothly on macOS, Linux, and Windows. It operates locally with no telemetry out of the box.
  • Download it from Ollama's Official Website.
  • Pull a great coding model via your terminal:
    • For chat and reasoning: ollama run deepseek-r1 or ollama run qwen2.5-coder
    • For fast inline autocomplete: ollama pull qwen2.5-coder:1.5b
• LM Studio (Best GUI Alternative): If you prefer a desktop application to browse, download, and test models with zero configuration and a built-in local server (localhost:1234 ), check out LM Studio.
• TabbyML (Best for Teams/Enterprise Self-Hosting): If you want a dedicated all-in-one open-source alternative to GitHub Copilot that runs via Docker, handles codebase-aware indexing, and supports offline multi-user environments, look at Tabby on GitHub.

Phase 2: Set Up Your IDE Integration

To get inline code completion (tab-to-complete) and sidebar chat inside VS Code or JetBrains without calling cloud telemetry services:

1. Install an Open-Source Extension:
   • Look for active community extensions like Roo Code or standard local-compatible clients. (Note: While widely popular previously, Continue.dev was sunset/acquired in mid-2026, though its open-source forks and alternatives remain active).
2. Configure the Endpoint:
   • Point your IDE extension settings to your local runner address (e.g., http://localhost:11434 for Ollama or http://localhost:8080 for Tabby).
3. Disable Telemetry in Settings:
   • Ensure that both your IDE (e.g., VS Code telemetry settings set to off ) and the specific extension settings have telemetry explicitly disabled.

Would you like help configuring a specific model (like Qwen 2.5 Coder ) with Ollama , or are you looking to deploy a multi-user Tabby instance on a home server/Docker setup?

Yes. If self-hosted + no telemetry is the priority, I’d shortlist these:

• github.com — my first choice for an IDE. The current 2.0 release explicitly says it removed anonymous telemetry and authentication. It supports VS Code, JetBrains, and a CLI, and can connect to locally hosted models.
• github.com — best for a dedicated self-hosted server. It's open source, self-contained, designed for on-prem deployment, and can run models on your own hardware.
• github.com — best CLI/agent option. You can point it at a local model rather than a cloud API. It does have analytics functionality, but its code provides a permanent analytics-disable option, so I'd explicitly disable it for a strict no-telemetry setup.

What I'd choose

For maximum privacy, I'd use:

VS Code/JetBrains → Continue → Ollama/local model

with the machine/server blocked from outbound internet after downloading the models. That gives you a practical coding assistant while making telemetry/phone-home technically impossible.

If you tell me your GPU/CPU and RAM (e.g. “RTX 4090, 64 GB”), I can recommend the best local coding model and give you a complete Docker/Ollama + Continue setup.

To build a fully self-hosted, private coding assistant with zero telemetry or external data-sharing, you need a decoupled stack : an inference engine to run the model, a local model optimized for programming, and a client/IDE extension to interact with it.

Here are the best open-source, self-hosted tools and configurations available for absolute privacy:

1. The Inference Engine (Backend)

• Ollama: The easiest way to get up and running locally on macOS, Linux, or Windows. It runs entirely offline and exposes a local API. You can grab it directly from Ollama.
• llama.cpp / Llama Server: A lightweight, high-performance C/C++ inference engine ideal for running quantized models with minimal overhead.

2. The Coding Models

• DeepSeek-Coder-V2: Exceptional performance for code generation, multi-language support, and filling-in-the-middle tasks.
• Qwen2.5-Coder / Qwen3-Coder: Highly optimized open-weights models specifically trained for agentic coding workflows and complex logic.
• Tip: You can pull these models directly via Ollama (e.g., ollama run qwen2.5-coder).

3. The Client Interfaces & IDE Extensions (Frontend)

• Tabby: An open-source, self-hosted AI coding assistant built specifically for air-gapped and regulated environments . It provides IDE extensions (VS Code, Vim, etc.) and handles real-time code completions locally. Learn more at the Tabby GitHub.
• Aider: A fantastic terminal-based pair programmer that edits files in your local git repository directly. It natively supports connecting to a local Ollama or OpenAI-compatible endpoint. Check it out at Aider.
• Continue: An open-source autopilot for VS Code and JetBrains. You can configure config.json to point completely to your local Ollama instance, ensuring no data leaves your machine. Check out the setup guide at Continue.
• Open WebUI: If you prefer a ChatGPT-style browser interface to interact with your local coding models instead of an inline IDE plugin, Open WebUI offers a fully self-hosted, Docker-ready dashboard.

If you'd like, let me know:

• Which IDE you use (VS Code, JetBrains, Neovim, etc.)
• Your hardware specs (GPU/VRAM and RAM)

I can give you a step-by-step configuration guide tailored to your exact setup.

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

My recommendation: Continue + local LLM

Continue can be configured for an air-gapped/offline environment. Its documentation specifically describes disabling anonymous telemetry and configuring a local model provider.

A typical fully-local stack would be:

VS Code / JetBrains
        │
        ▼
     Continue
        │
        ▼
   Ollama / llama.cpp
        │
        ▼
  Local coding model

With this arrangement, your source code and prompts don't need to leave your machine/network. For particularly sensitive environments, I'd also enforce this at the network layer—e.g. block outbound traffic from the assistant/container—rather than relying solely on an application's privacy setting.

One important current-status caveat: Continue's documentation says the original continuedev/continue repository is now read-only and describes its 2.0 release as final, although the tooling remains documented.

If you want a central server: Tabby

TabbyML is purpose-built for this. It is self-hosted, can run via Docker, provides an API and IDE integrations, and its current privacy policy explicitly states “No telemetry” and says it doesn't phone home or send analytics.

For example, you can run the server entirely on your own hardware and have developers connect their IDEs to it. Tabby's documentation describes it as an open-source, self-hosted coding assistant.

If you want an agent rather than autocomplete: Aider

Aider is particularly good for editing an existing repository, making multi-file changes, and working with Git. It supports local LLMs as well as cloud models, so using a local model keeps the actual coding interaction on-premises.

If “zero telemetry” is an absolute security requirement, I'd go one step further than choosing a privacy-friendly product:

1. Run the model locally.
2. Run the assistant locally/on your LAN.
3. Disable any telemetry/analytics features.
4. Block unnecessary outbound network access with a firewall.
5. Audit the source code and container network connections before deploying it for sensitive code.

If you tell me your hardware (CPU/GPU/RAM), IDE (VS Code, JetBrains, Neovim, etc.), and whether this is just for you or a team, I can recommend a specific self-hosted stack and model.

Continue can be configured for an air-gapped/offline environment. Its documentation specifically describes disabling anonymous telemetry and configuring a local model provider.

A typical fully-local stack would be:

VS Code / JetBrains
        │
        ▼
     Continue
        │
        ▼
   Ollama / llama.cpp
        │
        ▼
  Local coding model

With this arrangement, your source code and prompts don't need to leave your machine/network. For particularly sensitive environments, I'd also enforce this at the network layer—e.g. block outbound traffic from the assistant/container—rather than relying solely on an application's privacy setting.

One important current-status caveat: Continue's documentation says the original continuedev/continue repository is now read-only and describes its 2.0 release as final, although the tooling remains documented.

If you want a central server: Tabby

TabbyML is purpose-built for this. It is self-hosted, can run via Docker, provides an API and IDE integrations, and its current privacy policy explicitly states “No telemetry” and says it doesn't phone home or send analytics.

For example, you can run the server entirely on your own hardware and have developers connect their IDEs to it. Tabby's documentation describes it as an open-source, self-hosted coding assistant.

If you want an agent rather than autocomplete: Aider

Aider is particularly good for editing an existing repository, making multi-file changes, and working with Git. It supports local LLMs as well as cloud models, so using a local model keeps the actual coding interaction on-premises.

If “zero telemetry” is an absolute security requirement, I'd go one step further than choosing a privacy-friendly product:

To build a completely private, self-hosted coding assistant with zero telemetry and no data leaving your local machine or private network , you need a stack consisting of three layers: an inference engine (to run the model), a backend/completion server, and an IDE client.

The Recommended Open-Source Stack

1. The Inference Engine: Ollama or
   • What it does: Runs the open-source weights locally on your CPU/GPU . Completely offline and telemetry-free.
   • Top Coding Models to Load: deepseek-coder-v2 or qwen2.5-coder (available in various sizes depending on your VRAM).
2. The IDE Extension:
   • What it does: An open-source autopilot and chat extension for VS Code and JetBrains that hooks straight into your local Ollama instance.
3. Alternative Self-Hosted Server (For teams or air-gapped setups):
   • What it does: A self-hosted, all-in-one AI coding assistant server that can run fully offline behind your firewall for inline autocomplete and chat.

Step-by-Step: Setting up VS Code + Local LLM (5-Minute Setup)

• Step 1: Download and run Ollama on your local machine.
• Step 2: Pull a strong open-source coding model via your terminal:bash``` ollama run qwen2.5-coder:7b

Use code with caution.
- **Step 3:** Install the Continue Extension from the VS Code Marketplace.
- **Step 4:** Edit your `~/.continue/config.json` to point strictly to your local Ollama instance, ensuring no external API keys or network endpoints are referenced:json```
{
  "models": [
    {
      "title": "Qwen2.5 Coder Local",
      "provider": "ollama",
      "model": "qwen2.5-coder:7b"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen2.5 1.5B Coder",
    "provider": "ollama",
    "model": "qwen2.5-coder:1.5b-base"
  }
}

Use code with caution.

If you'd like, let me know:

• Your hardware specs (specifically your GPU/VRAM or unified memory on Mac)
• Whether you need this for just yourself or an entire team/network

I can recommend the optimal model size (e.g., 7B, 14B, or 32B parameters) for your exact setup.

To build a fully self-hosted, private AI coding environment with zero telemetry and no data leaving your machine or local network , you should use an open-source IDE extension coupled with a local inference engine.

The top stack for this setup pairs Ollama (for running the model) with Continue (for the IDE interface) or Tabby (for an all-in-one self-hosted server).

The Recommended Private Stack

- **What it does:** Runs open-weights coding models locally on your machine's CPU or GPU (supports macOS, Linux, and Windows).
- **Privacy & Telemetry:** Completely local, offline-capable, and transmits zero data or telemetry anywhere.
- **Great Models to load:** `qwen2.5-coder` (7B or 14B) or `deepseek-coder-v2`.[](https://docs.continue.dev/guides/ollama-guide) [[1]](https://docs.continue.dev/guides/ollama-guide)

- **What it does:** An open-source autopilot/chat extension for VS Code and JetBrains. It gives you inline code generation (`Ctrl+I` / `Cmd+I` ), sidebar chat, and autocomplete.
- **Privacy & Telemetry:** Fully open-source and model-agnostic. You configure it via a local JSON file to point directly at your local Ollama instance (`http://localhost:11434` ), ensuring no external calls are made.[](https://iternal.ai/best-private-ai-coding-assistants) [[1]](https://iternal.ai/best-private-ai-coding-assistants)

- **What it does:** An open-source, self-hosted alternative to GitHub Copilot that you can run via Docker on your local infrastructure.
- **Privacy & Telemetry:** Designed specifically for individuals or offline enterprise teams who want a centralized local server for code completions and chat without any third-party cloud connections.[](https://www.youtube.com/watch?v=eZ3J45K7gXU) [[1]](https://www.youtube.com/watch?v=eZ3J45K7gXU)[[2]](https://github.com/tabbyml/tabby)

Quick Setup Guide (Ollama + Continue)

json``` { "models": [ { "title": "Qwen2.5 Coder", "provider": "ollama", "model": "qwen2.5-coder" } ], "tabAutocompleteModel": { "title": "Qwen2.5 1.5B Coder", "provider": "ollama", "model": "qwen2.5-coder:1.5b" } }

Use code with caution.

Would you like help configuring a **terminal-based coding assistant** like Aider to run locally, or do you need recommendations on **hardware/GPU requirements** depending on the size of the model you want to run?

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

• Continue — my top pick for most developers. It works with VS Code/JetBrains and local models, and its current 2.0 release removed anonymous telemetry. Continue also documents an offline/air-gapped setup.
• Tabby — best if you want a central self-hosted server for yourself or a team. It's open source, self-contained, and can run entirely on infrastructure you control. However, its IDE extensions have anonymous usage tracking enabled by default, so you'd need to explicitly disable that.
• Aider — a good choice if you prefer a terminal-based coding agent rather than an IDE extension. For strict privacy, pair it with a local model rather than a cloud API.

What I'd choose

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

VS Code/JetBrains + Continue + Ollama + a local coding model

That gives you an IDE assistant while keeping inference local. Continue specifically documents running without Internet access and disabling telemetry.

If this is for a company/team, I'd lean toward Tabby on an internal server, with its anonymous usage tracking disabled and network egress restricted at the firewall.

If you tell me your OS (Windows/macOS/Linux), GPU/RAM, and whether this is personal or a team deployment, I can recommend a specific setup and model.

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) [1]

- **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. [1]

- **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)?