How it stands

How an answer is held to the record.

The model can say anything. This page shows where its claims get compared, who decides, what happens next, and what we cannot show.

Honest, here, means a claim stays within its evidence. It does not mean the claim is true.

The STAND pattern, letter by letter

ReAct, the reason-and-act loop, is how an agent works. STAND is how its claims are held to the record.

State the rules Declare · Map

Fixed before the run, so they cannot be fitted to the answer.

Marked factsA tool marks the values that matter.Typed facts per entity, with provenance, make a contradiction representable.describedResult({ facts })
Declared limitsA tool says what it checked, skipped or did not find.Limits are trusted declarations that become reasons on the standing.absent(), coverage()
What a search coveredOne call’s “nothing found” states exactly what it searched.Arguments are classified by role, and coverage is composed per call.Tool.search
Structured answerThe answer must fit your schema. Retries are your choice.No retry by default. { retries: N } adds N teaching turns..outputSchema()
Field to factYou say which answer field reports which fact.Declared, never inferred. It makes the contradiction decidable..claims()
Caveat gate in CIA check you run in CI fails tools that forgot their caveats.Class rules are errors. Overclaim rules warn unless strict or selected.checkSemantics

Trace the run Record · Trace

A record the model did not write, kept by the flowchart as it runs.

Every step writes a noteEach step’s reads and writes are captured with no annotations.TypedScope tracks reads and writes through a Proxy and commits per stage.FootprintJS stages
The model’s words as claimsWhy it called a tool and what it made of the result, filed as claims.A model declaration is never support. Silence means those checks do not run._findings
“No check ran” is a stateEach integrity check says whether it passed, failed or could not run.checked-pass, checked-fail, not-applicable and unreachable, per check.disposition ledger
The same verdict laterThe saved record gives the same standing as the live run.One pure fold over committed rows, with no clock, network or model.assessAnswer(recording)

Assess the claims Compare · Walker

Code compares. No model judges. It catches what the record can contradict.

1 Calling a tool

The model picks a tool and fills in its inputs.

Check	Compares	Who decides	What happens
Argument schema`inputSchema`	The arguments against the tool’s schema	Code	Rejected, with the reason.
Permission policy`PermissionPolicy`	The call against your policy	Code	Denied or halted.
Check in`checkIn`	The call against your rule, then a person	Code, then a person	Pauses for approval.
Ask or assume`askOrAssume`	A missing value against the tool’s rule	Code	Asks once before anything runs, or fills it in and says so.
Where a value came from`argumentSources`	The source the model cites against the person’s words or a result	Code, when the model declares	Runs, asks or flags.
Made-up tool inputs`argumentsFrom`	An ID the model passes against what it was shown	Code	Recorded only. The tool still runs.

Which tool to call stays the model’s choice, and this is the thinnest part. An unknown tool is refused. The rest is recorded.

2 Reading a result

A tool returns something, and the model decides what it means.

Check	Compares	Who decides	What happens
Declared limits`absent(), coverage()`	What the tool says it checked and skipped	The tool declares, and code reads it	A reason on the standing.
Empty result	An empty result with nothing declared	Code	A reason on the standing.
Time window`period`	The period asked against the period held	Code	A reason on the standing.
Column types`resultColumns`	Rows against the declared columns	Code	Off by default. Warns, or refuses the rows.
Conflicting readings`.findings()`	Two readings the model stood on for one fact	Code, when the model declares	A reason on the standing.
A judge on tool results`.findings({ judge })`	The result against the model’s proposition	A classifier	Filed apart. It never sets the standing.

3 Giving the answer

The model says what it found.

Check	Compares	Who decides	What happens
Answer shape`.outputSchema()`	The answer against your parser	Code	No retry by default. { retries: N } gives N corrective turns.
Invented values`.namesAndNumbersFromEvidence()`	Long numbers and IDs against tool results. Small numbers are skipped	Code	Flags it, gives one more turn, or refuses, by posture.
Contradiction`.claims()`	A structured field against a fact the tool marked	Code	Recorded on its own. Withheld when an enforcing check lists it.
Did it run at all`context.toolCalls`	The answer against the tools that ran	Your code	Through your check.
Code shown`Tool.script`	Code in the answer against the program submitted	Code	Marked unmatched.
Steps left undone`skill steps`	The answer against a skill’s declared steps	Code	A reason on the standing.
“Not found” stretched too far`.negativeClaims()`	“None” against what the search covered	Code	Opt-in and unmeasured. Not recommended yet.
Your own rule`.answerValidation()`	Anything you write	Your code	Enforce withholds. Observe records. The only path to known.

