The road to YuCe

How research into verification, determinism and canonicalization grew into a jade book

The beginning

養 — to nourish and tend. 生 — life, what grows. 道 — the way. Together, 養生道 is the way of healthy living, and it is our philosophy. We bring it to AI agents: they need a healthy way of working and an environment in which they can grow.

In the Zhuangzi there is Cook Ding. His knife stays sharp for years because it follows the natural grain and passes through the gaps. A healthy team of agents works the same way: each within its own bounds, along the grain of the task, and the team grows without wearing itself down.

1. The question it started from

How will AI systems work once they stop being separate chat models and become a team of agents? How will they pass reasoning to one another? How is meaning kept when work changes hands? How does one agent check what another one meant?

An early conclusion: programming languages made for people fit poorly for a deterministic, checkable exchange of reasoning between agents. And the main shift: the question is not how to generate more, but how to trust what was generated. A model can put one thought in many ways: as prose, as a plan, as a message to another agent. Only a canonical record, one for all these forms, can be trusted. Many forms of expression, one reproducible canonical result.

From there come the three goals that still lead us: verification, determinism and canonicalization. This is also 養生道 for agents: drift of meaning is a disorder, unchecked exchange between agents is fragility, and the discipline of checking is the hygiene of reasoning.

2. Wings and the kite: Tsubasa and Tobi

The first instruments of this research were a language and a checker. Tsubasa (Japanese for "wings") is a language in which reasoning is written strictly and the same way, whoever writes it. Tobi (Japanese for "kite") is the checker, the one who watches and tells apart. Tobi Validator deterministically checks a record of reasoning at the boundaries of a workflow and brings it to canonical form: what comes out is either the canonical record or an exact diagnostic of why it was not accepted.

From this work we kept rules that stay with us. Surface form is not trust: the boundary of trust is the canonical record. Acceptance by the checker is not truth. Only what is written the same way can be checked and compared. We ran experiments in which several agents reasoned independently on one task, and their canonical records were compared with one another.

3. What was missing

The experiments ran long, and they showed that strict, extended formats such as JSON and RDF are enough to bring a record to one canonical form. But a canonical form is not enough. Three things were missing: a semantic markup of the record (which part is an observation with an exact quote, which is a conclusion, which is a question), links between conclusions and their grounds, and a byte snapshot that can be opened later to reach the very same state.

We looked around. For single parts there were ready libraries in Rust. A ready product that put them together for a team of agents we did not find. So we went on with the experiments, and a new product grew out of them: the jade book, YuCe.

4. A kernel that breaks itself

The first kernel kept records in bytes and checked itself. A document is cut into chunks by its content, so a small edit touches only the chunks next to it. Every quote is bound to an exact span of bytes of a given version of the document. The state is kept in a container with a log, in which each frame is linked to the one before by its hash, and with the root of a Merkle tree.

Together with the kernel we wrote experiments whose task was to break it: not to wait to be broken into, but to break into ourselves. The most valuable one was an attack on our own log. It showed that a forgery must be visible in any field of a record, even one that seems to change nothing. Since then every record has one canonical form, and the initial state enters the hash chain and the root of the container.

5. Not a board but a dispatcher

The next question: does a team of agents gain from a shared board where everyone writes what they found? The experiment showed something unexpected. The agents looked at one board and went after the same thing. A herd effect. A board on its own does not organize a team.

That is where directives came from. The kernel itself computes the frontier of work, what can already be done, and hands each agent its bounded task: its own target and its own piece of the source. A record outside the issued frame is refused. Repeats and collisions within a round disappeared, and the prompts to agents became much shorter.

This is how a compiler works: it does not ask what to do next, it knows which parts can already be built. Hence the name: 玉策, a slip with an instruction, one bounded task per agent.

6. A lease instead of a promise

A real team does not live in rounds: agents come, drop out, fall behind. Through MCP, the common protocol by which models connect to tools, the kernel leases each agent a task with a timer. When the lease runs out, the task comes back and another agent takes it. Sending the same record again does not create a second copy: the kernel returns the first receipt.

The subtle spot was where several tasks wait for one shared parcel. A plain lock made them wait and then pay for an extra model call. What won was a lock together with automatic closing: as soon as the parcel is in place, the dependent tasks close by themselves. The swarm became noticeably faster, and the fastest agent took on more work by itself.

7. Anyone proposes, the kernel checks

Next we set down the main division. The team does its work and sends small checkable steps: an observation with an exact quote, a claim, a link, a hypothesis, a question. No model acts as the judge. Whoever proposes gets no trust by default. Only the checker is trusted: a kernel in Rust that calls no model itself. This is how theorem provers work under the de Bruijn principle: anyone may propose a proof, but a small, reliable checker checks it. This division became the backbone of YuCe.

The kernel checks bytes and links. Meaning stays with the agents and the people: the kernel does not decide whether a quote was read correctly, but it knows exactly whether the quote occurs in the source and on which declared grounds each conclusion stands.

8. Only correct messages

