GEML — General Expressive Markup Language

English | 中文

GEML is an Agent-Native fundamental markup format and protocol, designed for people and AI agents to read and write the same document.
One format, two readers. In agent-driven development and knowledge work, plain text and Markdown have no deterministic block boundaries: a program and a model trade the whole file in and the whole file back out — at best probing for it with line windows, and restating the original verbatim to rewrite it. Token cost grows with the length of the document, and the operation turns bloated. After a few rounds of rewriting, the copies excerpted elsewhere start to drift.

You can start without changing a thing. geml list, geml find and geml get address the Markdown you already have — nothing is converted, no new files, your .md stays .md:

geml list    README.md                          # every section, as an address
geml get     README.md '#key-features'          # read ONE section, not the file
geml set     README.md '#key-features' --body   # write one section back
geml replace README.md 'old text' 'new text'    # swap a string, told which block held it

Only that section enters the agent’s context — a couple of KB, not the whole ~40 KB file.

Need finer than a section — one block, one chart, one table? Let .geml stand in the middle ground: edit at that grain, and the --to md you ship never drifts from it.

For people, it is plain text that reads clean; for agents, it is an addressable, verifiable, traceable, revertible "Doc-as-a-Base".

GEML is minimal. It is plain text — still clean with no renderer in sight; one block syntax for the whole language; addressable, verifiable, referenceable structure, natively.

Instead of a separate mini-syntax for each kind of content, GEML carries every kind in one container: the typed block. Code is a block. So are tables, diagrams, math, callouts, even metadata — and a run of prose can be one too (=== text), whenever you want it addressable. Extending it later is just as plain. The shape is the same every time, which makes the language easy enough to learn that it's hard to get wrong.

=== code {#hello lang=python}
print("hi")
===

geml get doc.geml '#hello'   # by name, just this block

Blocks have names so the verbs have somewhere to land — the full syntax is in the format in 1 minute.

Contents: What it solves · Why now · What's different · The format in 1 minute · A gift for programmers · Get hands-on · With an LLM · Maturity & versions · The design · Roadmap · Take part · License

What it solves

Problems solved

1. Context load and token bloat

   • Status quo: data formats like JSON/XML carry heavy wrapper tags and syntax symbols; Markdown lacks strict structural metadata and a reference mechanism.
   • Approach: tuned markup density and syntax overhead, reading and writing only the target block — context cost no longer grows with document length, keeping agent reads and writes lightweight.

2. AST-level precision and parsing determinism

   • Status quo: unstructured text degrades over multiple rounds of LLM reads and writes — broken formatting, semantic drift, parsing hallucinations.
   • Approach: a deterministic grammar that maps directly to an abstract syntax tree (AST), so programs and LLMs perform atomic block-level create/read/update/delete.

3. Document copy fragmentation

   • Status quo: multi-agent collaboration and shared pipelines pass content around by copy-paste, leaving multiple disconnected copies.
   • Approach: Single Source of Truth by design — standardized module references and data binding eliminate redundant copies and version divergence.

Key features

1. AST-level structured operations

• Uniform node definitions; a document parses directly into a typed document tree (AST).
• Agents pinpoint the target section, attribute or component; partial patches and idempotent updates replace whole-file rewrites. Writes land as byte splices with whole-document re-validation — the tree serves reading and validation, and every untouched byte is guaranteed unchanged.

2. Low-token reads and writes

• What is saved is not markup characters — it is the part never read: #id hits one semantically complete block, and the rest never enters the context.
• For the same semantics, markedly lower prompt-token cost: better model throughput, lower inference cost.

3. Single source of truth, modular references

• Native cross-document, cross-fragment component references.
• Change the source node once and every reference follows — no version skew.

4. Robust two-way reads and writes

• One block shape for the whole language — easy to generate and hard to get wrong, a good match for mainstream LLM output distributions.
• A strict validator with precise error locations and actionable repair feedback.

Comparison

Why the LLM era needs a brand-new text format

Because both the producer and the consumer of a document have changed.

In traditional software engineering, a document was either a static explanation for people to read, or a serialized data file for programs.

Today, people and AI agents collaborate on the same document at high frequency. When the agent becomes the document's "second reader and co-author", the old balance breaks for good:

1. Context is scarce compute: every whole-document read or write burns an agent's limited attention window and reasoning budget;
2. Human–machine collaboration needs an isomorphic carrier: people need to read it at a glance, agents need to read and write it precisely, block by block;
3. Knowledge must have a single source of truth: scattered prompts and copy-pasted Markdown are destined to decay with every iteration.

Yet none of our existing text infrastructure was designed for this scene:

• Markdown (typeset for people): no stable structural blocks, no machine keys. To change one parameter, an agent must read and write the whole text — wasting context budget across multi-turn loops, and inviting drift in both format and meaning.
• JSON / XML (serialized for machines): full of wrapper syntax and structural noise — blocking natural human reading, while quietly eating expensive tokens in long contexts.
• Scratch memory and scattered files (no single source of truth): context is torn across chat history and Markdown copies everywhere; a copy is drift from the moment it is made, and version skew and hallucinated distortion follow.

The root of all three failures is each tool's own virtue: Markdown's "never error, write anything" is what gives people their freedom to write — and exactly why a machine cannot trust the structure it reads back; JSON/XML's strict schema is what gives machines their certainty — and exactly why nobody writes prose in it. The virtue is the defect, which is why patches cannot fix this: bolting "a broken reference must fail the build" onto Markdown betrays its contract, and stripping the wrapper syntax from JSON denies its nature. When people and agents start co-writing the same text at high frequency, what is needed is not a compromise between the two poles, but a format that treats "readable by people" and "operable by machines" as one design constraint from day one.

The answer: "Doc-as-a-Base"

GEML invents no heavy new runtime. Borrowing from the REST architectural style of Dr. Roy Fielding's dissertation, it gives plain-text documents one standard set of operational semantics: