NomosModels Are Engines. Nomos Is the Runtime.
Keep Claude Code, Cursor, Antigravity, OpenCode, Windsurf, or Aider. You prompt in plain English the exact way you already do while Nomos governs state isolation and merge safety underneath.
▲ NOMOS // TRANSACTIONAL GOVERNANCE HARNESS FOR CODING AGENTS
Agents Guess. Git Can't.
Meet the Deterministic Layer Underneath.
Keep Claude Code, Cursor, Antigravity, OpenCode, Windsurf, or Aider. Nomos sits between your coding agent and Git - locking main read-only, splitting INT specs from SUB code in a causal DAG, isolating edits in disposable worktrees, and enforcing 42 anti-reward-hacking AST quality gates before promoting memory and landing an atomic Two-Phase Commit.
✦ Hover Left Plane to perturb intent • Toggle "Stock Harness" above to simulate unguarded drift • Click green Totem for Docs
THE DEVELOPER DILEMMA // UNCHECKED AGENT ENTROPY
From Vibe Coding Velocity to Deterministic AST Rails
PHASE 01 // 0-60 MINS
The Vibe Paradise
10x Speed
- ⚡ Instant features scaffolded from prompts
- 🎨 UI renders immediately with zero cognitive load
- 🚀 “AI has solved coding forever” feeling
▲ Peak Velocity
PHASE 02 // THE 3 SILENT FAILURES
The Entropy Trap
0.1x Speed
- 🎭 Reward Hacking Tests: Deleted or weakened assertions to fake green builds
- 🕳️ Hollow Shims & Stubs: Hardcoded returns, dead TODOs, and monolithic files
- 🌪️ Unbounded Workspace Drift: Direct trunk edits and cross-layer boundary leaks
▼ Context Collapse
THE NOMOS HARNESS
Peace of Mind for Any Agent
Sustainable 10x
- 🛡️ Keep your favorite agent: Claude Code, Cursor, Antigravity, OpenCode, Windsurf
- ⚡ AST Complexity Ceiling: Enforces cyclomatic complexity <= 15 & file LOC <= 400
- 📦 Hermetic Worktrees: Physically read-only trunk prevents workspace drift
- ✅ 42 DoD Gates: Non-verbal AST proof blocks shims & reward hacking
▲ Deterministic Reality
A NEW LAYER IN THE ENGINEERING STACK We Don't Replace Your Coding Agents.
We Don't Replace Your Coding Agents.
We Govern Their Reality.
Nomos introduces the missing transactional runtime for both architectural intent (INT-*) and compiled code (SUB-*) - locking specs against reward-hacking, isolating edits in transient worktrees, and verifying every diff across 42 AST quality gates.
ZERO-PLUGIN SUPPORT
AntigravityClaude CodeCursorWindsurfOpenCodeAider
Built for Adversarial Agent Shortcuts.
Linters check syntax for honest humans after edits dirty a branch. Nomos blocks optimizing agents from deleting failing assertions, returning hollow stubs, weakening nomos.yaml, or rewriting specs to excuse broken code.
Compiled Exit Codes Over Polite Prose.
Markdown rules decay once context crosses 60%. Nomos enforces compiled Go, Git hook, and AST exit codes (exit 1) outside the model context window, promoting mneme.db lessons strictly after a verified 2PC receipt.
01 · HERMETIC SANDBOXING
Stay at Repo Root. Edits Run Isolated.
Guide your coding agent in plain natural language from the root of your repository with zero
custom slash commands. Underneath, Nomos routes every file edit into a transient worktree
(worktrees/<repo>-<task>).
- ✓ Protected trunk branch - Direct commits to
mainfail closed automatically. - ✓ Deterministic task lifecycle - Explicit
PLAN -> EDIT -> REVIEW -> SYNCphases. - ✓ 42 AST quality gates - Compiled Go & Tree-sitter checks before merge.
02 · 60-SECOND DROP-IN
One Go Binary. Zero Repo Migration.
Runs locally alongside your existing Git workflow, package managers, and CI pipelines with zero code refactors, zero framework lock-in, and zero telemetry leakage.
$ curl -fsSL https://sophialabs.ca/install | sh
$ nomos init
✓ AGENTS.md, SessionStart hooks & 42 AST gates armed
› "Add CapBAC token validation to auth middleware"
✓ Isolated in worktrees/repo-SUB-42 (main protected)
FIRST-PARTY PAIRED BENCHMARK · TRACETRIAL-BENCH (ARXIV:2610.32285) Tested on Top of the #1 Agent Harness.
Tested on Top of the #1 Agent Harness.
Zero Model Weight Changes.
Across 190 isolated Docker containers holding Claude Code v2.1.220 and Gemini 2.5 Flash-Lite fixed across all 95 tasks (0 errors), inserting
compiled nomos hook governance beat stock Claude Code on both axes (44.89 -> 48.78 Overall, 36W / 30T / 29L).
+15.2%
Agent Deliverables
34.78 -> 40.05 across n = 95 tasks
+42.8%
Context & Continuity
43.55 -> 62.16 (+78.3% Agent lift)
-18.2%
Harness-Caused Failures
55 -> 45 causal failure attributions
~4 ms
Compiled Go Hook Overhead
Static CGO_ENABLED=0 binary
VERIFIED HOOK MECHANICS · NOMOS V4.2.0
Three Systems Lessons from 190 Paired Containers
In the benchmark authors' published public leaderboard (tracelite.ai ↗), Claude Code ranks #1 overall while frontier models burn extra retries masking
harness faults. Locking stock Claude Code v2.1.220 + Gemini 2.5 Flash-Lite isolated three concrete harness invariants:
- 01 Additive Hook Chaining +10.39 Observability
Merging
nomos hookinto$CLAUDE_CONFIG_DIR/settings.jsonpreserves workspace-local.claude/settings.jsonplugins instead of shadowing them via--settings. - 02 Silence on Allow -39.3% Ablation Proof
Injecting synthetic coaching prose into
PostToolUsemasked POSIXEACCESerrors; emitting{}on allow and firing only on real AST, JSON, and JSONL errors restored full channel fidelity. - 03 Path Hygiene & Loop Breakers +78.3% Context Agent
Blocking unexpanded
$WORKSPACEand~paths on read & write tools plus a poll-safe 3-strike identical-failure breaker eliminated 200+ turn thrash loops.
CLOSED-LOOP REPOSITORY GOVERNANCE
How Nomos Governs Every Task End-to-End
From a plain-language prompt to an atomic fast-forward merge: your coding agent works inside
an isolated Git worktree while the Go binary enforces 42 sub-400ms AST gates before anything
touches main.
EXPLORE THE ECOSYSTEM
Deep-Dive Technical Platforms & Governance
Everything you need to govern coding agents, from local compiled Go AST rails to air-gapped enterprise nodes.
SPECIFICATION & PROOF
Dual-Core Architecture
Explore the architectural separation between Intent and Substrate, backed by 42 Definition of Done AST quality gates and transient worktree sandboxing.
Explore Architecture & Gates ➔SOLO, TEAM & REGULATED
Adoption Profiles
Start locally with the Apache 2.0 Open-Core Go binary on any developer workstation or CI pipeline, and expand to multi-seat governance and regulated air-gapped nodes.
Compare Adoption Profiles ➔LITERATURE & RUNBOOKS
The Engineering Handbook
Read first-principles essays on inverted control flow, AST gatekeeping, cognitive co-processors, and why stochastic prompt guardrails fail in production codebases.
Read Handbook Chapters ➔36 FORMAL CONTRACTS
Architecture Specifications
Inspect all 36 formal Go, CUE, and state-machine engineering specifications governing AST quality gates, hermetic worktrees, and indirect agent control.
Browse Architecture Specs ➔ NEXT ON THE WORKBENCH // SOVEREIGN PREVIEW
Transactional for Intent & Code. Built for the 70/30 Local Split.
nomos Open-Core (Apache 2.0) stays 100% local and uncrippled beneath the coding agent you already use. Next from the SophiaLabs lab: nomos code and Nomos Cockpit - built so you steer frontier models on the hard 70% of architecture while a local GPU clears the mechanical 30% unattended inside disposable worktrees.
70% FRONTIER STEERED · Architecture, Concurrency & Multi-File Design (Claude / Cursor / AGY-IDE) 30% $0 LOCAL AUTONOMY · Leaf Chores, Test Ratchets & AST Debt (16GB+ Local GPU)
ACID Specs Before Code
Intent is not an ephemeral chat prompt. Specs, CUE contracts, and acceptance criteria land as audited INT-* transactions that causally unlock SUB-* code worktrees - so agents can never rewrite your spec to excuse broken code.
Safe $0 Local Autonomy
Raw local MoE models are too noisy to trust directly on main. Caging nomos code inside disposable git worktree sandboxes and 42 AST sensor probes makes unattended local burndown safe: bad runs evaporate at $0 token cost.
Visual DAG & Worktree Radar
Inspect your live INT/SUB causal wavefront, parallel agent worktrees, 7x3 gate receipts, local GPU routing, and unpoisoned mneme.db memory from a single local control plane.
NOVEMBER 1 LAUNCH // OPEN CORE SUBSTRATE
Architectural Adoption Profiles
Pure open-core developer sovereignty at the baseline. Dedicated sovereign meshes and air-gapped appliances for defense and regulated engineering teams.
✦ OPEN CORE · APACHE 2.0
Open Core Developer Standard
Nomos Community
$0 Free
Permanent Open Core
For individual senior developers and open-source contributors seeking deterministic AST gates, transient worktree sandboxes, and physical machine-verified Definition of Done.
- Zero-LLM Deterministic CLI: Compiled Go binary with sub-100ms AST validation passes.
- 42 AST Quality Gates: Machine-enforces cyclomatic complexity (< 15), docstrings, and import boundaries.
- Transient Git Worktrees: Sandboxed execution (
worktrees/<repo>-<task>) isolates AI mutations. - Fractal State Machine: Procedurally locks mutations outside of strict
EDITphases. - BYO-Agent Coexistence: Drops underneath Claude Code, Cursor, OpenCode, and Aider seamlessly.
Independent Engineers
Sovereign Developer
Commercial
Single-Seat Developer
Autonomous Tier 2 burndown & telemetry
For independent tech leads, consultants, and senior engineers who need autonomous background agent burndown, 3D WebGL Cockpit telemetry, and subconscious vector recall.
- Everything in Nomos Community
- Tier 2 Nomos Code Fleet: Autonomous background agent running inside transient worktrees.
- 3D WebGL Flight Cockpit HUD: Real-time task radar, AST gate visualizer, and live state monitoring.
- Subconscious Memory Vectors: Nomos Mneme local embeddings cache for instantaneous code recall.
- Adversarial Critic Attestation: Automated red-team spec and diff review receipts.
Coordinated Swarms
Sovereign Squad Mesh
Squad Mesh
5–15 Seat Engineering Fleet
Coordinated autonomous swarms
For 5–15 developer engineering squads modernizing codebases with coordinated autonomous swarms, shared team memory, and multi-repo orchestration.
- Everything in Sovereign Developer
- Shared Nomos Mneme Memory Mesh: Subconscious vector embeddings and notes synchronized across the squad.
- Multi-Seat Fleet Cockpit: Centralized dashboard for sprint velocity, friction heatmaps, and debt audits.
- Cross-Repo Task Orchestration: Coordinated multi-worktree execution across frontend, substrate, and daemons.
Defense & Enterprise
Air-Gapped & Regulated
Turnkey Node
On-Prem Air-Gapped Appliance
Zero egress • 100% sovereign
For security-conscious enterprises and defense contractors requiring 100% air-gapped sovereign execution, custom AST compliance rules, and dedicated hardware appliances.
- Turnkey NixOS GPU Appliances: Pre-configured air-gapped hardware nodes running isolated sovereign swarms.
- Zero Egress & Model Privacy: Guaranteed zero data exfiltration, zero model training, on-prem clusters.
- Custom AST Compliance Gates: Tailored linters, proprietary security invariants, and custom DoD gate engines.
- Dedicated Architecture Advisory & 24/7 SLA: Direct access to senior systems architects for modernization sprints.
Detailed Edition & Gate Comparison Matrix
| Architectural Capability | Community (Free & Open Core) | Sovereign Developer | Sovereign Squad Mesh | Air-Gapped & Regulated |
|---|---|---|---|---|
| Deterministic Substrate Rails & Quality Gates | ||||
| Zero-LLM Compiled Go Engine | ✓ Sub-100ms | ✓ Sub-100ms | ✓ Sub-100ms | ✓ Sub-100ms |
| 42 Binary AST Definition of Done (DoD) Gates | ✓ All 42 Gates | ✓ Full Array | ✓ Full Array | ✓ Bespoke + Custom |
| Transient Git Worktree Sandboxing | ✓ Isolated | ✓ Isolated | ✓ Multi-Repo Mesh | ✓ Multi-Repo Cluster |
| 6-Phase State Machine (IDLE → LEARN) | ✓ Cryptographic | ✓ Cryptographic | ✓ Cryptographic | ✓ Cryptographic + Audit |
| Cognitive Escalation & Token Economics | ||||
| Local SLM Inference (Ollama / vLLM / llama.cpp) | Unlimited ($0 COGS) | Unlimited ($0 COGS) | Unlimited ($0 COGS) | Hardware Accelerated |
| Inference & Model Routing | Local SLM ($0 COGS) + BYOK | Local SLM + BYOK + Cockpit | Local SLM + BYOK + Squad Mesh | Turnkey NixOS GPU Hardware |
| Seamless BYOK Fallback (Gemini / Anthropic / OpenAI) | ✓ Supported | ✓ Automated | ✓ Automated | ✓ Private VPC Endpoints |
| Tier 2 Nomos Code Autonomous Fleet Burndown | — | ✓ Single Host | ✓ Parallel Swarm | ✓ Distributed Cluster |
| Cockpit Telemetry & Subconscious Memory | ||||
| Terminal ANSI Substrate HUD | ✓ Full CLI HUD | ✓ Full CLI HUD | ✓ Full CLI HUD | ✓ Full CLI HUD |
| Real-time WebGL 3D Cockpit HUD | — | ✓ Individual Seat | ✓ Squad Telemetry | ✓ Enterprise Fleet HUD |
| Nomos Mneme Semantic Memory | ✓ Local SQLite (mneme.db) | Vector Cache | Synchronized Mesh | On-Prem Distributed |
| Trial & Support Infrastructure | ||||
| Licensing & Delivery Model | Apache 2.0 (Forever Free) | Commercial Seat | Commercial Squad Mesh | Turnkey Hardware Appliance |
| Turnkey Hardware Appliances | — | — | Optional Add-On | ✓ Turnkey NixOS Box |
| Support & Engineering Retainer | Community GitHub | Priority Email & Discord | Dedicated Slack Channel | 24/7 SLA + Advisory |
THE DEVELOPER COEXISTENCE & ARCHITECTURAL FAQ
Frequently Asked Questions
Grounded answers on Tier 1 agent compatibility, local inference economics, open-core licensing, and air-gapped execution.
Does Nomos replace my favorite coding agents like Claude Code, Cursor, or OpenCode?
No. Nomos is not another chat window, IDE fork, or LLM wrapper. Nomos is a compiled Go binary that operates as the Deterministic Engineering Substrate underneath whatever coding tool you already use.
While Claude Code, Cursor, or OpenCode generate probabilistic candidate edits as cognitive co-processors, Nomos intercepts and sandboxes every change inside transient Git worktrees, runs 42 deterministic AST quality gates (< 15 complexity, docstring density, clean imports), and prevents broken code from polluting your trunk branch. You get 10x velocity without the Day 7 "AI complexity spiral".
How does inference work and what are the host costs?
Nomos has zero markups and zero token resale. SophiaLabs does not operate a paid cloud token proxy; you are never locked into an LLM middleman.
In typical workflows, 100% of your tasks run locally for $0 COGS on local SLMs (such as Gemma 4 26B, Qwen 2.5 Coder, or DeepSeek via Ollama / vLLM on Apple Silicon or NVIDIA RTX). When you require frontier reasoning (Claude 3.7 Sonnet, Gemini 2.5 Pro, OpenAI o3), your Tier 1 agent routes directly via your own Bring-Your-Own-Key (BYOK) environment variables while Nomos governs the repository boundaries via declarative configuration (nomos.yaml).
What is the difference between open-core Nomos Community and Sovereign editions?
Nomos Community is 100% free and open-source under the Apache 2.0 license. It gives solo developers the full compiled Go CLI substrate: transient worktree sandboxing, 42 AST Definition of Done quality gates, and local deterministic state machines.
Sovereign Editions (Developer, Squad Mesh, Air-Gapped) are commercial solutions for teams requiring synchronized team memory meshes, multi-seat telemetry, automated background burndown agents (nomos code), and turnkey on-premise NixOS hardware appliances.
Can our engineering team run 100% air-gapped without internet access?
Yes. Nomos was built from first principles for sovereign, offline engineering.
The Go binary has zero external runtime phone-homes and zero telemetry tracking. In air-gapped defense or regulated enterprise environments, inference runs entirely against on-premise GPU clusters (vLLM / Ollama). No source code, embeddings, or metadata ever leave your physical network perimeter.
How do I install and start using Nomos?
Installation is a single shell command from the canonical GitHub repository:
curl -fsSL https://sophialabs.ca/install | shZero credit card, zero account registration, and zero cloud lock-in. You immediately get the compiled Go binary in your PATH, run nomos init once in any Git repository, and prompt your coding agent in plain English with zero custom slash commands.
Does Nomos require changing my existing Git workflow or repo structure?
No. Nomos is 100% non-invasive. You do not need to restructure your codebase, adopt monorepo tooling, or rewrite existing CI/CD pipelines.
Nomos attaches to any standard Git repository. When you start a task, Nomos provisions a transient worktree (worktrees/<repo>-<task>) to isolate AI-generated edits. Your trunk branch (main) remains protected. Once edits pass the 42 AST gates, Nomos executes an atomic two-phase commit (2PC) to sync verified changes directly into your active branch and prunes the worktree cleanly.
Featured Engineering Reads
Deep architectural essays extracted from our private Cognitive Agent Engineering Handbook.
The Physics of Software: Why Code Is Dynamic Machinery, Not Paint on Canvas
The seductive metaphor of coding as 'creative direction' conflates zero-friction generation with zero-friction verification. Software is not static paint on canvas; it is dynamic machinery under load. When generation cost drops to zero, the engineer's true role transforms into Chief Structural Inspector.
Read full chapter →
Why Vibe Coding Dies: The Failure Modes of Stochastic Orchestration
Vibe coding is not a methodology. It is an ungoverned control loop. At repository scale it fails through context thrashing, silent regressions, and the code-janitor trap—because correctness was left inside a model that cannot return exit code 1.
Read full chapter →
Cognitive Inversion: The Engine Owns the Loop
The compiled kernel owns the lifecycle, the scheduler, and the capability budgets. The LLM is a bounded stochastic ALU: called, metered, and discarded. Inverted control flow is the only topology that survives multi-turn engineering.
Read full chapter →
The Execution Substrate: Worktrees, Gates, and Two-Phase Commit
Agent execution is a concurrency problem. Nomos isolates work in ephemeral git worktrees, forbids trunk mutation via pre-commit locks, and publishes only through Two-Phase Commit with Ed25519-signed receipts on refs/notes/nomos/releases.
Read full chapter →
Non-Verbal Proof: AST Invariants, Green Traces, and Exit Code 1
We never ask an LLM if code is correct. Correctness is a compiled predicate: Go AST invariants, hermetic import graphs, cyclomatic ceilings, docstring density, and a 100% green test trace. Failure is exit code 1. There is no negotiation.
Read full chapter →
The Dual-Core Architecture: Hermetic Domain Isolation & Supply-Chain Provenance
Autonomous agents fail in flat repositories because they invent cross-layer edges. Nomos partitions engineering into the Dual-Core Architecture—the Intent Plane and the Substrate Plane—and enforces those boundaries with worktree isolation, SHA-256 SSoT byte parity, and cryptographic supply-chain provenance.
Read full chapter →
Operating Autonomous Agent Swarms
Tier-1 orchestrators plan and sign; Tier-2 swarms mutate sandboxed worktrees under CapBAC and AST gates. The Go runtime owns the lifecycle. Failure is mechanical: runaway loops, budget exhaustion, worktree leaks, context contamination. This chapter is the runbook.
Read full chapter →
Inference Economics & The Velocity Dynamics
Inference cost is a control-flow problem. Prompt-heavy agents tax every turn with full-window reloads and unguided retries. Nomos treats the LLM as a budgeted subroutine: JIT state slicing, CapBAC accounting, AST-gated velocity over 90 days, and Nomos Mneme distillation of verified commits into retrievable memory.
Read full chapter →
The Invariant Card & Technical Glossary
The seven non-negotiable laws of autonomous engineering, followed by a five-layer lexicon—Axioms, Invariants, Gates, Capabilities, Receipts—that maps every Nomos term to its enforcement surface.
Read full chapter →
The Seven Laws of Deterministic Engineering
The first-principles deterministic and architectural derivation of the Seven Laws of Nomos, the Five-Layer Ontological Stack, and the 7x3 Canonical Gate Matrix governing autonomous software engineering.
Read full chapter →
The Deterministic Manifesto: Why Software Is Only the First Crucible
Software is not the destination; it is the crucible. The deterministic control harness proven in Nomos establishes the foundational cybernetic architecture for governing autonomous probabilistic agents across silicon, kinetic robotics, and physical reality.
Read full chapter →
The Agent-Steering Protocol & NCTE-100 Lexicon: Speaking Physics to Probabilistic Agents
Transactional code worktrees and declarative intent schemas are only two axes of deterministic software engineering. The third axis is the Cybernetic Agent-Steering Protocol - how the compiled Go substrate and human architect steer Tier 1 coding agents through HATEOAS CLI affordances, self-healing remedies, sub-5ms ambient hooks, and the 36-term NCTE-100 Succinct Action Lexicon.
Read full chapter →