One pipeline, one gate.
Every frame flows through the same refuse-to-guess pipeline: sample → route/cache fast tiers → judge → gate → deliver. The model is called only when the cheaper tiers cannot resolve the goal, and one gate decides what you hear about. Below: the whole system as a schematic, three animated plates of its core loops, and the fourteen modules that share the frozen vocabulary.
The end-to-end schematic.
Follow the ink line left to right — the frame's journey and the only path that spends money, at the judge. Dashed lines are the returns the hot path never waits on: episodic priors folded back into sampling, and the trace tapped down to the offline rail. The judge fans up to Sensing & Signals for cheap cues and down to Backends for the model call; the gate fans right to the three outcomes.
Five bands — declare, hot path, persist, foundation, offline. Every label is a real module or seam; scroll the diagram sideways on a narrow screen.
Three plates.
The watch loop selects one frame from a continuous stream; the cost cascade spends the model only as a last resort; the consequence gate turns a verdict into exactly one of fire, ask, or silent. Motion pauses when off-screen and holds a resting frame when you prefer reduced motion — the readouts are illustrative instrument telemetry, not benchmarks.
The watch loop
Frames arrive without pause and mostly pass through as faint outlines. SamplingController asks its SensePolicy whether this instant is worth sensing; the tier-0 gate latches a single frame on the rising edge and seals it into an EventCapsule.
The cost cascade
An admitted frame falls through three tiers of rising cost. RouteEngine tries a local regex route; on a defer it drops to FrameHashLayer, a near-frame cache; only a miss escalates to the Judge, which authorizes, binds to a SHA-256-verified static context, and dispatches a model. Fail-closed at every step.
The consequence gate
One dot leaves the Gate along exactly one of three routes; only the route it takes illuminates — the two it declines stay dark. FIRE delivers an incident, ASK defers to a human, SILENT logs and suppresses. The gate fires only on the rising edge — so most cycles stay silent.
The fourteen modules, mapped.
From the frozen contracts at the bottom to the edge harness at the top, every subsystem feeds the same pipeline. Each chip is distilled on the modules page.
DTOs, Protocols, the safety envelope, CONTRACT_VERSION
layered Settings + versioned profiles, resolved with provenance
the watch() seam, goal desugaring, two-phase atomic apply
the Percept orchestrator + the three-state gate
local fast-path route engine
frame-hash cascade
authorize → SHA-256 bind → dispatch
vendor adapters behind Protocols
entity graph, re-id, OCR, rhythm
memory + opaque evidence handles
the front door: source → core → safe sinks
one funnel, trace, replay, visualizer, doctor
offline, pre-registered ship-gate
edge sim + test/bench (percept.edge)
Where the seams live.
Contracts sit at the bottom of the layering — imported by the cognition core, never the reverse. Fourteen modules share that frozen vocabulary; each one is distilled on the modules page.
percept # pip install percept-vision · import percept percept.watch(...) # frozen entrypoint — WATCH_VERSION "1.1.0" percept.run(...) / .start(...) # batteries-included runtime front door percept.Percept # the cognition core — create / configure / from_bundle percept.contracts.watchplan # WatchPlan, ArtifactBinding — typed, portable plans percept.edge.tier0 # tier-0 gate reference — bit-identical with the JS/WASM edge percept.edge.detectors # cheap high-fps detectors — motion, onset, pose CONTRACT_VERSION = "1.10.0" # frozen data contract — MAJOR bump, never a silent edit