Agentic coding. On your infrastructure. Never in the cloud.
A full agentic coding assistant that writes, tests, refactors and reviews code, running entirely against your own local models, on your own hardware.
Why now
AI coding has crossed from research experiment to board-level KPI.
This is now the fastest-adopted developer tool category in history: faster than Git, faster than VS Code, faster than GitHub itself. Every Fortune 500 engineering organisation is running a procurement cycle on it right now.
$25B+projected 2030 AI code-assistant market (Gartner, 2024)
<12 moCursor from $0 to $100M ARR (Anysphere, 2024), one of the fastest SaaS trajectories on record
1.8M+GitHub Copilot paid seats across 77,000+ enterprise organisations (Microsoft, Oct 2024)
This is now a procurement line item. Not a hackathon toy.
The gap
But every major vendor made the same architectural choice.
- GitHub CopilotMicrosoftCloud only
- CursorAnysphereCloud only
- Claude CodeAnthropicCloud only
- Codeium / WindsurfCodeiumCloud only
- Replit AIReplitCloud only
- Google JulesAlphabetCloud only
Why they all picked this
Serving a frontier-scale model is a cloud business. GPU inventory, elastic routing and model-update cycles all require infrastructure most customers can't justify owning. Cloud is the natural distribution model for AI.
What that means for buyers
For most organisations the trade (productivity gain in exchange for sending code to a third party) is acceptable. For organisations where source code is a regulated asset, that trade is impossible. Those buyers have been effectively locked out of this category.
Everyone picked the same trade-off. We picked the other one.
The buyers locked out happen to be the biggest.
~50%share of global enterprise software spend concentrated in regulated industries (BFSI · healthcare · defence · government)
$650B+BFSI software and IT spend annually: the single largest vertical software budget on earth
Millionsof developers worldwide employed inside organisations where source code is itself a regulated asset
Zerofull-agent-loop assistants from the top cloud vendors deployable on an air-gapped network. The few local alternatives (Continue.dev, Tabby, Tabnine) are chat / completion-only, not full agentic
And the regulatory wall is widening, not shrinking
- EU AI Actfully in force Aug 2026Most financial-services and healthcare AI classified high-risk; code-handling AI inherits.
- DORA (EU)effective Jan 2025Digital operational resilience: third-party ICT risk disclosure mandatory for financial entities.
- HIPAA guidanceHHS/OCR, continuousAI touching PHI must satisfy BAA and risk analysis; cloud BAAs don't cover source-code egress.
- DPDP (India) + PIPL (China)in forceCross-border transfer restrictions tightening; data locality becoming the default assumption.
This isn't a cycle. It's a permanent gap. Our addressable market is widening by the quarter.
Your code can't leave the building.
Every mainstream AI coding assistant sends your source code to a third-party cloud for inference. Copilot, Cursor, Claude Code, Codeium: all cloud-only by design. For most teams, that's a trade-off. For many, it's a non-starter.
Finance
Trading algorithms. Risk models. Anything near PCI, SOX or MiFID.
Defence
ITAR, EAR, classified and controlled unclassified codebases.
Healthcare
HIPAA-regulated systems. Medical device firmware.
Government
Sovereign code. Air-gapped networks. National-security grade.
Industries where source code is itself a regulated asset.
The product
A full agentic coding assistant that never leaves your network.
Writes code. Runs tests. Refactors. Debugs. Reviews. Decides which tools to call. Runs entirely against your own local LLM, on your own hardware.
0bytes of your code leave your network
~32 MBself-contained binary; no runtime required
16languages tested at the release gate
Deployed with scp. Air-gapped by default.
More than a chat window on a local model.
Multi-file edits
Writes and modifies files across your codebase as a single coherent change.
Runs tests and shell
Executes commands, parses output, iterates until the suite passes.
Diff review in the editor
VS Code and IntelliJ plugins show every proposed change per file. Accept, reject or revert.
Semantic refactoring
An 11-language oracle grades renames, moves and signature changes for coherence.
Pluggable tool system
76+ built-in tools: git, grep, find, apply_patch, web fetch, code search and more.
Multi-backend orchestration
Senior writes, junior reads, expert reasons. Work is routed to the right model automatically.
A production-grade agent loop, the same shape as Cursor or Claude Code, running against your own weights.
Three LLM roles. One coordinator. Your hardware.
Senior
writes code and plansFast coder-tuned model (Qwen3-coder, DeepSeek-Coder or your choice). Runs the hot path on every turn.
Junior
reads and light editsLightweight model handles file reads, grep and small edits in parallel. Keeps the senior free for writes.
Expert
deep reasoning and consultBigger reasoning model (GLM 5.x, DeepSeek-V3) steps in on long-horizon decomposition and stuck-subtask recovery.
Access it however your team works today
VS Code plugin
Diff-preview review, session resume, status bar integration.
IntelliJ plugin
Native IntelliJ diff viewer and sidebar chat panel. Kotlin, Java and Scala first-class.
Terminal TUI
Rich Textual UI. Keybinds, plan panel, live tool output. SSH-friendly.
Simple CLI
Pipeable one-shot invocations. For scripts, CI and cron.
Reliability
Why reliability is the whole product.
Zero cloud fallback
Every failure surfaces inside your network. No vendor rollback, no telemetry stream, no second chance to fix it silently.
Regulated code = audit event
A wrong SQL migration or a scope-creep refactor in a compliance-governed codebase is a reportable incident, not just a bug.
On-prem can't lean on peak IQ
Frontier models mask flakiness with more capability. On-prem has to earn trust through hard measurement.
Statistical gate, not demo GIF
Three-round multirun with a 2/3 pass threshold. Deterministic regressions block a release. Stochastic noise doesn't.
Every regression becomes a test
v317 bracket-regex, v413 shell-quote, v414 path-overmatch: each shipped with a reproducing test. The baseline grows resistant.
100% is the release bar
No workload stays in the baseline unless it holds the gate. Push is blocked until the stamp refreshes clean.
Reliability is where sovereign-code wins, because frontier can't follow us behind the firewall.
What the baseline actually covers.
16 programming languages
Python, TypeScript, Go, Java, Kotlin, Scala, Swift, Rust, C, C++, Objective-C, Dart, C#, SQL, Cypher, CQL.
8-phase greenfield build
Bootstrap → domain model → store and tests → CLI → README → refactor restrictions → report command → bug fix. The same project built end to end.
10 real-world dev scenarios
Flask rate-limiter, Express JWT guard, god-function refactor, REST pagination, Go race fix, SQL-injection audit, PII scrubber, async HTTP, Prometheus metrics, SQL migration.
6 bug-fix and test-generation tasks
Null-deref fix, uncovered-code test generation, debug from traceback, large method-drop refactor, add-CLI-command, multi-file greenfield.
Two regression traps live
Enum fabrication (v281) and single-turn ceiling (v298): historic failure modes kept wired into every release gate.
Timed, resource-bounded
Per-workload wall-clock cap, 3-round majority gate, filesystem forbid-writes gate. Correctness measured on real artifacts, not self-grading.
42 workloads × 3 rounds = 126 attempts per release gate. One deterministic failure blocks main.
Not a demo. A product. With a baseline.
100%baseline-grade pass rate (42 workloads, zero exclusions; 3-round multirun gate on every release)
7,000+automated tests across every subsystem
11languages with semantic refactor grading (CoherenceOracle)
61regression classes codified with AST gates
Measured pass rate per language
2026-10-13, N=10 confirmation on Java, Scala and Objective-C.
- Python 100%
- C 100%
- C++ 100%
- C# 100%
- Dart 100%
- Go 100%
- Kotlin 100%
- Rust 100%
- Swift 100%
- TypeScript 100%
- CQL 100%
- Cypher 100%
- SQL 100%
- Java 100%
- Scala 100%
- Objective-C 100%
42/42 workloads pass the gated baseline, zero exclusions. 3-round majority gate; 126 attempts per release. 7,145 unit tests pass before any push. Covers 16 languages, 10 real-world developer scenarios, and 6 bug-fix / test-generation tasks across the polyglot workload set.
Deployment
One binary. One copy. You're deployed.
The cloud model
- Code shipped to a third-party endpoint on every keystroke
- Metered per-token billing, unpredictable at scale
- Vendor controls model version, availability and roadmap
- Requires outbound internet and exceptions in your firewall
- Compliance team wants to know: who sees your IP?
sovereign-code
- Nothing leaves your network. The binary is the entire egress model.
- Fixed hardware cost. No per-token billing. No surprise invoices.
- You pick the weights: Qwen, DeepSeek, Llama, custom fine-tunes.
- Air-gap deployable. Validated on offline Linux and macOS hosts.
- Compliance team sees one file. Audit is simple.
scp sovereign-code user@target:/usr/local/bin/ # that's it.Who it's for
Built for teams where source code is a regulated asset.
Regulated enterprises
Finance, insurance, pharma, healthcare: any team under PCI, HIPAA, SOX, MiFID or sector-specific IP controls.
Defence and national security
ITAR / EAR / classified projects. Full air-gap deployments, offline SBOM audit, no outbound sockets.
Government agencies
Sovereign code bases. On-prem data residency requirements. GDPR and country-specific data-locality mandates.
Critical infrastructure
Energy, utilities, telecom, transportation. Code that controls real-world systems can't live on someone else's server.
AI research teams
Experiment with your own fine-tunes. Full observability of agent trajectories. No vendor gatekeeping.
Any team that owns its weights
If you're already running local LLMs, sovereign-code turns them into a serious coding agent, with no re-architecture.
Compare
Where sovereign-code sits.
Cloud frontier
Cursor · Claude Code · Copilot- Strengths
- Peak capability
- Rich IDE polish
- Zero infra setup
- Trade-offs
- Cloud-only: code leaves your network
- Per-token billing
- Vendor-controlled roadmap
Local chat UIs
Continue.dev · Tabby · DIY Ollama- Strengths
- Runs locally
- Open source
- Trade-offs
- Thin agent loop
- No multi-backend orchestration
- No reliability baseline
sovereign-code
On-premise · your own weights- Strengths
- Full agent loop locally
- Multi-backend coordinator
- 42-workload reliability baseline
- Shipped as one binary
- Trade-offs
- Peak capability bounded by your local weights
Honest positioning: we don't out-run frontier cloud models on peak capability. We're the right answer when the code can't go to the cloud.
Feature by feature.
| Feature | Cursor | Claude Code | Copilot | Continue.dev | sovereign-code |
|---|---|---|---|---|---|
| Deployment | Cloud | Cloud | Cloud | Local (BYO LLM) | Local (BYO LLM) |
| Code leaves network? | Yes | Yes | Yes | No | No |
| Air-gap deployable | No | No | No | Yes | Yes |
| Agent loop depth | Full multi-step | Full multi-step | Light + chat | Chat / light | Full multi-step |
| Multi-file edits | Yes | Yes | Partial | Varies | Yes |
| In-editor diff review | Yes | Yes | Yes | Varies | Yes (v370–v374) |
| Multi-backend orchestration | No (single model) | No (single model) | No (single model) | No (single model) | Senior / junior / expert |
| Reliability baseline | Internal | Internal | Internal | None published | 42-workload public |
| IDE surfaces | Own fork of VS Code | CLI + VS Code | VS Code / JetBrains | VS Code / JetBrains | VS Code / JetBrains / TUI / CLI |
| Cost model | Subscription + API | Subscription + API | Subscription | Free (OSS) | CAPEX (hardware) |
No single tool wins every row. The right choice depends on which rows your organisation treats as hard constraints.
When to pick what.
Code can leave the building
- Need peak capability and an agent loopCursor or Claude Code
- Already in GitHub / VS Code, want completionGitHub Copilot
- Prefer open source, happy with light chatContinue.dev
Code cannot leave the building
- Need a serious agent loop and reliabilitysovereign-code
- Just need light completionTabby or self-hosted Continue
- Hybrid: some projects cloud, some air-gappedCursor cloud-side + sovereign-code on-prem
Our job isn't to beat Cursor on peak capability. It's to be the right answer when the code can't go to the cloud.
How it works
Three effort tiers, chosen by the cost of being wrong.
The coordinator routes each request through one of three effort tiers. When a subtask fails, an escalation ladder recovers; on the highest tier, a reflection gate verifies every output before it reaches disk.
Long-horizon vs ultra: when to pick which.
| Aspect | Long-horizon | Ultra |
|---|---|---|
| Task shape | Multi-file edits where failures are cheap to catch: code review, tests, the user will notice. Feature-add, module build, documentation, test authoring. | Multi-file edits where failures are expensive to catch or expensive to recover from. Migrations, security fixes, production code, anything that crosses a compliance boundary. |
| Cost profile | ~2–4× standard-effort latency and tokens. Typically 3–10 minutes wall-clock. Standard retry ladder catches most failures; no verify-pass gate. | ~2–3× long-horizon on top (so 5–10× standard). Typically 10–30 minutes. Best-of-N sampling, mandatory reflection gate, expert per subtask. |
| Auto-escalation (standard → ultra) | Known-hard-shape classifier match (enum-fabrication / lru-complexity / long-context-rewrite); explicit user flag (--effort ultra); risk keywords in the prompt (production, migration, security). | |
| The one-line rule | Long-horizon = complex task, standard reliability. Ultra = complex task where you can't afford a silent wrong answer. | |
Pick the tier that matches the cost of being wrong, not the task complexity. The retry ladder recovers from honest errors; only the reflection gate catches silent correctness drift.
Contact
See it running.
Ask for a live demo and bring your toughest refactoring question, or for a walkthrough of an air-gapped install.