How Soil verifies a handover

Most tools that "summarise a conversation" ask you to trust the summary. Soil does something different: it lets a handover prove it works by actually being loaded into a fresh model and continuing the work. The headline:

Why "it reads well" is not enough

A handover can look complete and still fail the only test that matters: can a different, cold model pick up the work and continue? Reading nicely and continuing correctly are not the same thing. So Soil's standard isn't "this looks thorough". It's "a fresh model, given only this, actually continued".

The two models in the room are the judges

There are exactly two models involved in any save-then-load:

• the model you save from, which, at the moment you save, still has the full context of your conversation, and
• the model you load into later, which starts cold with nothing but the handover.

Soil uses both of them, and only them. No third model grades the result and no hidden "AI judge" sits between you and the score. The test runs on your real models, in real conditions, which is exactly what keeps it honest.

How the check works, in plain terms

1. At save time, the from-model writes the answer key. While it still has full context (the only moment anything truly knows the answers), it notes the handful of key things any faithful continuation must get right, and records the correct answers itself. The handover quietly writes its own short answer key.
2. At load time, the to-model takes the test cold. When you later load the handover into a fresh model, that model answers the same key questions using only the handover, which is exactly the situation a real continuation faces.
3. Soil compares the two. The cold answers are scored deterministically against the from-model's answer key · pass, unknown, or wrong. A pass means the handover carried what it needed to; an unknown or a wrong points at exactly what a continuation would have had to guess.

Everything stored along the way is a safe projection: the questions, the reference answers, and the cold answers all pass the same safety boundary, so no secrets are ever kept.

Built to catch more than forgetting

Five things make the check hard to pass by luck, and each is described here in plain language:

• Some check questions are deliberate trick questions. They are built from decisions that changed along the way, and they assume the old, changed decision is still true. The loading model passes only by correcting the question, not by agreeing with it. A model that just parrots the summary fails exactly there · which is the point, because quietly reverting to an old decision is the most expensive kind of drift.
• Critical values and your project's own terms are carried word for word. Exact numbers, names, versions, and the vocabulary your project actually uses are preserved verbatim, not paraphrased. The next model inherits your precise values and speaks your project's language, so nothing load-bearing gets blurred in translation.
• A decision that was argued about keeps that history. When something was disputed and then resolved, the handover records that it was contested and how it settled. A fresh model will not quietly reopen a question you already closed, because it can see the question was fought over and won.
• A truth that holds only under conditions keeps its conditions. A decision or constraint that is valid while a limit holds, until a date, or only in one environment is carried with that bound attached · "valid while / until / only when" · never flattened into a false absolute. The next model inherits the rule and its scope together, so it does not apply a scoped truth where it no longer holds.
• Each next step names the decisions that govern it. A step does not just sit near the locked decisions and constraints; it points at the ones that bind how it must be done. So the next model applies those facts while acting on the step, instead of reciting them in one place and ignoring them in another.

Two signals, told apart honestly

Soil is careful not to dress up a guess as a measurement:

• Save-time is a humble forecast. When you save, the from-model also role-plays a fresh reader and flags likely gaps. This is a useful hint about how continuable the handover looks, but it is one model talking to itself, so Soil presents it humbly, not as proof.
• Load-time is the real measurement. The test only completes when you actually load the handover into a second model and it answers cold, scored deterministically · pass, unknown, or wrong. That is the authoritative continuity signal, because the round-trip genuinely happened across your two real models. It runs today on project loads (soil load @project).

One thing sits deliberately outside both signals: the working-style observations a save records. Those are raw recorded answers, shown at load exactly as written · never scored, never graded, and never part of the readiness band or the recall check.

Why this is the honest way to do it

This design follows Soil's core rule: never overclaim. Soil doesn't assert "this handover is high quality". It arranges for your own models to demonstrate continuity, surfaces the result plainly, and tells the forecast apart from the measurement. Over many real saves and loads, the record of how handovers actually continued is what lets Soil keep improving the recipe, quietly, from real usage.