Anyone who has used a modern coding assistant knows the pleasure of it: three characters typed and an entire line appears, sometimes an entire block. For many teams that pleasure comes with a condition they cannot accept. Every keystroke and every fragment of source is uploaded in real time to somebody else's servers for analysis. In finance, healthcare and defence work, the code is not permitted to leave the internal network at all, let alone be fed to an external service. Speed and secrecy look like a straight trade-off, until someone carries the whole assistant back into their own machine room.

Tabby is that arrangement. It is a coding assistant you host yourself, written in Rust and packaged as a single service process. Completion, the question-answering engine and the administrative console all live inside the same artifact, and no external database or cloud service is required to run it.

One service, the whole pipeline

The architecture is deliberately boring in the best sense. One process schedules inference, indexes the repository, exposes the interface and serves the management console. Because there are no moving parts to assemble, a small team can run it on a single machine and forget about it. Once the model has downloaded and the service is up, members install the companion extension in their editor, point it at the address, and start working.

Extensions exist for more than a dozen mainstream editors, covering the common integrated environments in several languages as well as the modal editors that some people never leave. The practical consequence is organisational rather than technical: one server, one model, one set of settings, and every developer in the team gets an identical assistant.

It knows the codebase, not just the syntax

The core capability is real-time completion. The cursor position, the surrounding code and the contents of the file are assembled into a context, sent to a model running on the same machine, and a single line or a whole block comes back in a fraction of a second. Completion and conversation can be configured separately, so a light model carries the high-frequency completions while a stronger one handles the occasional deep question, neither slowing the other down.

The more interesting half is context. A parser walks the repository and extracts class definitions, method signatures and call relationships into an index. Retrieval then injects the internals that actually exist in your project into the request, so the suggestion uses your own internal library and your own naming habits instead of guessing at something that merely looks plausible. The index covers the repository, internal documents and issue trackers, which means the question-answering side can point at evidence in the code rather than at general knowledge.

Your choice of model, and modest hardware

The service is neutral about model vendors. The maintained list covers the well-known open code models, and weights you have trained or tuned yourself can be attached instead. On the hardware side, acceleration is supported on the mainstream discrete graphics cards and on the chips Apple builds, and one ordinary consumer card is enough to drive models in the billions of parameters for a small team.

The console handles the human side of running it: creating accounts, issuing a separate access token to each person, watching usage per member and switching which model serves completion and which serves conversation. For organisations that must be auditable, access control and usage records provide something to point at during a review. A later addition, an agent codenamed Pochi, extends the scope from completing code to doing work: it takes a whole task, breaks it down, plans and executes, and reports progress while it goes.

Licensing, honestly stated

The licensing is split, and the split is worth understanding before adopting it. The completion engine, the model registry and the core interfaces are fully open under a permissive licence, so any team can deploy them at no cost and a small group's daily needs are covered. The administrative console, single sign-on and audit logs sit in the commercial tier, sold per seat, with a hosted option for those who would rather not run anything.

By the middle of 2026 the project had gathered more than thirty thousand watchers. An honest assessment has to include the limits: a self-hosted arrangement is only as good as the model and the hardware behind it, and a local model still trails the frontier services on complicated reasoning and changes that span many files. The light models a small team can afford are best at the patterns that recur in ordinary code, which is where most completions live anyway.

For a team with a hard rule that source cannot leave the network, and a wish to give every developer the same assistance, this belongs on the shortlist. The only way to know is to run it once on your own hardware and watch what it does with your code.