Everything you can attach

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

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

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 /api/laserbrain/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, frequency (θ–α, 4–12 Hz), clarity

two phrasings → which reads clearer, and by how much

describe a situation or stuck point, get phronesis framework guidance

heat T, moisture Q, rain R, vitality V, stress S — the field right now

exactly eight words in, the field’s reply out

the four word-groups it accepts: ground, wind, form, change

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

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

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

the field right now, or None — fails open, never invents weather

eight words from the vocabulary in, the field’s reply out

context displacement: how far the world has moved since you grounded

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