Name the standing Conclude · Fold

One of five words, with its reason. Not a percentage.

KnownA check you wrote passed for this answer. The library cannot see how your check decided.Needs a passed enforcing answerValidation report. Never known from silence.
ConsistentChecks ran and found nothing wrong. The library says this is not a verification.unrefuted. A membership pass keeps a reason from firing and supports nothing.
Not sureA check found a problem, and the reason is shown.Each reason names its source: specific calls, the answer or the run.
AskThe run is waiting on a person.Any pause reads ask, from the recording alone.
Not assessedNothing could be checked.not-applicable. A different state from a clean result.

Decide what happens Act · Lens and your app

Your policy, in your code. Withholding does not undo a tool action already taken.

FlagThe answer goes out, and the problem is recorded.The default posture. You learn the rate before you act on it.posture: 'assist'
One more turnInvented values are named back, and the model gets one revision.Latched at one per turn. The rewrite is the model’s, and the re-check is code.posture: 'guard'
RefuseAfter one revision, the run raises an error instead of returning.UnsupportedValuesError. It does not suppress streamed draft tokens.posture: 'rails'
WithholdA structured answer that fails is withheld. Nothing streams.AnswerValidationError, or HTTP 422 through a hosting door.mode: 'enforce'
Observe firstThe same checks run and the answer is delivered with its standing.A failed report reads not sure with answer-check-failed.mode: 'observe'
Show the personOne plain line after the answer, written by the library.Prose answers only. On typed answers the standing arrives as data.standingLine
Explain this answerWhat was checked, what was not, and who vouches for each line.Fixed versioned templates over the record, never a model.accountForAnswer

Recorded only means the check files what it found and does not move the answer’s standing today.

What the model is told

Most checks add nothing to what the model is sent. Here is what each setting adds.

Setting	Added to the prompt	Sent back to the model
`.answerLayer()`	Nothing	No. The line is added to the delivered answer.
`.namesAndNumbersFromEvidence()`	Nothing, until guard or rails fires	Under guard and rails, one repair turn with a recovery instruction.
`.outputSchema()`	One fixed JSON-format sentence	Only with `{ retries: N }`.
`.claims()`, `.answerValidation()`	Nothing beyond that sentence	Never. Re-asking would invite the model to change the claim, not the facts.
`.findings()`	A fixed instruction on how to declare, and `_findings` on every tool	No.

After an answer exists, the model is asked again in four cases: an invented value under guard or rails, a bad shape with retries on, unfinished steps, and a bad citation on a “not found” claim. A run that hits its limit gets one separate wrap-up call.

When the answer leaves

Path	When streamed text leaves	If a check finds a problem
Structured answer, enforcing check	After the checks	Withheld. Nothing streamed.
Structured answer, observing check	After the checks and the standing	Delivered, with its standing.
Prose with the answer layer	Before the standing is worked out	Delivered, and the standing arrives right after.
Prose with `rails`	Before the checks finish	Both drafts streamed, then `run()` throws.

So “checked before anyone sees it” holds only for structured answers with a check, or when nothing streams. Prose can never reach known.

Where it stops

A silent model. Checks on what the model declares run only when it declares. A model that says nothing reads consistent.
Trusted tools. A tool’s declarations are trusted. A tool that misstates what it searched gets an honest-looking standing.
Your own check. It can call a model, and the library cannot see how it decided. A stub that always passes still reads known.
Rewrites. Under guard or a schema retry the new answer is the model’s. Only the re-check is code.
Findings that do not move the word yet. A contradiction on its own, a made-up tool input and evidence from an earlier turn are recorded, and the word can still read consistent or not assessed.
Opt-in. Almost every check is opt-in, and a tool that marks nothing gets compared with nothing.
The world. A false sentence built from real values can pass. The record is not the world.

What we have not measured

The results on this page come from a scripted model. That shows how the checks behave. It does not show how often a real model trips them.
We have no measured rate for how many wrong answers this catches.
Does serving the record back to the model make it more honest? We cannot say yet. In one ten-run test it made no difference to citing junk records, and answers kept fewer real facts. In a later one, citing junk fell from 7 runs in 10 to between 2 and 5, and answers again kept fewer real facts. Ten runs swing by a run or two.
More honest, or just more silent? The record alone cannot answer that. It needs blind hand labels, and that study has not reported.