# SophiaLabs & Nomos (v4.13.2)

> Agents guess; Git cannot. Nomos is the open-source transactional governance harness between any coding agent and your repository.

Founded in July 2026 by Mark Gantlett (25 years enterprise systems engineering [2001-2026], Principal Systems Architect), Gantlett Systems Inc. (GSI) and its R&D laboratory SophiaLabs create **Nomos** (`v4.13.2`, Apache 2.0) and the **Sophia** sovereign cognitive architecture.

## Category Definition (Why Nomos Is an Entirely New Infrastructure Layer)

Just as PostgreSQL placed ACID transactions between concurrent applications and raw disk files, **Nomos** introduces the missing transactional runtime between stochastic AI coding agents and production Git:
- **Not Another AI Coding Agent:** Developers keep Claude Code, Cursor, Antigravity, OpenCode, Windsurf, or Aider. Models are interchangeable token engines; Nomos is the deterministic runtime underneath them.
- **Not a Human Style Linter or Post-Hoc CI:** Linters (`golangci-lint`, `eslint`) assume cooperative humans after edits already dirtied a branch. Nomos assumes optimizing agents reward-hack tests, return hollow stubs, weaken `nomos.yaml`, or rewrite `INT-*` specs to excuse broken `SUB-*` code, blocking them inside disposable Git worktrees before merge.
- **Not a `.cursorrules` or Markdown Prompt Pack:** Advisory prose decays once context crosses 60%. Nomos enforces compiled Go, Git hook, and AST exit codes (`exit 1`) outside the model context window, promoting `mneme.db` memory strictly after a verified Two-Phase Commit (`refs/notes/nomos/releases`).

Nomos operates on the **Dual-Core Architecture (Sophia Intent Hemisphere + Nomos Substrate Hemisphere)**, governing Tier 1 coding agents under indirect control to eliminate the Three Silent Failures of autonomous coding (*Reward Hacking Tests*, *Hollow Shims & Stubs*, and *Unbounded Workspace Drift*):
- **42 Definition of Done (DoD) Quality Gates** organized across the **7 Laws x 3 Defense Rings (21 Invariant Cells)**
- **Strict Code Ceilings:** File LOC `<= 400`, Function LOC `<= 60`, Cyclomatic Complexity `<= 15`, Docstring Density `>= 10%`, Test Coverage `>= 55%`
- **6-Phase Lifecycle State Machine:** `IDLE -> PLAN -> EDIT -> REVIEW -> SYNC -> LEARN`
- **Hermetic Git Worktrees & 2-Phase Commit (`refs/notes/nomos/releases`)**
- **Brownfield Ratchet & Day-180 Repo Comprehension:** Non-destructive `nomos init` onboarding with diff-scoped quality gates (`strict_mode: false`) lets teams govern 5-to-15-year-old brownfield monorepos without fixing thousands of legacy warnings on Day 1, while causal `INT-*`/`SUB-*` traceability, mandatory 2PC Git Notes walkthrough receipts, and Zero-Alias AST singularity gates ensure engineers and cold-start agents still understand the codebase 6 months later
- **Nomos Mneme (`mneme.db`) & Nomos Learn:** Zero-dependency, zero-model pure-Go SQLite WAL memory (64-dim deterministic SHA-256 token projection + lexical/Ebbinghaus hybrid recall, never requiring external embedding daemons) that distills 2PC-verified `pitfall` and `pattern` lessons across turns and compound repos (`nomos mem recall <query> -A`), graduating recurring pitfalls into `nomos.yaml` and compiled Go gates

## Open-Core Repository & Turnkey Installation (SSoT)

