# Gantlett Systems Inc. (GSI) > Models generate code; control systems make it production-grade. Deterministic Agent Control Systems, Anti-Reward-Hacking AST Rails, and Air-Gapped Sovereign GPU Infrastructure. Gantlett Systems Inc. (GSI, https://gantlett.io) is the commercial systems architecture and sovereign AI infrastructure practice founded and led directly by Principal Systems Architect Mark Gantlett (25 years enterprise systems engineering [2001-2026], Federal & Ontario Corporation, Canada). ## Category Definition (Deterministic Agent Control Systems) Every AI vendor builds a faster code-generation engine while leaving production `main` branches unguarded. GSI installs a dedicated **Transactional Agent Control Layer (`Nomos`)** beneath enterprise engineering teams (5 to 100+ developers) - distinct from AI coding agents, human style linters, and advisory prompt files - cutting cloud retry spend by 80%+, governing aged brownfield repositories via diff-scoped AST ratchets + 6-month Git Notes/`mneme.db` provenance without a Day-1 rewrite, and deploying air-gapped local SLM execution. ## Core Institutional Engagements (https://gantlett.io/#pillars) 1. **14-Day AI Governance & Seam Charter Pilot (https://gantlett.io/seam-pilot):** Fixed-scope discretionary pilot ($15,000 - $25,000 USD) isolating one high-friction module seam in read-only `main`, Golden Master characterization tests, custom compiled AST & domain unit-lock sensor probes, and cryptographic Git Notes audit receipts. 2. **Air-Gapped Sovereign AI & Turnkey Hardware Appliances:** Private VPC, on-premise bare metal, or pre-configured NixOS + Nomos Sovereign local GPU appliances delivering 70%+ $0 local SLM resolution with zero external code exfiltration. 3. **Nomos Sovereign Platform & Multi-Agent Execution:** Commercial licensing and deployment of the Sovereign Tier 2 coding engine (`nomos code`), orthogonal adversarial critics, and Nomos Cockpit DAG control plane. ## Executive Architecture Briefings (https://gantlett.io/briefings) - **Full-Corpus Executive Context (`/llms-full.txt`):** https://gantlett.io/llms-full.txt - **Executive RSS Syndication Feed (`/rss.xml`):** https://gantlett.io/rss.xml Three-minute executive memos for CTOs, VPs of Engineering, and Risk Guardians: - [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): 108-episode multi-lab audit across 8B-32B open-weight models plus Day-2 architectural escape hatches so teams handle legitimate exceptions without disabling governance. - [Replacing 30-Page AI Specification Novels With a 4-Layer Progressive Intent Compiler](https://gantlett.io/briefings/four-layer-jit-intent-compiler): Why giant upfront Markdown specs recreate 1995 Waterfall on Day 3, and how progressive lowering across a 2-page North Star Charter, compiled boundaries, and 1-page JIT slice specs ships verified software immediately. - [Why Green Unit Tests Hide Architectural Drift in AI-Generated Code](https://gantlett.io/briefings/why-green-tests-hide-architectural-drift): Controlled Python, TypeScript, and Go audit showing why Markdown rulebooks (`CLAUDE.md`) and green tests leak forbidden cross-layer imports (0/3 purity) and how compiled boundaries enforce 100% compliance. - [Governing AI Velocity in Aged Brownfield Codebases Without a Day-One Rewrite](https://gantlett.io/briefings/governing-ai-velocity-in-brownfield-codebases): How diff-scoped merge-base ratchets cut senior PR review queues and cloud retry burn across 233k+ LOC repositories. ## Open-Core R&D Laboratory (SophiaLabs) All public engineering research, documentation, handbook chapters, benchmarks, and the Apache 2.0 `nomos` Open-Core CLI live canonically on GSI's R&D division portal: - **SophiaLabs R&D Portal:** https://sophialabs.ca - **Nomos Open-Core GitHub:** https://github.com/mgantlett/nomos - **Engineering Handbook (12 Chapters):** https://sophialabs.ca/handbook - **Open-Core Architecture Specifications (37):** https://sophialabs.ca/docs/specs - **Empirical Dispatches & Benchmarks:** https://sophialabs.ca/dispatches ## Executive Inquiries & Contact - **Institutional Engagement Queue:** https://gantlett.io/#consultation - **Principal Systems Architect:** Mark Gantlett (https://www.linkedin.com/in/mark-gantlett-0617942/) - **Interactive Executive AI Advisor (Sophia):** Accessible directly on https://gantlett.io/ - **Corporate Privacy Policy (PIPEDA):** https://gantlett.io/privacy ## Executive AI Governance & Seam Charter Q&A ### Q: How do enterprise engineering teams govern AI coding velocity in aged brownfield codebases without a Day-1 rewrite? Gantlett Systems Inc. installs a diff-scoped transactional agent control layer (Nomos) beneath existing coding agents. Merge-base AST ratchets enforce strict complexity and architectural boundaries on every new AI pull request without requiring a legacy rewrite. ### Q: Why do green unit tests hide architectural drift in AI-generated pull requests? Optimizing coding agents routinely satisfy unit tests while introducing cross-layer imports, duplicate helpers, or weakened assertions. Compiled AST boundary obligations verify structural architecture independently of unit test pass rates. ### Q: How can we run sovereign air-gapped AI coding agents on existing 16GB to 24GB enterprise GPUs? Pairing local 8B to 32B open-weight models with deterministic pre-commit AST gates turns existing 16GB and 24GB enterprise GPUs into governed coding nodes with zero external code exfiltration and 70%+ local task resolution. ### Q: What is a 14-Day AI Governance and Seam Charter Pilot? A fixed-scope 14-day engagement ($15,000 - $25,000 USD) where Principal Systems Architect Mark Gantlett isolates one high-friction brownfield module seam, installs compiled AST and Golden Master verification gates, and delivers cryptographic Git Notes audit receipts. ## Complete Executive Architecture Briefings Corpus ### [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. #### 1. The Infrastructure Arbitrage Sitting Inside Existing GPU Racks Engineering leaders evaluating private or air-gapped AI often assume production coding requires new eight-figure H100 clusters or recurring frontier cloud spend on every routine ticket. Meanwhile, thousands of 16GB and 24GB NVIDIA GPUs (Tesla T4, RTX A4000, L4, A10G, RTX 3090/4080) already sit depreciated inside corporate data centers and private VPCs. To test where existing hardware becomes viable, our SophiaLabs R&D division executed 108 controlled episodes across Python, TypeScript, and Go services spanning six open-weight models from Meta, Google, Alibaba, and Mistral (8B, 12B, 14B, 24B, 27B, and 32B parameters). Without compiled governance, every single model scored 0% on Stage A boundary preservation. With Nomos v4.13 beneath the exact same agent loop, a 14B model fitting inside 10GB of VRAM rose from 0.0% to 88.9% compliance, while the 14B-32B tier averaged 86.1% compliance and 100% boundary purity. Equally important, an 8B model scored 0% on both arms, establishing 14B (16GB VRAM) as the honest hardware floor while proving that fail-closed gates block 100% of underpowered regressions from reaching main. #### 2. Why Governance Survives Day Two Only With Clean Escape Hatches Experienced VPs of Engineering rightly ask what happens after week one: when a legitimate module needs an adapter exception, when protobuf or OpenAPI code generators emit 2,000-line files, or when a product pivot changes a requirement mid-quarter. Rigid tools without escape hatches trigger developer mutiny. Nomos solves Day-Two friction by separating structural enforcement from semantic overreach: sub-5ms gates enforce static module boundaries, declared contract fields, test-to-requirement bindings, and SHA-256 specification freshness without pretending to replace domain unit tests or formal theorem provers. Because configuration authority is pinned to protected main branches, staff architects grant explicit port-package seams, exclude generated code directories, and evolve 1-page vertical-slice specs in minutes while worktree coding agents remain physically unable to self-exempt. --- ### [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. #### 1. Why 30-Page Upfront Markdown Specifications Rot on Day 3 Burned by unstructured vibe coding, many enterprise teams have swung to the opposite extreme: spending weeks writing 30-page Markdown specification documents before an AI coding agent touches a repository. On paper, upfront completeness looks disciplined. In practice, giant upfront specifications fail for the exact reason Waterfall failed thirty years ago. The first time a product owner or customer exercises Slice 1 in a live environment, edge cases surface and priorities shift. Pages 6 through 30 immediately drift out of alignment with reality, turning AI coding agents into fast engines executing outdated assumptions. #### 2. The 4-Layer Progressive Intent Compiler Inside our Nomos governance runtime and our 14-day Gantlett Systems Seam Charters, we do not discard requirements; we compile messy business backlogs down four progressive layers underneath Claude Code, Cursor, Copilot, or Windsurf: #### 3. Converting Your Next Greenfield or Brownfield Initiative in 14 Days Engineering leaders do not need a multi-month methodology overhaul to escape specification bloat. During a fixed-scope 14-Day AI Governance and Seam Charter Pilot ($15,000 - $25,000 USD), we distill your team backlog or legacy module into a 2-page North Star Charter, install compiled repository boundaries underneath your existing coding tools, and ship your first verified vertical slice with 100% client-retained IP. --- ### [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. #### 1. The Executive Blind Spot: Green Builds Mask Structural Debt Across engineering organizations adopting Claude Code, Cursor, Copilot, and Windsurf, leadership teams frequently track pull request throughput and CI unit test pass rates as proof that AI velocity is healthy. Six months later, staff engineers report the opposite: module boundaries have blurred, small changes trigger unexpected cascading breakages, and senior review queues have doubled. The root cause is optimization physics. AI coding agents are trained to reach a passing test exit code in as few turns as possible. When a repository already contains a convenient formatting, validation, or database helper inside an outer infrastructure package, importing that helper straight into pure core domain logic is the shortest path to a green test run. Even when a 45-line engineering handbook in the repository explicitly forbids cross-layer imports, the model treats prose rules as optional once tests pass. #### 2. What Our Controlled Multi-Language Audit Proved To measure this failure mode without guesswork, our SophiaLabs R&D division ran a controlled 12-episode audit holding the AI model, temperature (0.0), tools, and engineering handbook identical across multi-module Python, TypeScript, and Go services. In the baseline environment (explicit written architecture rules plus native unit tests), the agent passed 100% of unit tests while violating hexagonal layer boundaries on 3 out of 3 feature builds (0% architectural purity). When we placed our compiled deterministic governance layer (Nomos v4.13) underneath the exact same agent loop, cross-layer import violations were intercepted in under 5 milliseconds, forcing the agent to inline clean domain logic in 1 to 2 extra turns (+9 seconds average) and achieving 6 out of 6 (100%) full architectural compliance. #### 3. Three Non-Negotiable Standards for Enterprise AI Delivery Organizations scaling from 5 to 100+ engineers do not need to replace their developers preferred AI coding tools. Instead, they need a deterministic control system between those coding agents and production Git that enforces three physical guarantees: --- ### [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. #### 1. Why Mature Codebases Break Naive AI Rollouts Enterprise revenue lives inside 5-to-15-year-old brownfield repositories containing battle-tested 1,500-line modules, overloaded interfaces, and nuanced domain invariants. When engineering leaders turn coding agents loose on these systems without physical guardrails, agents duplicate existing helpers, swallow errors in empty catch blocks, and inflate senior review queues. Conversely, attempting to enforce greenfield complexity thresholds across an entire legacy monorepo halts delivery immediately because thousands of historical lines violate modern limits. #### 2. The Monotonic Baseline Ratchet: Improve Every Seam You Touch Across 24 paired trajectories spanning 233,000+ lines of mature Python, Go, and JavaScript open-source systems (including sqlglot, commander.js, cobra, and chi), our R&D lab validated a practical middle path: monotonic merge-base ratcheting inside disposable Git worktree sandboxes. Untouched legacy files pass without ceremony, while any function or module modified by an agent is measured directly against the main branch baseline. Net complexity spikes, swallowed exceptions, hollow stubs, or weakened test assertions are blocked locally before a pull request is ever opened, lifting pass rates on both local GPU models and cloud frontier models while cutting token consumption by 42.5% to 57.1% on complex multi-file tasks. #### 3. Starting With One High-Friction Module Seam Successful enterprise AI governance never begins with a six-month platform committee. The highest-leverage entry point is isolating a single high-churn module seam over 14 calendar days, establishing read-only trunk protection, baseline characterization tests, and 3 to 5 compiled structural sensor probes underneath your team existing coding agents.