Give it a brief. Walk away.
Return to working, verified, buildable software.
From a laptop GPU to a data-centre rack — it detects your silicon and scales automatically.
No subscription required to operate. Perpetual licence model.
Native C++ workstation — not Electron, not a plugin. A Software House swarm runs a Task DAG,
verifies in shadow buffers, then solidifies. Local Ollama. PostgreSQL memory. Your machine.
Get the alpha first. Pay once, own it forever. Run it entirely on your hardware.
Waitlist members receive early install access, launch pricing before public release, and updates while the workstation is in active alpha — plus a say in what we ship next.
Neon Sovereign is an autonomous engineering workstation: you define the outcome, it plans, executes, verifies, then hands back a buildable result with an audit trail.
Turn a spec into a repo: scaffold, implement, compile, smoke test. You return to green builds, not a chat transcript.
Iterative repair loops with verification gates. The ledger remembers prior incidents and proven fixes.
Refactors with interface negotiation and Crucible verification before anything reaches disk.
Multi-agent parallel lanes, stable semantic IDs, and rollbackable checkpoints — designed for non-trivial repos.
Documentation grounded in your code + build logs, not marketing boilerplate.
Local Ollama, local memory, no cloud required to operate. You control egress.
Neon Sovereign took a brief (“minimal Win32 C++20 counter app”), generated the repo (include/, src/, CMakeLists.txt), ran an integration build, verified outputs, and returned a SUCCESS verdict.
Simulation #294: Final State: SUCCESS · Seed: Completed · SwarmIdle: Yes · OutputsOK: Yes · IntegrationOK: Yes · wall_s ≈ 195s
Simulation #293: Final State: SUCCESS · Seed: Completed · SwarmIdle: Yes · OutputsOK: Yes · IntegrationOK: Yes · wall_s ≈ 4495s
Final State: SUCCESS Seed: Completed | SwarmIdle: Yes | OutputsOK: Yes | IntegrationOK: Yes
The swarm produced buildable Win32 artifacts (CMake + C++20 source layout) and passed integration verification — without a human hand-editing files mid-run.
More demonstrations will land as the workstation UI hardens — but the build pipeline is already closing the loop.
Built from first principles for teams tired of babysitting every file edit — and architectures that cannot converge on shippable software.
At launch it queries your GPU, measures available VRAM, selects the right model tier, and sizes the agent swarm accordingly. You configure nothing. Whether on a laptop or a rack of H100s — it simply runs harder.
Gemma-class Logic tier + compact Sentinel critic. Full pipeline, full Crucible. Audit hot-swap evicts Logic before locking Sentinel — you never pay for two full stacks at peak VRAM.
FULL CAPABILITYMid-tier Architect models, larger context windows, full Silicon Retina visual audit. More parallel Developer lanes active simultaneously as headroom allows.
EXPANDED SWARMLarge MoE Architect tiers, deep context, multiple Developer agents running in parallel. VRAM governor partitions dynamically across the available pool — no static configuration needed.
MAXIMUM AUTONOMYMulti-host Ollama fabric, optional vLLM and OpenAI-compatible endpoints, rack sidecar routing. The swarm agent count grows automatically to match available inference capacity.
LIMITLESS SCALEState the outcome. The Architect produces a full JSON Task DAG with stable semantic IDs.
Kahn's algorithm computes optimal parallel execution order. You approve or steer before work begins.
Developer agents run in parallel, negotiating interfaces before writing a single line of code.
Every patch runs the Crucible gauntlet — shadow compile, peer review, adversarial audit — before touching disk.
Running software, proof-of-work screenshots, forensic audit log. You return to a result, not a suggestion.
Three intents drive the same engine — consultation when you need it, autonomous execution when you don't, forensics when something breaks.
Talk through design and trade-offs. Swarm telemetry, staff mail, and checkpoints in one orchestrator feed — without kicking off a full build.
Interview, plan approval, then the full Software House run: Architect DAG → parallel Developers → Crucible. Same path as headless CI.
Reason over the open codebase and ledger — compiler incidents, prior fixes, flight-recorder history. No greenfield detours.
Pipeline lifecycle stages map to the UI and to --headless on your CI box — archived logs, staff mail, attestation chain included.
Every agent has a fixed role enforced in C++. Wrong tools, wrong outputs — rejected at the gate. The Sentinel is always a different model family from the Architect by doctrine, so the critic never shares failure modes with the coder. The swarm count grows automatically with available VRAM.
Designs the Task DAG. Plans and arbitrates interface conflicts. Never writes implementation code.
Implements in a Reason-Act-Observe loop. Real tool execution — reads, edits, compiles, observes output.
Adversarial auditor. Different model family — never generates code. Red-team hypothesis on every patch.
Owns integration builds, cross-compilation, the shadow buffer. Only role permitted to call build_project.
Ghidra headless bridge. Silicon-level read-only analysis of instruction scheduling and memory layout.
Agentic fuzzing and stress testing against virtualised QEMU and Hyper-V targets.
Captures live desktop / VM framebuffers. Vision-language audit for layout collisions, contrast failures, missing UI.
Read-only blast-radius analysis. Can hold tasks and escalate before bad mutations land.
Read-only reconnaissance — docs, headers, symbols — before Developers commit to interfaces.
Environment, packaging, and deployment lanes. Coordinates with ForgeMaster on integration builds.
Layout and interaction feedback paired with Silicon Retina evidence — not guesswork in chat.
Post-mortem on failed runs — traces, logs, and ledger state to explain what broke and why.
LLMs are consumers of state — not the source of truth. Neon’s deterministic spine (semantic graph, task board, causal ledger) survives every session.
Build history, AST vault, terminal flight recorder, FTS + pgvector recall. Bundled Postgres or your own SOVEREIGN_DATABASE_URL.
Tree-sitter graph with stable semantic IDs — not fragile byte offsets. Architects emit Task DAGs that reference real nodes in your codebase.
LNK2019, C2146, and friends get upserted. The next repair prompt starts from proven fixes, not fresh hallucinations.
Staff mail and blackboard replies let you redirect the swarm mid-flight without restarting the pipeline from zero.
ledger-mcp stdio server exposes the same Postgres memory to Cursor and other tools — one ledger, many clients.
In-memory SQLite contract negotiation so parallel Developers agree on interfaces before anyone writes implementation code.
Every patch a Developer submits runs a layered gauntlet before the filesystem sees it. Multiple inner repair rounds fire automatically before a single swarm-level retry is consumed.
Fast structural balance check on the patch. Failure triggers a Speed-tier LLM structural fix before proceeding.
A second model pass, independent of the Developer, issues PEER_APPROVED or PEER_ISSUES with specific bullets. Issues feed a Logic-tier rewrite before Sentinel sees the patch.
Red-team hypothesis plus Speed-tier audit from a different model family. Only the [AUDIT]: section drives rejection — protecting against false positives.
LSP diagnostics and optional single translation-unit compile run against the patch in a shadow buffer. Code does not reach disk until this passes.
A Vision-Language Model captures live framebuffers from the running target via QEMU, Hyper-V, or ADB. Audits for layout overlaps, contrast violations, and missing UI elements.
SHA-256 attestations for every real executed command. Agents cannot forge sovereign records, golden fixtures, or integration results. Pipeline success requires a valid attestation chain.
v0.1.0 active alpha — Windows 11 primary, WSL2/Linux build path. Agents-cpp SDK, libgit2, Tree-sitter structural edits, optional AVX2/AVX-512 dispatch.
Designed from the ground up for regulated and sensitive environments — healthcare, finance, legal, defence. Your source code and context never leave the box unless you explicitly configure it to.
Weights run on your hardware via Ollama. No cloud API key required to operate the full pipeline. Optional cluster endpoints for teams with dedicated inference infrastructure.
Project knowledge, build history, compiler incident memory — stored in a local PostgreSQL ledger with pgvector recall. No third-party knowledge base.
Collaboration uses BIP39 12-word mnemonic identity. No accounts. No registration. No cloud authentication required.
API keys and credentials encrypted via Windows DPAPI. Never exposed to any model context window under any circumstance.
Toolchain, verification strategy, and agent specialisation change automatically based on what you are building. Tier-1 depth on native C/C++/Rust today — everything else in active expansion.
TIER-1 (highlighted) — C / C++ / Rust: stable, production, battle-tested. All others in active expansion.
Neon Sovereign is shipping to early access registrants first. It is a genuine engineering frontier — not a polished consumer product. Expect rapid iteration and breaking changes.
Native C++ workstation — parallel agents, shadow-buffer verification, persistent ledger. Not a chat sidebar. Join the waitlist for alpha access.
NeonSovereign.store · Perpetual licence. No subscription to operate.