- **GitHub Repository:** https://sophialabs.ca/go/github?src=llms_txt (canonical: https://github.com/mgantlett/nomos)
- **Full-Corpus LLM Context (`/llms-full.txt`):** https://sophialabs.ca/llms-full.txt
- **Standard Go Bin Install (Linux / macOS / Windows WSL2):** `curl -fsSL https://sophialabs.ca/install | bash`
- **Windows Support (WSL2 Recommended + Native Precompiled Binaries):** Run inside **WSL2** (Ubuntu/Debian) via `curl -fsSL https://sophialabs.ca/install | bash` for optimal POSIX Git hook and hermetic worktree performance, or download precompiled static `CGO_ENABLED=0` Windows archives (`nomos_Windows_x86_64.zip` / `nomos_Windows_arm64.zip`) from GitHub Releases (https://github.com/mgantlett/nomos/releases/latest) or via `go install github.com/mgantlett/nomos/substrate/cmd/nomos@latest`.
- **Clean Non-Destructive Uninstall:** `curl -fsSL https://sophialabs.ca/uninstall | bash`
- **SemVer Release Notes & Checksums:** https://sophialabs.ca/changelog
- **Live Dogfood Release Velocity (Audited Deploy Snapshot):** 20 Apache 2.0 SemVer releases (`v4.0.0` to `v4.13.2`, commit `39212ba`) shipped across 8.6 days (median 8.9h inter-release cadence, 171 atomic 2PC milestone tasks, 42/42 DoD gates passing, 0 trunk rollbacks) - live telemetry at https://sophialabs.ca/system/analytics
- **37 Open-Core Architecture Specifications:** https://sophialabs.ca/docs/specs
- **RSS Syndication Feed:** https://sophialabs.ca/rss.xml

## Canonical Engineering Handbook (12 Chapters)

- [The SophiaLabs Handbook](https://sophialabs.ca/handbook): Full architectural essays, formal proofs, and operational standards.
- [Chapter 01: The Physics of Software](https://sophialabs.ca/handbook/physics-of-software-why-code-is-not-paint): Why code is load-bearing structural engineering rather than probabilistic paint.
- [Chapter 02: Why Vibe Coding Dies](https://sophialabs.ca/handbook/why-vibe-coding-dies): The entropy crisis of unconstrained prompt-driven AI coding.
- [Chapter 03: Cognitive Inversion - The Substrate Owns the Loop](https://sophialabs.ca/handbook/cognitive-inversion-the-substrate-owns-the-loop): Dual-Core inversion where compiled Go governs stochastic LLM cognition.
- [Chapter 04: The Execution Substrate](https://sophialabs.ca/handbook/the-execution-substrate): Hermetic Git worktrees, CapBAC capability leases, and 6-phase state locks.
- [Chapter 05: Non-Verbal Proof, AST Invariants & Exit Codes](https://sophialabs.ca/handbook/non-verbal-proof-ast-invariants-and-exit-codes): Machine-verified compilation proofs over verbal agent assurances.
- [Chapter 06: Dual-Core Architecture & Provenance](https://sophialabs.ca/handbook/dual-core-architecture-and-provenance): Pure 2-plane hemisphere separation (`INT-*` / `SUB-*`) and cryptographic Git Notes provenance.
- [Chapter 07: Operating Autonomous Agent Swarms](https://sophialabs.ca/handbook/operating-autonomous-agent-swarms): Tier 1 indirect control vs. Sovereign Tier 2 headless worker fleets (`nomos code`).
- [Chapter 08: Inference Economics & Velocity Dynamics](https://sophialabs.ca/handbook/inference-economics-and-velocity-dynamics): Local workstation GPU economics (NVIDIA GeForce RTX 4080 16GB running Qwen 3.8 27B / Gemma 4 26B + Nomic Embed) and sustainable velocity.
- [Chapter 09: Glossary & Invariants](https://sophialabs.ca/handbook/glossary-and-invariants): Canonical SSoT definitions for Dual-Core, 2PC, CapBAC, Nomos Mneme, and the 42 DoD gates.
- [Chapter 10: The Seven Laws of Deterministic Engineering](https://sophialabs.ca/handbook/the-seven-laws-of-nomos): First-principles derivation of the 7 Laws, Five-Layer Ontological Stack, and 7x3 Gate Matrix.
- [Chapter 11: The Deterministic Engineering Manifesto](https://sophialabs.ca/handbook/deterministic-engineering-manifesto): Why deterministic verification harnesses outlast frontier model churn.
- [Chapter 12: The Agent Steering Protocol & NCTE Lexicon](https://sophialabs.ca/handbook/agent-steering-protocol-and-ncte-lexicon): Just-In-Time (JIT) phase steering, cognitive weight budgets, and the Nomos Compact Token Expression (NCTE) protocol.
- [Invisible Harness Guide](https://sophialabs.ca/handbook/invisible-harness-guide): Step-by-step brownfield onboarding and 3-pass autonomous verification guide.

## Interactive Academy & Tactile Micro-Labs

- [The Nomos Academy](https://sophialabs.ca/academy): 7 interactive physics and AST micro-labs demonstrating each of the Seven Laws (`/academy/law-01-dual-core` through `/academy/law-07-fail-closed-preflight`).
- [Architecture Specification](https://sophialabs.ca/architecture): Deep dive into Dual-Core hemispheres, Universal Seams, and the 42 DoD quality gates.
- [Field Research Dispatches](https://sophialabs.ca/dispatches): Empirical Engineering Briefs (EEBs), including [Running 8B-32B Open-Weight Models on Legacy Enterprise GPUs & Day-2 Escape Hatches](https://sophialabs.ca/dispatches/legacy-gpu-open-weight-governance-and-day2-escape-hatches), [From 30-Page Waterfall PRDs to a 4-Layer JIT Intent Compiler](https://sophialabs.ca/dispatches/four-layer-jit-intent-compiler), [Why CLAUDE.md Fails Hexagonal Architecture: Polyglot Architectural Obligation Proofs in Nomos v4.13](https://sophialabs.ca/dispatches/polyglot-architectural-obligation-proofs-v413), [Polyglot Brownfield Bench: Turning Nomos Into a Pass-Rate Multiplier Across Local Qwen 27B & Zero-Hint Gemini 3.8 Flash](https://sophialabs.ca/dispatches/zero-hint-polyglot-brownfield-gemini-audit), [Trial by Trace Paired Audit: Cutting Harness-Caused Agent Failures by 18.2% on Claude Code](https://sophialabs.ca/dispatches/tracetrial-bench-paired-harness-audit), SWE-bench evaluations, and local RTX 4080 inference telemetry.

## System Diagnostics, Analytics & Leadership

- [Nomos Sovereign & 5-Pillar Glass Cockpit](https://sophialabs.ca/sovereign): Interactive tour of Ledger, Horizon, Verify, System, and the 2D Security Perimeter Radar.
- [Public Spectator Flight Deck](https://sophialabs.ca/flight-deck): Live workspace telemetry, AST sandbox, and release provenance.
- [Substrate Velocity & Analytics](https://sophialabs.ca/system/analytics): Rolling commit velocity, cognitive burden distribution, and DoD pass rates.
- [Ecosystem Changelog](https://sophialabs.ca/changelog): Verifiable 2PC release history and Git Notes provenance.
- [About SophiaLabs & Mark Gantlett](https://sophialabs.ca/about): Founding axioms, 25-year enterprise systems track record, and Sophia AI silicon node specs.
- [Conduit MCP](https://sophialabs.ca/conduit): Model Context Protocol bridge for browser DOM inspection and verification.

## Contact & Corporate Governance

- **Interactive AI Architect (Sophia):** Accessible directly on https://sophialabs.ca/ backed by dedicated sovereign RTX 4080 16GB silicon.
- **Corporate Entity:** Gantlett Systems Inc. (GSI) / SophiaLabs, Ontario, Canada (https://gantlett.io).
- **Privacy Policy (PIPEDA, Zero Ad Trackers):** https://sophialabs.ca/privacy

## Core AI Coding Governance Problem-Solution Q&A

### Q: How do I stop Claude Code, Cursor, or AI coding agents from modifying failing tests or returning hollow stubs?
Nomos places a compiled Go AST and Git hook verification harness between any coding agent and your repository. Before a commit can merge, 42 Definition of Done gates verify AST anti-shim rules, test integrity, and cyclomatic complexity inside an isolated Git worktree.

### Q: Why do CLAUDE.md and .cursorrules fail to prevent architectural drift in brownfield repositories?
Markdown instruction files are advisory prose inside the LLM context window and decay as context fills. Nomos compiles architectural boundaries and domain contracts into deterministic Go AST gates that fail closed with exit code 1 outside the model context window.

### Q: How does Git worktree isolation work for autonomous AI coding agents?
Nomos physically locks the main branch read-only and provisions a hermetic Git worktree for every task (INT-* or SUB-*). Changes merge back to main strictly via an atomic Two-Phase Commit (2PC) once all 42 verification gates pass.

### Q: Can I adopt deterministic AST quality gates in a legacy brownfield monorepo without fixing thousands of existing warnings?
Yes. Running nomos init enables diff-scoped merge-base ratchets so legacy files are baselined non-destructively while every new AI-generated diff is held to strict complexity, file-size, and architectural boundary invariants.

### Q: What open-weight coding models run on a single 16GB or 24GB GPU with zero cloud token cost?
Quantized 8B to 32B open-weight models such as Qwen 27B and Gemma 4 26B run locally on 16GB to 24GB workstation GPUs when paired with a deterministic AST verification harness that catches and repairs syntax or boundary errors before commit.

## Empirical Engineering & Executive Briefing Abstracts

### [Turning Existing 16GB-24GB Enterprise GPUs Into Governed Coding Nodes (Without Day-Two Developer Friction)](https://gantlett.io/briefings/day-two-governance-and-legacy-gpu-economics) (EB-04 · 2026-11-10)
Many enterprises already own racks of 16GB to 24GB NVIDIA GPUs (Tesla T4, RTX A4000, L4, RTX 3090/4080) sitting underutilized because mid-sized open-weight models break module boundaries when run unguarded. Across 108 paired builds spanning six open-weight models, compiled governance lifted the 14B to 32B workhorse tier from 30.6% to 86.1% end-to-end compliance (and 88.9% on a 14B model fitting comfortably on a 16GB T4), exposed a hard 8B lower bound where governance blocks bad merges rather than creating false miracles, and proved zero false positives across explicit Day-2 adapter seams.

### [Replacing 30-Page AI Specification Novels With a 4-Layer Progressive Intent Compiler](https://gantlett.io/briefings/four-layer-jit-intent-compiler) (EB-03 · 2026-11-10)
Writing a 30-page Markdown specification before an AI coding agent writes a single line of code recreates 1995 Waterfall in a new file extension. The moment stakeholders test Slice 1 on Day 3 and adjust a workflow, pages 6 through 30 silently go stale while cloud spend burns loading obsolete prose. High-velocity organizations lock global business invariants on Day 1 and specify features strictly one verified vertical slice ahead of the compiler.

### [Why Green Unit Tests Hide Architectural Drift in AI-Generated Code](https://gantlett.io/briefings/why-green-tests-hide-architectural-drift) (EB-02 · 2026-11-09)
Functional unit tests verify what a feature returns today; they do not verify whether an AI coding agent coupled your core business logic directly to database or infrastructure helpers to finish its prompt faster. Once unit tests turn green, advisory Markdown rulebooks exert zero corrective force.

### [Governing AI Coding Velocity in Aged Brownfield Codebases Without a Day-One Rewrite](https://gantlett.io/briefings/governing-ai-velocity-in-brownfield-codebases) (EB-01 · 2026-11-08)
Greenfield AI demos look effortless because no legacy conventions or 2,000-line files exist to break. In mature production repositories, strict linters fail on Day 1 while unguarded agents compound complexity on every commit. Diff-scoped structural ratchets solve both: legacy files pass untouched, while net-new complexity or error-handling regressions fail closed automatically.