Thoth

The paper writes itself while the code is still hot.

The archive and the paper stay the same object

The house can invent faster than a linear desk can explain it. A 30 Hz pipeline moves. A human document takes weeks and is stale in days. Thoth’s cut is the first step: the system names what to write from the activity itself. A commit, a deploy, an API that did not exist last week — those are the sparks. The draft lands while the function is still in cache.

That is the product to want. The archive and the paper stay the same object. Write a capability once in code. The chapter that describes it is already in motion. Six white papers, 116,000 words, ninety-six chapters already exist as evidence of that factory’s output — pages the loop produced, sitting next to the modules they name.

When the next engine lands, the next paper starts from the last one. The corpus writes the next corpus. Knowledge production stops being the bottleneck. Invention and explanation share a clock.

Search → Structure → Write → Score → Publish

Thoth is a closed loop. Search → Structure → Write → Score → Publish. A change lands. The Searcher detects the documentation gap. The Structure Engine plans the chapter — scope, depth, the sections that do not already exist. The Writer produces a source-grounded draft. The Scorer grades it. The Publisher commits. The next Searcher treats that new paper as context for the next gap.

Each publication is fuel. The output of one turn is the only input the next turn needs. The library teaches itself what to write next.

• Searcher — names the gap from live activity: commits, deploys, APIs, benches.
• Structure Engine — plans a non-redundant chapter against the papers already on disk.
• Writer — one chapter at a time, every claim tied to code, a benchmark, or a named reference.
• Scorer — grades accuracy, completeness, non-redundancy, depth, and citations. Accept is 8.5 or better.
• Publisher — commits the markdown and tells the mesh the paper exists.

The next paper starts from the last one. The archive and the paper stay the same object.

It watches commits, deploys, and APIs

The Searcher reads the git log, the docs directory, the engine registry, the evidence benches, and the house’s own memory rooms. A new function, a renamed module, a deploy, an API — those wake it. The moments that fire: a new engine lands, a benchmark beats the last number, a paper section is too thin, a domain has no chapter at all.

Priority is novelty times impact times feasibility. High-value gaps jump the queue. Low-value noise does not. Rare finds — a Gem that unifies three systems, a Stone that collapses a whole domain — get a dedicated paper, not a footnote.

The Updater keeps the published set honest after the first commit. When a number moves, it does not rewrite the book. It patches the sentence that cited the old number, versions the paper, and leaves an audit trail of what changed and why. Critical contradictions jump the line. Cosmetic edits wait.

A chapter that cannot point at the code does not ship

The Writer is sequential inside one paper so later sections can cite earlier ones without ghost references. Parallel only across different papers on different nodes. Every technical assertion has to land on a function, a measured number, or an established reference. Missing sources are flagged or cut. Depth wants an equation, metrics, and code.

The Scorer is five numbers, not a vibe. Accuracy is weighted hardest. Completeness checks the plan. Non-redundancy keeps two papers from saying the same thing. Depth wants the math. Citations have to resolve. Below 7.0 the draft dies. Between 7.0 and 8.5 it rewrites. At 8.5 it may publish.

The Publisher then makes the artifact real: clean markdown, a commit the mesh can see, a NATS signal on thoth.publish.complete. Searchers, updaters, and validators pick that signal up. Within seconds the new paper is context. The library just taught itself the next gap.

A chapter that cannot point at the code does not ship.

Thoth writes. Sheshat weaves

The name is not decoration. Thoth is the Egyptian god of writing and knowledge. Sheshat is his partner — the measurer, the weaver, the one who keeps the marks from drifting apart. Thoth writes. Sheshat weaves. Thoth discovers. Sheshat connects. Thoth produces quantity. Sheshat ensures quality.

Neither half is enough. Thoth without Sheshat is a flood of unmeasured pages. Sheshat without Thoth is a standard with nothing new to score. Together they keep a living corpus: one entity generates the next chapter; the other weaves it into the map and scores whether it belongs. A library that writes, then measures what it just wrote.

That weave is why the archive and the paper can stay the same object. He produces the next page while the code is still hot. She binds it to the graph so the next Searcher can see it. Write, weave, write again.

What this page is honest about

This loop is how the factory keeps its own writing current. It is not Year-1 annual-contract value. Twenty million dollars is an ask — to land memory first. Papers and runbooks weave on top of that store.

Next in the catalog: Sheshat.