About

Dayna Blackwell is a software engineer, open source author, and published researcher. Founder of Blackwell Systems.

I build production backend systems, AI-native developer tooling, and the research infrastructure that connects tokenizer design to transformer internal organization. 20+ open source projects in Go, Rust, TypeScript, Python, and C, used by 120+ repositories across 60+ organizations, with 1M+ downloads. 11 self-published research papers. 50+ PRs merged into Google, Anthropic, HashiCorp, GitHub, Grafana, LangChain, and Stretchr’s testify.

What I’ve Built

GCF (spec, playground, betterthanjson.com) is an AI-native wire format reverse-engineered from tokenizer data. 100% comprehension on every frontier model on standard workloads. 91.2% on structurally complex code graphs where JSON drops to 54.1%. 50-92% fewer tokens than JSON. 43 billion+ lossless round-trips across 5 formats, zero failures. Seven language implementations (Go, TypeScript, Python, Rust, Swift, Kotlin, .NET), seven registries, tree-sitter grammar. Used by 28 projects outside Blackwell Systems, with 580K+ downloads. Adopted by Chrome DevTools MCP (54K stars, the #1 MCP server on GitHub), OmniRoute (77K stars), Speakeasy (customers include Google, Verizon, Mistral AI), the Linux Foundation’s Open Data Products SDK, netclaw (560 stars, replaced TOON entirely), ctx (515 stars), NeuroNest, Raycast Store, and others. Published whitepapers: GCF wire format, tokenizer-attention coupling, stranded attention, developmental atlas of attention head specialization, structural ambiguity in JSON tokenization.

knowing is a content-addressed code intelligence engine that beats every competitor in the category with statistical proof. P@10=0.278 across 308 tasks, 16 repos, 8 languages: 3.2x codegraph (19K stars), 5.05x GitNexus (40K stars), 5.35x Gortex, 12.1x Aider, 18.5x grep. 23 extractors spanning 26 languages/formats. 12 self-adapting retrieval mechanisms. 28 MCP tools and 8 resources across 7 planes. Supply chain detection without executing code (1.0% FP rate). OpenTelemetry runtime trace ingestion. Community detection with Merkle roots. GCF wire format (84% fewer tokens than JSON). Single Go binary, zero dependencies. Published whitepaper: Content-Addressing as a Computation Primitive for Software Relationship Intelligence.

bide is a framework for durable AI agents in Go, where side effects fire at most once. One append-only journal derives four guarantees no other agent framework pairs in a single library: at-most-once non-idempotent side effects (a fair crash-injection benchmark measures maxFired=1 against 4-64 for re-running frameworks), thousands of concurrent durable runs in one process with no cluster, a cryptographically verifiable RFC 6962 Merkle audit spine checkable offline without trusting the vendor, and provably convergent shared state via gsm (machine-checked in Coq 8.18/8.20). Plain-Go by default with an optional typed flow builder, any model (native Claude, native Gemini, any OpenAI-compatible endpoint), and durable Sleep/WaitUntil/Interrupt for ambient agents. Requires Go 1.27. Built for agents that move money, touch records, or act under audit.

agent-lsp is a stateful MCP server runtime over real language servers. 66 tools, 24 Agent Skills, speculative execution engine, 30 CI-verified languages. 5,500+ monthly downloads. Listed on the official MCP Registry, Glama (A-tier), and awesome-mcp-servers. Adopted in production by OmniRoute, NUR (Nix User Repository), and others.

mcp-assert is the deterministic testing standard for MCP servers. 55,000+ total downloads across 6 distribution channels. Shipped from 0-to-1 in one week. 102 servers scanned, 34 upstream bugs found, including 9 crashes in Ant Group’s mcp-server-chart, fixed upstream. Runs in CI across 39 of WYRE’s MCP server repos.

polywave is a formally specified parallel agent coordination protocol (6 invariants, 48 execution rules, 7 participant roles, 5-layer worktree isolation). 4-5x measured speedup. knowing (94K LOC) was built using polywave. Go SDK: 33 packages, 75+ CLI commands, 4 LLM backends, autonomous daemon mode. Listed on ComposioHQ/awesome-codex-skills (13.6K stars).

claudewatch is a 32-tool MCP server for AI development observability. PostToolUse hooks, session analytics, CLAUDE.md effectiveness scoring, friction pattern classification.

GCP Emulator Platform: 5 composable emulators (Secret Manager, KMS, IAM, Eventarc, auth) with shared hook architecture. The Secret Manager emulator is the most widely adopted community solution, ranked #1 on Google/Bing/DuckDuckGo, recommended by Google AI Overview, Gemini, and GitHub Copilot. 275K+ downloads. Used in the test suites of Apereo CAS, Camunda and Flipt, among 10 projects using the emulators.

Top-10 all-time contributor to mcp-go (9.2K stars). Full open source portfolio.

Professional Work

Backend Enterprise Developer at Best Western Hotels & Resorts, where I architect and operate the core loyalty platform backend serving millions of members across 5,000+ properties in 120 countries. This platform is the foundational layer consumed by nearly every engineering team in the company. I designed the Digital Wallet (5 currencies), the serverless promotion rules engine (Lambda, EventBridge, DynamoDB, Redis), and the real-time CDC pipeline. Revenue-critical systems with 24/7 on-call. Founding member of the Agentic Development Group, leading enterprise-wide rollout of AI-enhanced engineering workflows.

Publications

All 11 are self-published and archived on Zenodo with permanent DOIs. Each has a citation and BibTeX entry under Cite this.

Blackwell, D. (2026). Tokenizer-Attention Coupling: How BPE Merge Decisions Permanently Shape Transformer Internal Organization. Preprint.
doi:10.5281/zenodo.20925910

43 tokenizers from 20 providers. Every one merges delimiter characters with adjacent content, destroying structural boundaries before the transformer runs. Controlled experiment: two identical 410M models, same corpus, same hyperparameters, different tokenizer. The one with 16 merge-barrier characters develops 4.6x more structural attention heads, achieves 3-738x better structured data perplexity, 3-5x better code comprehension, with zero natural language cost. 18-phase causal ablation protocol proves the heads are necessary, sufficient, and format-general. Validated across 2 architectures, 2 scales, and 3 domains (structured data, code, molecular chemistry). Introduces tokenizer-attention coupling: BPE merge decisions permanently constrain which attention heads develop.

@misc{blackwell2026tokenizerattentioncoupling,
  author       = {Blackwell, Dayna},
  title        = {Tokenizer-Attention Coupling: How BPE Merge Decisions Permanently Shape Transformer Internal Organization},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.20925910},
  url          = {https://doi.org/10.5281/zenodo.20925910},
  note         = {Preprint, self-published}
}

Blackwell, D. (2026). Stranded Attention: BPE Tokenization Permanently Constrains Transformer Structural Capacity. Preprint.
doi:10.5281/zenodo.21158886

When a standard BPE model is fed clean delimiter boundaries using its own frozen weights, all 384 attention heads at 410M and all 768 at 1.3B show 4x more delimiter attention (14% to 54%). This frustration gap appears by step 5,000 and does not change across 35,000 additional steps. At 1.3B, standard BPE develops 124 counterproductive delimiter heads whose removal improves comprehension by 57%. Stranded heads are a third attention state: active but unproductive, neither functional nor safely removable.

@misc{blackwell2026strandedattention,
  author       = {Blackwell, Dayna},
  title        = {Stranded Attention: BPE Tokenization Permanently Constrains Transformer Structural Capacity},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.21158886},
  url          = {https://doi.org/10.5281/zenodo.21158886},
  note         = {Preprint, self-published}
}

Blackwell, D. (2026). Developmental Atlas of Attention Head Specialization: Spacing, Stranding, and the Capacity Tax of BPE Tokenization. Preprint.
doi:10.5281/zenodo.21205389

The first comprehensive tracking of attention head specialization at scale: 384 heads across 7 behavior types, 131 checkpoints per run, 7 training runs on 2 corpora and 2 architectures (GPT-NeoX 410M, Llama 410M). The BPE capacity tax is architecture-independent: spacing ablation costs +64.3% on NeoX (MHA) and +67.0% on Llama (GQA). Together, 48-56% of attention capacity in standard BPE is non-productive (40-48% spacing recovery, ~8% collapsed into position-zero sinks). Merge barriers (a 16-line tokenizer config change) eliminate the need for it entirely.

@misc{blackwell2026developmentalatlas,
  author       = {Blackwell, Dayna},
  title        = {Developmental Atlas of Attention Head Specialization: Spacing, Stranding, and the Capacity Tax of BPE Tokenization},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.21205389},
  url          = {https://doi.org/10.5281/zenodo.21205389},
  note         = {Preprint, self-published}
}

Blackwell, D. (2026). GCF: A Token-Optimized Wire Format for Structured LLM Interactions. Working Paper.
doi:10.5281/zenodo.20579817

2,400+ LLM evaluations across 11 models and 3 providers. 100% comprehension on every frontier model on standard workloads. 91.2% on structurally complex data where JSON drops to 54.1%. 43 billion+ lossless round-trips. Grammar characters selected from the set empirically verified to have near-zero BPE merge rates across 43 tokenizers. Spec v3.2 Stable.

@misc{blackwell2026gcf,
  author       = {Blackwell, Dayna},
  title        = {GCF: A Token-Optimized Wire Format for Structured LLM Interactions},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.20579817},
  url          = {https://doi.org/10.5281/zenodo.20579817},
  note         = {Working Paper, self-published}
}

Blackwell, D. (2026). Structural Ambiguity in JSON Tokenization: A Cross-Tokenizer Analysis. Preprint.
doi:10.5281/zenodo.20789619

8 tokenizers from 6 providers. JSON’s 15 most common field names merge with the opening quote on 50-63% of tokenizers. JSON boundary merge rate: 8.93%. Pipe-delimited: 1.00%. Tab-delimited (TOON): 59.82%. JSON overhead reaches 81% at 500 rows.

@misc{blackwell2026jsontokenization,
  author       = {Blackwell, Dayna},
  title        = {Structural Ambiguity in JSON Tokenization: A Cross-Tokenizer Analysis},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.20810588},
  url          = {https://doi.org/10.5281/zenodo.20810588},
  note         = {Preprint, self-published}
}

Blackwell, D. (2026). Content-Addressing as a Computation Primitive for Software Relationship Intelligence. Technical Report.
doi:10.5281/zenodo.20342255

Hierarchical Merkle trees over code relationship edges as a query-optimization substrate. Self-adapting retrieval, cryptographic proofs of relationship presence and absence, supply chain detection. No prior art found in a survey of Sourcegraph, Kythe, CodeQL, Bazel, Neo4j, IPFS, and Nix. Companion implementation: knowing.

@misc{blackwell2026contentaddressing,
  author       = {Blackwell, Dayna},
  title        = {Content-Addressing as a Computation Primitive for Software Relationship Intelligence},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.20342255},
  url          = {https://doi.org/10.5281/zenodo.20342255},
  note         = {Technical Report, self-published}
}

Blackwell, D. (2026). Normalization Confluence in Federated Registry Networks. Technical Report.
doi:10.5281/zenodo.18677400

Extends normalization confluence to federated environments where multiple registries with independent invariants are connected by morphisms encoding cross-organizational constraints. Proves federated convergence requires only validity preservation for tree-shaped networks.

@misc{blackwell2026federatedconfluence,
  author       = {Blackwell, Dayna},
  title        = {Normalization Confluence in Federated Registry Networks},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.18677400},
  url          = {https://doi.org/10.5281/zenodo.18677400},
  note         = {Technical Report, self-published}
}

Blackwell, D. (2026). Normalization Confluence for Registry-Governed Stream Processing. Technical Report.
doi:10.5281/zenodo.18671870

A third regime for coordination-free convergence in distributed systems: normalization confluence, where non-commutative operations converge through compensation. Companion implementations: nccheck (verification DSL) and gsm (Go runtime with O(1) event application).

@misc{blackwell2026normalizationconfluence,
  author       = {Blackwell, Dayna},
  title        = {Normalization Confluence for Registry-Governed Stream Processing},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.18671870},
  url          = {https://doi.org/10.5281/zenodo.18671870},
  note         = {Technical Report, self-published}
}

Blackwell, D. (2026). Drainability: When Coarse-Grained Memory Reclamation Produces Bounded Retention. Technical Report.
doi:10.5281/zenodo.18653776

Proves the O(1) vs Omega(t) dichotomy for coarse-grained allocators: drainability produces bounded retention, its absence produces unbounded growth. Companion implementation: libdrainprof (C profiler, sub-2ns overhead).

@misc{blackwell2026drainability,
  author       = {Blackwell, Dayna},
  title        = {Drainability: When Coarse-Grained Memory Reclamation Produces Bounded Retention},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.18653776},
  url          = {https://doi.org/10.5281/zenodo.18653776},
  note         = {Technical Report, self-published}
}

Books

Building AI Agents in Go (first edition, October 2026, 776 pages) teaches how AI agents work by building one in Go with the standard library, from a 30-line loop to a crash-triage agent for a real Go web service: tool calling, context, streaming, MCP, evals across models, sandboxing and prompt-injection defenses, and crash-safe runs. Every example runs offline with no API key. Buy, $29 · Free sample · Launch post · Code

You Don’t Know JSON (107,000 words) covers JSON ecosystem architecture, schema validation, binary formats (MessagePack, CBOR, Protocol Buffers), streaming architectures, security patterns, API design, and testing strategies. Available on Leanpub.

What I Write About

This blog provides technical deep-dives into programming language fundamentals, distributed systems, and AI-native development tooling.

Tokenization & LLM Architecture:

• BPE merge barriers and their effect on attention head specialization
• Structured data comprehension at scale
• Tokenizer-attention coupling across architectures and domains

Code Intelligence & AI Tooling:

• Benchmark methodology for code context retrieval
• MCP server development and testing
• Multi-agent coordination and parallel development workflows
• Claude Code extensibility (skills, hooks, subagents)

Language Design & Systems:

• Value semantics vs reference semantics across languages
• Memory models, concurrency primitives, escape analysis
• Why modern languages moved away from OOP patterns

Distributed Systems:

• Event-driven architectures at scale
• Idempotent message handling and deduplication patterns
• Serverless patterns and AWS architecture

Contact

• Email: dayna@blackwell-systems.com
• GitHub: @blackwell-systems
• Open source: full portfolio | consulting