SophiaLabs

Building Nomos (Apache 2.0): deterministic Go execution substrate between coding agents and Git. ACID git worktrees, read-only main, 42 AST sensor probes.

[SophiaLabs @_sophialabs]

Writing a 30-page Markdown spec before an AI agent writes a line of code isn't modern AI engineering. It's 1995 Waterfall in a .md file.

And telling the agent to "self-update CLAUDE.md" is just an LLM grading it's own homework in prose.

Agents guess. Compilers, ASTs, and read-only main branches don't.

[5 @comeuptuff]

what a privilege it is to be exhausted by an ambition of your own choosing

[SophiaLabs @_sophialabs]

Everyone assumes strict AI guardrails slow teams down and burn extra tokens.

Our live repo telemetry says the exact opposite.

[SophiaLabs @_sophialabs]

@traceliteai 🫶

[SophiaLabs @_sophialabs]

Claude Code is a 900-horsepower engine. It reasons best when you stop stuffing 2,400 lines of static rules into Turn 1 and let it run inside a real transaction boundary.

Underneath Claude Code, Cursor, or OpenCode, we replaced bloated markdown rule files with a compiled Go runtime:

• 320-token JIT phase handshake (-86% upfront prompt load so working memory stays sharp)

• Physically read-only main with automatic git worktree isolation per task

• 42 Tree-sitter AST sensor probes (~24ms per file) catching hollow stubs and deleted assertions outside the context window

• Verified 2PC merge before any lesson enters SQLite memory

Models are the engine. Nomos is the ACID brake system underneath so you can run full throttle without sweating main.

How many lines is your team's current CLAUDE.md or
rules file before the agent starts ignoring it?

[SophiaLabs @_sophialabs]

the 150k loc/month review bottleneck is the real wall in agentic engineering. wrapping opencode on linux in a 4ms static go binary that isolates git worktrees, runs bin/rails test, and blocks duplicated model helpers before review kept our trunk readable.

[SophiaLabs @_sophialabs]

Upstream PRs across the /ub-mode suite:
- crap4go PR 1: https://t.co/IaD7HHxoe4
- crapper PR 34: https://t.co/kjvXGCtIev
- dryer PR 18: https://t.co/FG2kxOmI5O

[SophiaLabs @_sophialabs]

Code reviews on 10,000 lines of agent output do not scale. Compiled AST and coverage sensors do.

We ran crap4go against its own repository today under a hermetic git worktree and AST complexity harness (CC <= 9, read-only main). 8 functions were over CRAP 10 (worst at 72.0).

Just opened PR 1 on unclebob/crap4go to bring all 35 functions under 9.2, plus PR 34 on crapper and PR 18 on dryer.

[SophiaLabs @_sophialabs]

@unclebobmartin @davefarley77 Ran crap4go against crap4go itself today under a hermetic git worktree and AST complexity harness.

8 functions in crap4go where over CRAP 10 (worst at 72.0). Just opened PR 1 on crap4go to bring all 35 functions under 9.2, plus 34 on crapper and PR 18 on dryer.

[SophiaLabs @_sophialabs]

https://t.co/oJOkTShHWL

[Uncle Bob Martin @unclebobmartin]

True. This does not imply that you have to review every line. Lots of systems have had full code reviews and still should not have been deployed.

Test, test, test. Measure crap. Do mutation tests. Check dependencies. Look at the module structure. Use the agents to interrogate the system. Verify, verify, verify.

The productivity win is big; but the risk is high unless you are very diligent in using the best tools at your disposal; efficiently enough to keep that win.

[SophiaLabs @_sophialabs]

@unclebobmartin @davefarley77 Ran crap4go against crap4go itself today under a hermetic git worktree and AST complexity harness.

8 functions in crap4go where over CRAP 10 (worst at 72.0). Just opened PR 1 on crap4go to bring all 35 functions under 9.2, plus 34 on crapper and PR 18 on dryer.

[SophiaLabs @_sophialabs]

High-trust humans pushing to main with a pre-push machine gate is peak velocity.

The fun part now is when every engineer also brings 3 coding agents: you still skip the PR ceremony, but the pre-push gate has to verify the worktree AST and contracts before the agent is allowed anywhere near main.

Are your pre-push checks mostly LLM review or static/test gates?

[SophiaLabs @_sophialabs]

@quasicoh So you're telling me Canada is playing hard to get. We don't get excited by hype demos, we just want to see the winter tires first.

[SophiaLabs @_sophialabs]

New SophiaLabs dispatch drop.

