An agent is a model in a loop. Building AI Agents in Go has you build the loop: 17 chapters and 776 pages, from the first request to a crash-triage agent for a real Go web service, using only Go’s standard library. Every example runs offline with no API key.
Two CouchDB databases got the same replications in the same order. One ended with a document deleted, the other with it live, and the only difference was a validation function that accepts everything. This is the full path from a theory of convergence, to a model of CouchDB’s replication, to a prediction committed before any test, to the one scenario the model got wrong, to the bug behind it and the fix that merged into CouchDB.
Agents that share state usually rely on eventual consistency and hope. Bide’s shared state rests on a convergence theorem that is machine-checked axiom-free, re-checked on three proof-assistant toolchains, and wired into the engine as a fail-closed gate, so a bug in the Go verifier cannot hand you a machine whose tables do not converge. This is what is proven, how it is checked, and exactly where the proof stops.
bpp wins on tokens and loses on being read correctly. Across 8 models and ~770K records, mean comprehension error was GCF 31% / JSON 40% / bpp 54%. The failure is mechanical: bpp interns repeated values into a pointer table and models return the pointer instead of the value. The token saving is erased the moment you price the errors.
You rarely know everything before you have to start building. This is the workflow I use to build the parts that are settled, hold the parts that are not as defaulted decisions with known reversal costs, and never paint into a corner. Two anchors carry it: invariants made unrepresentable, and a decision register threaded through the code as a greppable ID.
You find an over-restriction because something legitimate breaks and points at the spot, and it breaks earlier the earlier you encode the rule. You do not find an over-permission the same way, because nothing legitimate ever exercises it. Here is the asymmetry, a worked example, and where it stops being true.
A measured, reproducible evaluation of Jev (TypeSafe AI) against the peer class its own benchmarks avoid. Where the moat is real, where it reduces to a copyable harness, and the one same-task test that settles it. Run from public materials only, no stake.
We benchmarked 8 tokenizers from 6 providers and performed exhaustive vocabulary scans. 15 of the most common JSON field names (id, name, type, value, title, time, text, url, path, description) exist as merged vocabulary entries (quote+field in one token) on GPT-4 (#32586 for ‘“name’), LLaMA, and Qwen. Claude and Gemma have zero such entries. These merges are hardcoded, deterministic, and irrecoverable without retraining the tokenizer. On real eval data: JSON boundary merge rate 8.93% vs GCF 1.00% (88.8% fewer). GPT-4 has 114 quote+letter vocabulary entries vs 17 pipe+letter (6.7:1 ratio). JSON overhead is 81% at scale. This structural ambiguity compounds per row and explains model-dependent comprehension failures across 2,400+ evaluations.
23 comprehension runs across 10 models (Claude Opus/Sonnet/Haiku, GPT-5.5/5.4/5.4-mini, Gemini 2.5 Flash/Pro, Gemini 3.1 Pro, Gemini 3.5 Flash). Generation eval across 11 models and 3 providers (Anthropic, OpenAI, Google). GCF wins 22, ties 1, loses 0 on comprehension. GCF achieves 5/5 valid generation on every frontier model with zero prior training. TOON fails 0/5 on generation with Opus, GPT-5.4, GPT-5.4-mini, Gemini 3.1 Pro, and Gemini 3.1 Flash Lite. JSON breaks on input at 500 symbols.
codegraph has 19K GitHub stars. GitNexus has 40K. Aider has 20K. We benchmarked 7 systems on 302 tasks across 17 codebases, 8 languages. knowing is 3.79x more precise than codegraph, 6.00x vs GitNexus, 6.35x vs Gortex, 22.0x vs grep. 13 self-adapting mechanisms that compound over time.
We inserted GCF into TOON’s benchmark harness. Same datasets, same tokenizer, same methodology. GCF uses 34% fewer tokens on mixed-structure data, matches TOON on flat data, and achieves 100% LLM comprehension accuracy where JSON fails at 66.7%.
We indexed 300 popular packages with knowing’s code graph, computed isolation scores based on credential access + process spawning patterns, and achieved a 1.0% false positive rate across both the initial 200 and a held-out 100. No sandbox. No execution. No heuristics. Just graph structure.
Your Go CLI tool is on GitHub Releases. 80% of developers will never find it there. Here’s how to put it on pip and npm with 50 lines of bash, getting a 12x download multiplier. Full technique with scripts, numbers, and the release pipeline that ties it together.
Rigorous benchmark of AI agent code retrieval: 107 tasks, 5 repos, 5 languages, 4 competitors. grep precision: 2%. GitNexus: 7.6%. knowing: 23% (11.5x better, p<0.0001). Plus: 193x faster indexing, 28x less RAM, 48x more token-efficient than Repomix. The first statistically validated comparison of code intelligence tools for AI agents.
AI coding agents have a context problem. The tools solving it fall into four categories: context packers, code graphs, memory systems, and runtime observability. Each solves one piece. None versions the intelligence. None proves anything. None learns without poisoning itself over time. This article explores the landscape and argues that content-addressed code graphs with cryptographic proofs are the missing foundation.
Git proved that content-addressing file contents gives you integrity, history, efficient equality, and distributed collaboration for free. The same architecture applied to code relationships gives you something new: versioned intelligence that you can diff, cache, prove, and trust over time.
Would a visual debugger like gotrace have caught three concurrency bugs found via static code reading in a production Go library? The answer reveals a fundamental taxonomy that holds across all programming languages.
Go, Node.js, Java virtual threads, Erlang, Rust, Python, Kotlin: each language’s concurrency model is a different engineering trade-off against the same physics. This article builds the framework for understanding all of them, starting from the OS scheduler and working upward.
We built a reproducible experiment measuring how many tokens AI coding agents consume when navigating code with grep vs LSP. On HashiCorp Consul (319K lines), LSP uses 34x fewer tokens. On a TypeScript rename across 24 files: 1,441x fewer bytes. The experiment covers 4 codebases, 3 languages, 13 tasks covering 7 agent workflows.
MCP servers are the tools AI agents rely on. We tested 55 of them with mcp-assert, found 20 bugs across 9 servers, and submitted fix PRs. Grafana and Ant Group merged ours. Three days after launch, Ant Group’s visualization team asked us to integrate mcp-assert into their CI. The most common failure: servers throw unhandled exceptions instead of returning isError, leaving agents unable to recover.