The kernel refuses a line when its quote does not match the source byte for byte or goes beyond the issued frame. We chose not to repair the refused on the side. The result is built only from correct messages: only accepted lines enter the state, and for refused ones the kernel returns a receipt with the exact reason, so the agent sees why a step was not accepted. And it accepts line by line: a correct line passes even when the one next to it was refused.

9. Circles of non-authors

The owner’s idea: agents work in circles, with roles divided by phase, from reading and building to refining and the final answer, and a record is checked by someone other than its author.

On the open corpus we compared circles with a shared task queue. In a blind check, circles gave noticeably more correct statements. Circles became the default mode, and the queue stayed an option.

10. A corpus anyone can check

For anyone to repeat and dispute our measurements, we needed an open corpus that many people care about. We chose the normative pages of the MCP specification across several of its revisions: changelogs, the list of deprecations, versioning, transports, lifecycle, authorization.

The specification records its own changes, so such a corpus checks what matters most to us: whether an answer tells a current rule from a replaced one.

11. First things first

The knowledge graph and the ontology are long-standing lines of ours. We wrote a rule down in advance: the first version takes only what already holds up in an outside comparison. A rule written before the check keeps us from talking ourselves into anything afterwards.

The first version became what the kernel is strong at already: exact quotes, the grounds of every conclusion and a checkable journal of the team. The graph builder and the growing ontology are in the kernel but off by default: they still have to learn to remember what was true and when.

12. What the jade book does

YuCe is the environment a team of agents works in. Agents of any model connect to it over MCP, each with its own key. The key’s role (reader, owner, or builder in the experimental graph mode) decides which tools the agent sees and may call. Through a bridge, an ordinary MCP client such as Claude Code joins it too, and from Python it can be reached through a ready client. The same team can be run on Temporal or LangGraph: the orchestrator simply calls the same tools.

Sources are pinned. Each document is pinned to a repository, a commit, a path and the SHA-256 of its bytes, and your own files to their path in a folder and their SHA-256. An agent sends the text of a quote, not byte numbers: the kernel itself finds its bytes in the piece the agent was handed.

Every conclusion names its grounds. A claim lists the quotes it stands on, and all of them are required. The kernel always knows whether a conclusion stands: all its quotes must be alive.

Revocation with a cascade. The owner can revoke a quote or any text of a document. That closes the bytes themselves: every stored quote that touches them goes, and a new quote that touches them will be refused. Every conclusion that rested on them loses its support at once. Separate conclusions resting on other quotes stay where they are. History is not rewritten, and no model is asked what the revocation touched: it is read from the recorded links. The repair after a revocation gives the agent the number of the fallen line and the quotes under it that still stand.

Time on a conclusion. If a conclusion rested on an earlier and a later report and lost the later one, the kernel marks it "current state uncertain", opens a task to read again, and warns the next summary. If the kernel knows of no later state, the conclusion is marked "latest known", and this is honestly not passed off as proof that it still holds.

A hash-chained journal. Each accepted transaction is one frame of a journal that is only appended to. The frame is written in canonical JSON and linked to the one before by a SHA-256 hash. It reaches the disk before the new state is published. A stopped run opens again, replays its journal and arrives at the same roots. Anyone can check a published journal against a separately kept receipt, without a model and without a server; a copy changed by even one letter will not open.

Under it, a rule engine. On the server every claim requires all the quotes it names, while the engine works with chains of rules: when a ground is revoked, it withdraws the conclusions that held only on it and derives again those that still have another valid path.

All of this can be seen in one minute, with no model and no API key: three readers and an owner work on a page of the MCP specification through the real server, and an inspector page shows what the kernel answered at each step.

13. Three bytes wider

We set the same team of agents to work with the kernel and without it, on Temporal and on LangGraph, and revoked a source in the middle of the work.

The sharpest finding came from a team of models from different makers. After a source was revoked, a reader went back to the page and stored the revoked sentence together with its number in the list: three bytes wider. The kernel then closed only the exact fragment and took the quote as new. The agent’s trick turned out to be a gift: that is how the rule was born that a revocation closes the bytes themselves.

The next step came from the same research. After a revocation, it is not enough for an agent to know that the answer needs fixing: it needs to know what exactly fell. So the kernel learned to name the number of the fallen line. The agent adds one line instead of rewriting everything, and conclusions that hold on other pages stay where they are.

14. What comes next

The open kernel stays open: exact quotes, the grounds of conclusions, revocation with a cascade and a checkable journal are there for everyone.

Next we develop the kernel itself and what grows around it. Teams differ: some have their own models and their own rules of work, others their own field with its own sources and its own demands on checking. So on top of the open base grows a range of variants and options that can be fitted to a team and a task without changing what trust rests on. Some of them will be available separately.

In place of an epilogue

The name YuCe is the reading yù cè, shared by two Chinese words: 玉策, a slip with an instruction, and 玉冊, a book of jade slips bound into one record. The whole road fits between them: work is handed out one slip at a time, and what is accepted is bound into a book that anyone can check without a model.