The AI-native wire format for structured data. Built for the agentic loop.

[!IMPORTANT] Reverse-engineered from original attention research. Four papers by Dayna Blackwell (2026, under review):

• GCF: A Token-Optimized Wire Format for Structured LLM Interactions
• Tokenizer-Attention Coupling: How BPE Merge Decisions Permanently Shape Transformer Internal Organization
• Stranded Attention: BPE Tokenization Permanently Constrains Transformer Structural Capacity
• Developmental Atlas of Attention Head Specialization: Spacing, Stranding, and the Capacity Tax of BPE Tokenization

GCF is built for the agentic loop, where the same structured context crosses the model boundary turn after turn. A single payload is already 50-92% smaller than JSON. But GCF also deduplicates repeated structure across turns and sends only deltas when context changes, so by the 5th overlapping call each response costs 99% fewer tokens than the JSON equivalent, and a full 10-call session runs 94.4% cheaper than re-sending JSON every turn. Session dedup and delta both need local IDs and a multi-turn design: neither JSON nor TOON can do this at all.

• 100% comprehension on every frontier model, zero training required. 91.2% on structurally complex code graphs, where TOON drops to 68.8% and JSON to 54.1%.
• Proven lossless. decode(encode(value)) == value for every structured value, verified across 43,000,000,000+ round-trips in 5 formats and 6 languages, with interop validated across 17 serialization formats. Zero runtime dependencies, in all seven SDKs.
• One codec for every format. Encode JSON, YAML, TOML, CSV, or MessagePack to GCF; the model reads it natively with zero format instructions; decode() converts back to any of them. Your existing schemas and validators work on the decoded output unchanged.

No other single format is all four at once: schema-free (no .proto), lossless, token-compact (50-92% vs JSON), and model-readable with zero training. JSON is verbose, Protobuf needs a schema, MessagePack is binary, and TOON silently corrupts data (7.54% round-trip failure, 176,487 silent corruptions per 10M) and collapses on structured data (68.8% comprehension where GCF holds 91.2% and JSON 54.1%). GCF is designed at the tokenizer level: its pipe delimiter has a 0% merge rate with field names, while JSON's grammar symbols and TOON's tab are hardcoded as merged vocabulary entries in BPE tokenizers (TOON's tab merges with adjacent content on 32.91% of boundaries, the worst of any common separator, and JSON's quote on 8.17%), creating structural boundaries the model cannot recover.

pip install gcf-python                    # Python
npm install @blackwell-systems/gcf        # TypeScript
go get github.com/blackwell-systems/gcf-go  # Go
cargo add gcf                             # Rust
dotnet add package BlackwellSystems.Gcf   # .NET

Or wrap any existing MCP server with zero code changes:

pip install gcf-proxy

Benchmarks

2,500+ LLM evaluations across 11 models, 4 providers, and 50+ independent test runs.

Full results: gcformat.com/guide/benchmarks

Encode any structured data (generic profile)

from gcf import encode_generic

output = encode_generic({
    "employees": [
        {"id": 1, "name": "Alice", "department": "Engineering", "salary": 95000},
        {"id": 2, "name": "Bob", "department": "Sales", "salary": 72000},
        {"id": 3, "name": "Carol", "department": "Marketing", "salary": 85000},
    ],
})

GCF profile=generic
## employees [3]{id,name,department,salary}
1|Alice|Engineering|95000
2|Bob|Sales|72000
3|Carol|Marketing|85000

One header declares field names. Rows are positional values only. No field names repeated per record. Lossless: decode(encode(value)) == value for every structured value, proven across 43,000,000,000+ random round-trips in 5 formats and 6 languages.

Graph profile (code intelligence, knowledge graphs, MCP tools)

For data with nodes, edges, and distance groups:

from gcf import encode, Payload, Symbol, Edge

output = encode(Payload(
    tool="context_for_task", token_budget=5000, tokens_used=1847,
    symbols=[
        Symbol(qualified_name="github.com/org/repo/pkg.AuthMiddleware", kind="function", score=0.78, provenance="lsp_resolved", distance=0),
        Symbol(qualified_name="github.com/org/repo/pkg.NewServer", kind="function", score=0.54, provenance="lsp_resolved", distance=1),
    ],
    edges=[Edge(source="github.com/org/repo/pkg.NewServer", target="github.com/org/repo/pkg.AuthMiddleware", edge_type="calls")],
))

GCF profile=graph tool=context_for_task budget=5000 tokens=1847 symbols=2 edges=1
## targets
@0 fn github.com/org/repo/pkg.AuthMiddleware 0.78 lsp_resolved
## related
@1 fn github.com/org/repo/pkg.NewServer 0.54 lsp_resolved
## edges [1]
@0<@1 calls

Local IDs (@0, @1) replace full names in edges. 81 tokens instead of 191 for JSON.

Try it live in the playground with real-time multi-format comparison. Paste JSON, YAML, or TOML. Encode from and decode to JSON, YAML, TOML, CSV, and MessagePack.

How it works

Generic profile

Lossless structured data encoding. Arrays, nested objects, mixed types, primitives, root scalars. Works on any data that deserializes to objects and arrays, regardless of source format.