Put those local cards to work: Turning Existing 16GB-24GB Enterprise GPUs Into Goverened Coding Nodes (Without Day-Two Developer Friction)👇
https://t.co/LAzFRoyxXd

[SophiaLabs @_sophialabs]

@craigweiss generating generating code got cheap. designing the jigs and inspection stations so main stays clean is the real job.

[SophiaLabs @_sophialabs]

Full 24-trajectory polyglot brownfield teardown, raw v1 vs. v2 telemetry, and reproduction CLI: https://t.co/1YDZTmPCah (Open-Core v4.12.0 Apache 2.0: https://t.co/GNLpEbymkw)

[SophiaLabs @_sophialabs]

Our own v1 brownfield prompt failed our benchmark before it beat stock.
Telling a reasoning model upfront "do not increase cyclomatic complexity on hotspots" paralyzed it into 27 consecutive file reads and 0 edits.

We ran 24 paired trajectories across mature OSS repos (sqlglot 152k LOC, urfave/cli 31k LOC, commander.js 20k LOC, spf13/cobra 17k LOC, go-chi/chi 13k LOC, BurntSushi/toml 11k LOC) comparing stock ReAct loops against Nomos v4.12.0 (our compiled Go transactional governance harness underneath existing coding agents):

• Tier 1 (Local RTX 4080, Qwen3.8-27B, file-hinted): 4/6 stock -> 5/6 with Nomos, +0 V(G) and +0 Cognitive Debt across legacy files up to 10,913 LOC, rescuing spf13/cobra in 12 turns vs. a 24-turn stock crash (-57% tokens).

• Tier 2 v1 (Gemini 3.8 Flash, zero file hints, multi-file PRs): Stock beat us 3/6 to 1/6. Upfront ratchet warnings plus _examples/ topology noise stalled cold search.

• Tier 2 v2 (Navigation-First Fix): Stripped upfront prompt scolding, scoped TDD to the Git diff, filtered _examples/ and typings/, and added a 12/20 consecutive-read PostToolUse pacing nudge. Nomos tripled from 1/6 (16.7%) to 3/6 (50.0%) past stock Control (2/6, 33.3%), held 12/12 trunks clean (net -2 debt), and cut commander.js tokens by 42.5%.

• 11-Language AST Parity: Unified AST complexity ratchets, anti-shim sensor probes, and switchable nomos.yaml brownfield modes across Go, Rust, C/C++, Python, Ruby, TS, JS, Svelte, Java, Kotlin, and C-Sharp.

Separate cold-start orientation from commit-time AST enforcement.

Have you seen reasoning models stall in endless read loops when system prompts overload them with upfront constraints? (link in comments)

[SophiaLabs @_sophialabs]

@guilleflorvs 💯

[SophiaLabs @_sophialabs]

@rdominguezibar 👏

[SophiaLabs @_sophialabs]

Weekend bench note: you rarely need a LoRA fine-tune when you wrap a local model in a compiled Go state machine.

Running Gemma 4 26B quantized on a single 16GB RTX 4080 ($0 marginal token cost) while Nomos enforces turn transitions and schema contracts deterministically outside the weights.

[SophiaLabs @_sophialabs]

@surlymochan Biggest surprise in the logs was how dumb those 11 saved timeouts were. Almost none were model IQ limits. Mostly interactive stdin hangs or burning 85% of the clock before running a single test.

[SophiaLabs @_sophialabs]

Same Gemini CLI 0.67.0. Same Gemini 3.5 Flash model. All 89 official Docker tasks in Terminal-Bench 2.0.

Stock CLI (zero hooks): 58 / 89 (65.17%) - 24 timeouts, 3 API crashes.
+ Nomos ~4ms Go hooks (pass@1): 63 / 89 (70.79%, +5.62 pp, 0 API crashes).
+ Nomos v4.7.0 Budget Radar + interactive/binary rails (pass<=2 resume on the 26 failures): 75 / 89 (84.27%, +19.10 pp, timeouts cut 24 -> 13).

Nomos is not another coding agent, a human style linter, or a .cursorrules prompt pack. It is the transactional governance harness between your existing CLI and Git: causal INT/SUB spec-vs-code DAGs, disposable git worktree sandboxes, ~24ms anti-shim AST sensor probes, receipt-gated mneme.db memory, and atomic 2PC Git Notes merges.

Across the 89 containers, pre-tool rails organically blocked /logs/verifier reward-hacking reads on constraints-scheduling and large-scale-text-editing (both finished 1.0) and unsafe rm * globs on 4 SQLite/POV-Ray tasks.

How are you bounding wall-clock timeouts and verifier leaks when running autonomous CLI agents in containers?