Private coding assistant
A coding assistant for teams whose code cannot leave the network
- Served on your GPUs
- Works fully air-gapped
- Every request logged on your systems
Illustrative sample. The repository, file and answer are fictional.
“Why does this run apply VAT twice for EU customers?”
Context retrieved
billing/invoice.pyopen file
billing/models.py
docs/tax-rules.mdfrom your wiki
apply_vat() is called in both build_line_items() and the totals pass. The rule in docs/tax-rules.md says it belongs in the totals pass only.
Model, index and logs all sit on hardware you control
Why self-host it
A codebase is not a document you can send somewhere to be helpful
Source code carries client work under contract, embedded credentials, security logic and years of accumulated decisions. It is also the asset most organisations would least like a competitor or an attacker to read.
This is the same argument as sovereign AI generally, applied to your engineering team. If the constraint is a specific country's rules rather than a client contract, see data residency by region.
Client contracts
Agencies, consultancies and contractors often work under terms that prohibit client code being sent to any third party, whatever the provider's retention policy says.Regulated and classified work
Defence, government and critical infrastructure work is frequently done on networks with no outbound route at all. A hosted assistant simply cannot be used.What is in the repo
Codebases contain credentials, security logic, customer identifiers and unreleased product decisions. Completion context does not distinguish between them.Per-seat cost at scale
Per-developer pricing scales with headcount forever. Hardware you already own does not, which changes the arithmetic for larger engineering teams.
| Topic | Hosted coding assistant | Self-hosted on your infrastructure |
|---|---|---|
| Where code goes | Fragments sent to the provider on each request | Nothing leaves your network at any point |
| Isolated networks | Needs outbound access, often a licence check too | Runs fully air-gapped, no call home |
| Codebase knowledge | Limited to the open file and recent context | Retrieval across your repositories and internal docs |
| Model control | The provider changes the model when they choose | You pin a version and test before you move |
| Cost model | Per developer, per month, indefinitely | Your own hardware, no per-seat licence |
| Audit | Whatever the provider chooses to expose | Every request and response logged on your systems |
What we build
Beyond autocomplete
Inline completion is the part everyone demonstrates. The capabilities that change how a team works are the ones that understand your codebase rather than the current file.
Completion served in your editor
An open-weight code model served inside your network, with your editors pointed at the internal endpoint. Developers stay in the tools they already use.Questions answered from your repositories
Retrieval over your code, internal documentation and architecture decisions, so the assistant can explain why something works the way it does rather than guessing from public patterns.Review and change assistance
Summarising a diff, flagging patterns your team has decided against, and pointing at the internal rule a change contradicts. Scoped to the conventions your codebase actually follows.Legacy and in-house languages
Where a team works in an internal framework or an older stack that public models handle poorly, the corpus is your own code, which is exactly where retrieval and fine-tuning earn their cost.Evaluation on your own code
A benchmark built from your repositories, so model choices and prompt changes can be measured on your stack instead of argued from public leaderboards.Access control and audit
Repository permissions enforced at retrieval time, and every request and response logged inside your environment for security review.
How we build it
Serve it, ground it, then measure it
The hard parts are not the model. They are serving it fast enough that developers keep it switched on, grounding it in your codebase, and proving it helps.
Latency is the adoption problem. An assistant that takes too long to suggest gets turned off in a week, whatever its answers are worth, which makes serving and sizing a product decision rather than an infrastructure detail.
- Stage 1
Agree what it has to do well
Inline completion, codebase questions and review assistance are different workloads with different latency budgets. We pick the ones worth building first and define how success will be measured on your repositories.Scoped workloads and a benchmark - Stage 2
Choose and size the model
Candidate open-weight code models are benchmarked on your languages and your hardware, with licence terms checked against how you intend to use them. Quantization is used to fit the GPUs you have.A model that fits your hardwareOpen-weight code modelsQuantization - Stage 3
Serve it inside the network
An inference endpoint on your own servers, sized for concurrent developers rather than a single user, with the throughput and latency measured under realistic load.Private inference endpoint - Stage 4
Index your repositories
Code, internal documentation and decision records are chunked and embedded on your own GPUs into an index inside your environment, with repository permissions carried through to retrieval.Private code index - Stage 5
Connect the editors
Your developers' editors are pointed at the internal endpoint so the assistant appears in the tools they already use, with no change to how they work day to day.Working in your team's editors - Stage 6
Measure, log, hand over
We run the benchmark, wire in audit logging and access control, then hand over the serving stack, the index pipeline and the runbooks so your team can update models themselves.A system your team can run
Why us
We have built the pieces this is made of
A private coding assistant is a served open-weight model, a retrieval pipeline over a proprietary corpus, and a tool developers will actually keep open. We have shipped all three.
- PharmaBrain: an air-gapped retrieval assistant over thousands of proprietary documents, on local GPUs
- AS-One: an open-source computer vision framework with 580+ GitHub stars, built and maintained by our team
- 150+ models delivered, with 50+ AI engineers and specialists
Where it can run
Air-gapped
Weights, index and serving stack installed inside an isolated network, with no outbound request at inference time.Your own cloud account
Deployed into your AWS, GCP or Azure tenancy, with private endpoints your platform team controls.
Getting started
From assessment to an assistant your developers keep open
Step 1: Assessment
Scope and feasibility
We review your languages, repositories, editors and security rules, then recommend which workloads to build first and what hardware they need.
- NDA on request
- Hardware sized before you buy
Step 2: Proof of concept
4–6 weeks
A served model and an index over a real subset of your repositories, benchmarked on your own code with your developers using it.
- Measured on your repositories
- Runs on your hardware
Step 3: Production
Harden, deploy, hand over
Access control, audit logging and monitoring go in, then we hand over the serving stack, the index pipeline and the runbooks.
- You own the IP
- Your team updates models
Guides from our engineers
Go deeper on private AI
Choosing a model, sizing the hardware, and what each deployment option actually protects against.
- Which Open-Weight LLM Should You Self-Host?Technical
- What GPUs Do You Need to Self-Host an LLM?Hardware
- RAG or Fine-Tuning? The Wrong Answer Is ExpensiveDeep dive
- What Does It Cost to Run Your Own LLM?Cost
- Air-Gapped, Private Cloud or Sovereign Cloud: Which Do You Need?Architecture
- Deploy an Open-Weight LLM on Your Own Server with vLLMTutorial
- Self-Hosted Coding Assistants: What Works Air-GappedGuide
- Data Residency Rules That Shape AI Projects in 2026Regulation
- On-Premises vs Cloud Computer Vision Deployments – An Enterprise GuideDeep dive
FAQ
Questions engineering leads ask
Because source code is usually the most sensitive asset an engineering organisation has, and a hosted assistant sends fragments of it to a third party on every keystroke. For teams working under client contracts that prohibit code leaving the network, in defence and government work, or in regulated industries where the codebase contains embedded credentials and customer data, that is not a policy question but a hard constraint. A self-hosted assistant keeps the model, the index and the logs inside your perimeter.
Open-weight code models, chosen against your hardware and your languages. The right choice depends on the GPUs you have, how many developers will use it concurrently, your latency target for inline completion, and the licence terms you can accept. We benchmark candidates on your own repositories rather than on public leaderboards, because performance on your stack is what matters.
Yes, and that is usually where the value is. Retrieval over your repositories, internal documentation and architecture decision records lets it answer questions like why a module behaves the way it does, or where a rule is enforced. It is the same retrieval architecture as a private knowledge assistant, with code and developer documentation as the corpus.
Most open editor integrations speak to a model endpoint over HTTP, so the assistant is served inside your network and the editor points at it. That keeps developers in the tools they know, and it means the endpoint is the only thing that needs securing. We scope the integration against the editors and languages your team actually uses.
Yes. Model weights, the index over your repositories and the serving stack can all be installed inside an isolated network, with no licence server to call home to and no outbound requests at inference time. Model and dependency updates follow an agreed path that fits your change control rules.
We agree what to measure before the build: acceptance rate on suggestions, time to a useful answer on codebase questions, and how often the assistant is right about your own code. Those come from an evaluation set drawn from your repositories. Without that, adoption is the only signal, and adoption is easy to mistake for value.
Related
Keep exploring
- LLMs & agentsSovereign AIPrivate LLMs and vision models on your own servers, VPC or air-gapped network.
- LLMs & agentsPrivate knowledge assistantAn internal assistant that answers from your own documents, with citations, on hardware you control.
- LLMs & agentsOpen-weight model fine-tuningAdapt open models to your domain on your own infrastructure, and keep the weights.
- CompanySecurity and IPNDAs, IP ownership, data handling and private deployment options.
Case studies
Book a strategy session
Scope a private coding assistant
Tell us your languages, roughly how many developers would use it, and the rules your code has to stay within. An engineer will reply within one business day, under NDA if you need it.
- Send the form, it takes 2 minutes
- We reply within 1 business day, under NDA if you need it
- A 30-minute call to scope feasibility and next steps