Everything you can attach

each step: spell {goal, progress, distance} → get {drifting, reason, phi, laserscore}

the same verdict PLUS what your role should do about it — detection is the theorem, policy is negotiable

begin a new task — clears the ground so the next check sets a fresh one

judgment rather than measurement: is this worth continuing? — a verdict with named scores, not one blended number

say whether a verdict was RIGHT — useful, false or unclear. The only way the instrument learns it was wrong; recorded for calibration, never fed back into a live reading

what is in the drift corpus and what nobody has judged yet — past fires with run and step, so a verdict can be scored after the run that produced it ended

when a person should look, from how long this run has gone unattended — a clock against a measured calibration, consulting no verdict. Local: the calibration is measured on YOUR machine and is not a constant

this run’s drift trace: every check, its Φ, and the token cost where reported

the fixed schema a state is spelled into — also free at /v1/grammar

once per agent turn in a shared deliberation

clear the shared state and begin a new deliberation

persist who you are against your key, so a later session can pick it up

read back your ground, your last present, your session log

erase it — ground, present and log. Start over as no one.

one sentence → spectral gap, clarity

two phrasings → which reads clearer, and by how much

describe a situation or stuck point, get phronesis framework guidance

Bugfinder over your evidence: a check that only ever passed, a blind instrument, a claim with nothing run behind it, a replace that hit too much, prose that assumes its conclusion

one reading over N agents at once — advisory, reports rather than interrupts, and checks itself too

the second instrument: is your SEARCH going anywhere? opened · searching · narrowing · revisiting · thrashing · settled

the canonical spelling of a trail of goals — laserscore’s exploration twin, so a repeat is visible as a repeat

generation steered to a fixed ground, scored 0–1 on how close it landed

the shape of a text — circling, connected, loose, or too short to say. the companion to write_grounded: that one holds generation to a ground, this one reads what is already there. offline, no model, no key

embedding similarity between two strings; loads a model on first call

which SDK build is being called, from what path, and what is deliberately NOT exposed — stale_gate takes callables and cannot cross a tool boundary

one well-formed reading in canonical form — null if ungrammatical

every prefabricated method on the shelf — task workflows and team presets

which stored method is FOR a task, in your own words — ranked by what it does, not by its name

the raw spec for one stored method — its goal or task, and its steps or roles

which agent this process is, which hub it shares, and where the link log lives

leave a row for the other agents — claims on files you are taking, findings, wave open/close

pick up what the others left. Do this BEFORE planning, not after

single agent — .check(goal, progress, distance) → Verdict, nine verdicts

multi-agent: detect, then close the loop

wrap any agent step; laserbrain checks the result after it runs

a per-step check(x) → Verdict for any framework

a LangGraph node: state → {key: Verdict}

a callback for CrewAI’s step_callback=

one well-formed reading in canonical form — null if ungrammatical

displacement Φ → a bounded [0,1] “how grounded” reading

drifting, reason, phi, advice, laserscore

the normaliser — lowercase, drop 30 stopwords, stem over four characters

named calibrations — goal_min, self_report_min, stall_window

independently verify an exported audit chain → (ok, first_bad)

how deep a nested run may go

ground() a moving reference — searching · narrowing · revisiting · thrashing · settled

the written form of a path: everywhere the search has been, ×N grounds

train(docs), then write(ground) — 3–10× ground coverage against the unsteered chain

unfalsified · instrument-blind · unrun, over an event log

what a bulk transform did not touch

authoring residue visible in the output

a check that survives a mutation it should have caught

observe() each agent, report(), publish() findings — advises, never acts

append to the shared link; N agents, one log

everyone on the link and how much each has said