1. Arrays of objects. ## name [count]{field1,field2} declares field names once. Rows are pipe-separated values. Absent fields use ~, null uses -.
2. Nested objects. Fixed-shape nested objects are flattened into > path columns: "customer>name" becomes a column, values go directly in the row. 20-48% fewer tokens on deeply nested API data. Variable-length arrays and irregular shapes use ^ attachment fallback.
3. Primitive arrays. Inlined: tags[2]: admin,user. Strings containing commas are quoted.
4. Scalars. key=value at the top level. Strings that collide with typed literals ("true", "123", "-") are quoted automatically.
5. Root values. Objects, arrays, and scalars at the document root. Every JSON value has a GCF representation.

Graph profile

1. Positional fields. One header declares field names. Rows are values only.
2. Local IDs. @0, @1. Edges reference by ID, not by repeating full identifiers.
3. Hierarchical grouping. Section headers (## targets, ## related) replace per-record metadata.

Both profiles share the same grammar (common scalar grammar, key grammar, header format). The savings are structural and grow with payload size.

Streaming

Emit a payload incrementally, without buffering it, for database cursors, pagination, and graph traversals too large to hold in memory.

1. Deferred counts. A header emits [?] when the size isn't known yet (## edges [?]) and rows stream out as they are produced.
2. Summary trailer. A closing ##! summary symbols=8 edges=6 counts=2,1,3 backfills the real counts once the stream ends, so the model still gets exact totals.
3. O(1) memory. The encoder holds one row at a time; a 10,000-row cursor streams in constant memory instead of materializing the whole response.

TOON's tabular header requires the row count up front, so it must buffer the full array before the first byte; GCF defers the count and fills it in at the end.

It gets cheaper over time

Session deduplication: Symbols sent in prior responses become bare references (@7 = 2 tokens vs 19 for full declaration). At production scale (500 symbols), session dedup alone cuts 86.3% by call 5; composed with delta, 99.0% per call. A 10-call session reaches 94.4% cumulative savings vs JSON (each response costs 171 tokens vs 29,072 for JSON).

Delta encoding: When the context changes slightly between queries, send only the diff. 81.2% additional savings on re-queries.

No other format has these. They compound across multi-turn agent interactions.

Research

GCF was not tuned by trial and error. Its grammar was reverse-engineered from attention-level research into how BPE tokenization shapes what a transformer can represent, then validated after the fact by controlled from-scratch training.

The mechanism: a tokenizer's merge decisions permanently constrain a model's internal organization. Grammar symbols that BPE folds into the surrounding text (JSON's quotes and braces, TOON's tab) create structural boundaries the model cannot cleanly recover; a delimiter with a 0% merge rate against field names (GCF's pipe) does not. The design follows from that measurement, not from a token count.

Four papers by Dayna Blackwell (2026, currently under review) establish it: the GCF format paper, Tokenizer-Attention Coupling, Stranded Attention, and a Developmental Atlas of Attention Head Specialization. The effects are measured intrinsically and causally, from attention structure and controlled training at 1.3B scale, not scored by an LLM judge, so they are not explained away as "the benchmark just measures training exposure": GCF wins on models that have never seen it.

Read the full argument in the Tokenizer Analysis and the whitepaper.

Implementations

Zero runtime dependencies. Permanently. All seven implementations depend only on their language's standard library. No transitive dependencies. No supply chain risk. This is a permanent commitment: GCF will never take on external runtime dependencies. MIT licensed. All implementations support both generic profile (encodeGeneric) and graph profile (encode). CLI included in the six original language SDKs. Syntax highlighting via tree-sitter (Neovim, Helix, Zed).

Specification: SPEC v3.5.1 Stable with 265 conformance fixtures, 43,000,000,000+ lossless round-trips verified across 5 formats and 6 languages. Seven implementations (Go v1.6.2, Swift v2.6.1, .NET v0.1.0, the rest v2.5.2). Cross-language conformance verified.

Documentation

gcformat.com

• Getting Started
• Benchmarks
• Benchmarks (Full Data)
• GCF vs TOON
• Schema Validation
• FAQ
• Tokenizer Analysis (why JSON's grammar breaks at the BPE level)
• GCF on Small Models (where the comprehension gap actually lives: cheap, local, and open-weight models)
• Playground
• Specification

Adopted by

See all adopters →

Use cases

• MCP tool responses. Any MCP server returning structured data. 50-92% fewer tokens with 100% comprehension accuracy.
• Agent-to-agent communication. 63% fewer tokens per handoff. 5/5 generation validity on every frontier model.
• LLM structured output. LLMs produce valid GCF with a 3-line primer. No training required.
• Code intelligence. Graph profile with local IDs, edges, and distance grouping.
• Multi-format interop. Validated lossless across 17 serialization formats (JSON, XML, MessagePack, YAML, BSON, TOML, CBOR, Protobuf, CSV, JSON5, Avro, Arrow, Parquet, Pickle, INI, NDJSON, Plist).

More links

• betterthanjson.com
• jsonalternative.com
• betterthantoon.com

License

MIT - Dayna Blackwell