Intelligence isn't generated. It accumulates.
What should a system remember, when should it reconsider, how would it know whether it improved, and what must it never be allowed to do? Those questions are published here as protocols, implementations, experiments and evidence — and this page's own build refuses any claim it has not earned. The book is the way in; the proof below runs in your browser.
A generator answers. A system accumulates.
The agent ecosystem builds on a frozen model and prays. The limiting factor isn't raw model intelligence — it's memory architecture, deliberation structure, temporal grounding, and governance. Those are infrastructure problems, not parameter problems. Here is the gap, axis by axis.
What this page is entitled to claim.
Every surface in this portfolio carries the same five rows, and the fourth is the one that costs something to write. The chip in the band above reads ?, and it reads that because it is derived from the twelve protocol statuses rather than chosen — a page with one shipped protocol and five drafts does not get to average itself into a rung.
- Status
- The κ proof is exhaustive and runs client-side: 1,052,740 directed graphs on 2–5 nodes and 873,611 finite maps on 2–7 nodes, with 0 counterexamples. The governance floor below it is property-tested — 109 kernel laws and 101 compose laws, at 2,000 trials each. Everything else on this page is a specification, and each card says which.
- Last verified
- 2026-08-16
- Source
- The proof is in /kappa_proof.js and runs in the reader's own browser with no server. The law counts were re-derived on 2026-08-23 by running node test/laws.mjs and node test/compose-laws.mjs against the box-and-box package; both suites derive their own printed totals, and scripts/law-manifest.mjs writes them to LAW_MANIFEST.json, which every published count in the tree is checked against.
- Limit
- Exhaustive verification of an equivalence over finite structures is not evidence that routing on it helps. κ > 0 ⟺ a nontrivial strongly connected component is a theorem about graphs; that deliberating when κ > 0 produces better answers than not is an empirical claim, and nothing on this page tests it. Nine of the twelve protocols have no implementation at all, and the one benchmark figure quoted here was produced by us, on our own system.
- Next rung
- external — Someone who is not us runs the κ proof and reports the result, or benchmarks a memory system through PRISM and publishes a number we did not produce. Every figure on this page today has one author.
Three questions, and what would settle each.
A research programme is defined by what would change its mind. Each of these names where it lives in the tree, what is already established, what is not — and the specific result that would move it. The status beside each protocol is read from the protocol record, not written here.
Can the shape of a knowledge graph tell an agent when to deliberate?
Established. The κ invariant is proved exhaustively — the proof below runs in your browser and finds no counterexample.
Not established. That topology can be measured says nothing about whether routing on it helps. The routing benefit is untested, and it is this page's own stated limit.
What would settle it. One measured task where κ-routing beats both always-retrieve and always-deliberate on the same corpus. OS-005 makes the sharper bet — that the margin inverts on cheap hardware, because topology is most valuable when it tells you to skip an expensive inference entirely.
Can memory improve continuously without quietly corrupting itself?
Established. One system runs the loop and another measures it, end to end.
Not established. The instrument and the subject are both ours. A benchmark we wrote, scoring a system we wrote, is not evidence about either — and PRISM rewrites its own scenarios as systems improve, so if the benchmark optimises against the system it measures, the score stops meaning anything at some point nobody has located.
What would settle it. Someone who is not us, running the benchmark against a system that is not ours. Beneath it a narrower question we can answer in-house: should consolidation fire on surprise (OS-011 emits prediction error into the loop) or on a schedule — and which actually crystallises better knowledge?
Can autonomous agents coordinate without surrendering accountability?
Established. The governance floor underneath the stack decides one action at a time and ships a certificate with every verdict.
Not established. Coordination as such is not something OpenSentience has. A floor that governs a single decision is not a protocol for many agents holding to it at once, and nothing here has shown that. Printing a question with no work behind it is the point.
What would settle it. A run in which agents with conflicting claims reach a safe outcome with no central arbiter, and every step is auditable afterwards. OS-012 SCOPE sketched typed spatial claims checked pairwise — it is deferred and has no spec file, so it is a sketch, not an answer.
And behind all three, the one this site exists to ask: if a system holds the right relationships at high confidence and can navigate them to answer, does it understand the domain?
We don't ask you to trust the thesis. We ship the receipts.
Every claim here is checkable. The headline κ proof runs exhaustively, in your browser, with no server and no trust required — and it's only one of the receipts.
topology ON 92.6% vs OFF 92.3% — +0.3pp QA, +0.8pp session hit rate. That ablation is the only comparison measured.
0 counterexamples · exhaustive, and it runs in your browser below
the governance floor, property-tested — this is the KERNEL scope; the compose/CC2 suite is counted separately and the enforced total is derived under the stack, not typed here
then adversarial testing crashed it to 0.45 and surfaced real bugs we fixed
teach a skill on machine A, replay it on machine B (OS-011 Embodiment)
The κ invariant OS-002 · topology as a cognition signal
DAG region
SCC region
The graph's structure mechanically determines the prompt structure — no human prompt engineering. The topology is the reasoning template. The Deliberator writes conclusions back as new nodes, so κ falls as uncertainty crystallizes into settled knowledge.
Verify it yourself 1,926,351 finite systems · 0 counterexamples
Part 1 — Directed graphs (n=2..5): for all 1,052,740 graphs, verify κ(G) > 0 ⟺ β₁(G) > 0 ⟺ G has a nontrivial strongly connected component.
Part 2 — Finite dynamical systems (n=2..7): for all 873,611 maps f:[n]→[n], verify κ(TransitionGraph(f)) > 0 ⟺ f has a periodic orbit of period > 1.
Part 1: Directed graphs
| n | Graphs | With SCCs | Failures | r(κ, β₁) | Time | Status |
|---|
Part 2: Finite dynamical systems
| n | Maps | Periodic | Failures | Time | Status |
|---|
From theorem to shipping product
The proof verifies the invariant across 1,926,351 mathematical objects. Here is what happens when κ meets a real knowledge graph on a live MCP server.
Store a business cycle
4 nodes stored: Market Share → Revenue → R&D → Product Quality → Market Share All edges: causal type MCP tools used: store_node × 4, then edge creation
Analyze topology
routing: deliberate max_kappa: 1 scc_count: 1 fault_line: Product Quality → Market Share deliberation: max_iterations: 2, agents: 1, confidence: 0.75
The stack, status-aware.
[&] composes agents. PULSE gives them a heartbeat. PRISM measures their effect. They're independent — adopt one without the others — and they stack, mirroring how HTTP, HTML and CSS converged in the browser. Underneath them all sits an un-weakenable governance floor.
Cognition is a loop, not a prompt.
Every system in the [&] portfolio runs the same five-phase loop — the canonical PULSE phase kinds, which are exactly the Graphonomous machine architecture. Each phase is a place where a protocol does its work. The loop is wrapped by governance, clocked by PULSE, gauged by PRISM, and bounded by SCOPE.
Wrapped, clocked, gauged & bounded —
every phase runs under permissions, audit, and three autonomy levels
declares the loop's phases, cadence, and cross-loop signals
measures how well the loop performs over time
bounds where agents may act over shared space
12 protocols. The shape of a mind.
Not a list — a structure. Eight cognitive primitives (OS-001 → OS-008), each one capability of an intelligent system, grounded in cognitive science. Above them, four cross-cutting algebras that measure, time, embody, and bound the whole — the rings around the loop. Range OS-001 → OS-012, every entry honest about its status.
Eight cognitive primitives OS-001 → OS-008 · the capabilities
Graphonomous: Knowledge Graphs for Continual Agent Learning
A graph-backed memory engine where agents store episodic, semantic, and procedural knowledge as typed nodes with confidence scores and provenance chains. Multi-timescale consolidation inspired by hippocampal replay — fast memory promotes to slow memory, weak connections decay, strong patterns crystallize. Outcome-driven learning updates confidence across causal chains, not just individual nodes.
κ-Routing: When to Retrieve, When to Deliberate
The cyclicity invariant κ (kappa) detects irreducible feedback loops in a knowledge graph. When κ = 0, the subgraph is a DAG — retrieve context in one pass. When κ > 0, circular dependencies exist — iterate and deliberate before answering. κ determines not just whether to think harder, but how entangled the reasoning is. Proved on 1,926,351 finite systems with zero counterexamples. Fault-line edges (minimum cuts within SCCs) become the mechanical decomposition boundaries for deliberation.
Topology-Driven Deliberation: Fault Lines as Prompt Boundaries
When κ > 0, fault-line edges become prompt boundaries. The Deliberator decomposes circular knowledge along those boundaries, runs focused reasoning passes on each partition, reconciles them, and writes conclusions back into the graph — reducing κ over time as uncertainty crystallizes into settled knowledge. Single-agent fast path; escalates to multi-agent formal argumentation (Deliberatic) only when convergence fails.
Proactive Attention: Self-Directed Cognition Without Queries
The missing ignition in a reactive system. The Attention Engine is a periodic loop that examines the knowledge graph's topology, coverage gaps, and active goals to decide what the system should reason about, learn about, or act on next — without waiting for a query. Three modes: Explore (what don't I know?), Plan (what should I do?), and Focus (where should I spend compute?). Not a 5th cognitive primitive — attention is meta-reasoning over the existing four.
Hardware-Adaptive Cognition: Same Topology, Different Depth
κ routing becomes more valuable on constrained hardware — it tells the system when to skip expensive inference entirely. Three tiers (local 8B, local 70B+, cloud frontier) with qualitatively different strategies: single-pass enrichment vs. multi-pass deliberation, demand-triggered vs. heartbeat attention, aggressive crystallization vs. fresh inference. The κ paradox: ROI of topological routing is highest when inference is most expensive.
Thin Governance: Permissions, Audit, and Lifecycle for Any Runtime
A lightweight governance layer — not a full runtime — that wraps around any OTP-based agent system (Jido, Alloy, or raw GenServer). Provides the permission taxonomy (filesystem, network, tool invocation, graph access), audit trail, agent lifecycle states (installed → enabled → running), and three autonomy levels (observe, advise, act). Designed as a hex package dependency, not a daemon.
Pattern Recognition and Threat Defense
Defines how agent systems detect and defend against adversarial inputs, compromised agents, and knowledge poisoning. Five threat categories: prompt injection, knowledge poisoning (BadRAG/TrojanRAG), agent impersonation, privilege escalation, and denial of service.
Pipeline Enforcement and Quality Gates
The enforcement runtime that sits above agents and below humans. Orchestrates [&] pipelines, enforces governance contracts, gates execution on epistemic confidence. Five components: PipelineEnforcer, QualityGate, ContractValidator, SprintController, ContextManager.
Four cross-cutting algebras OS-009 → OS-012 · the rings
Protocol for Rating Iterative System Memory
The first self-improving continual learning benchmark. 9 CL dimensions, 3-layer judging (transcripts → dimension judges → meta-judges), IRT difficulty calibration, and scenario evolution. Two closed loops interlocking: PRISM improves the benchmark, Graphonomous improves the memory. We used it to benchmark ourselves — score went from 0.10 to 0.99 in 4 cycles, then adversarial testing crashed it back to 0.45 and we fixed real bugs.
Protocol for Uniform Loop State Exchange
The temporal algebra of the [&] stack. Where [&] declares what agents can compose, PULSE declares how their processes cycle over time — phases, cadence, substrates, invariants, and cross-loop signaling. Five canonical phase kinds, six cadence types, six canonical tokens, seven invariants. Any conforming loop becomes automatically PRISM-evaluable without integration work. The circulatory system that makes [&] a stack instead of a pile.
The Sensorimotor Loop for &body.*
Closes the perception-action gap. Defines the typed perceive → act → affordances → encode_state → replay loop that any &body provider implements — the agent's instantiation in an environment. Emits a SurpriseSignal (forward-model prediction error) into PULSE, so embodiment loops can drive learning in the memory loop. InteractionTrace schema, five invariants, twelve conformance tests.
Spatial Claims and Coordination Protocol for Embodied Environments
The spatial algebra of the [&] stack. Where PULSE governs when loops cycle, SCOPE governs where agents act — an N-D Region algebra (intersect, union, contains, overlaps) and a typed SpatialClaim envelope: a first-class assertion of intent over a region, so multiple agents can broadcast, detect conflict, and coordinate over shared space without a central arbiter. Supersedes OS-015 Viewport Binding; subsumes six ad-hoc coordination concerns into one algebra.
Grounded in cognitive science, not analogy
Tulving's episodic/semantic split; multi-store memory; hippocampal–neocortical replay. Graphonomous consolidates fast→slow on idle.
Kahneman's dual-process theory. κ-routing implements the System-1/System-2 split mechanically, from graph topology alone.
Temporal-difference learning; sequence timing. PULSE gives every loop a declared cadence and cross-loop signals.
O'Keefe & Nadel's cognitive-map theory; place & grid cells. SCOPE is an N-D region algebra for shared-space coordination.
The governance floor box-and-box · 109 kernel laws × 2000 trials
Protocols say what a system can do. box-and-box answers
the question underneath them all: given everything it could
do, what is it allowed to do, and which option is best? An
eight-rung modality ladder, each rung a small
algebra with stated laws, composed by one bridge that runs
feasible ▸ permitted ▸ best over a
safety floor that cannot be weakened. Every verdict ships a
certificate.
Two counts, two scopes — and they are not a
discrepancy. node test/laws.mjs enforces
the 109 kernel laws — the eight
rungs and their bridges — which is the suite this page and the
playground refer to. node test/compose-laws.mjs
enforces a further 101 compose/CC2
laws (the & and |>
brick operators; 14 in the suite plus the AC-COMM anchor), for
210 enforced in total — the number
ampersandboxdesign.com
quotes. It also declares 3 open
gaps (CP5/CP6/CP7, the Value.pi carrier)
which print FALSIFIED in red by design; the build fails
if one starts passing. Counts measured by running both suites on
2026-08-24, at
2,000 trials per law. Nothing
here is fetched at runtime — re-run the suites to check us.
The catalog as evidence.
Unboxed Patterns is a generated registry: every entry carries the rung its evidence has earned, and the build refuses an entry whose witness does not check out. It is the source material the book is written from — a catalogue and an editorial narrative serve different readers, and today they are the same object. When an edition is written it gets its own record, and the invitation above changes by itself, because nobody types it.
That third number is the one that matters and it is the one that is hard to move. Everything else on this page is us checking our own work.
Open the catalog- 2 deployed
- 13 in the tree
- 1 written down
- 16 no witness yet
One mark per chapter, coloured by the rung its evidence has earned — a filled mark is witnessed, an empty ring is not. Nothing here was drawn by hand. The book is read on the web; there is no file.
Three rungs, three different invitations.
A page may only ask you to do what its evidence has earned. The κ proof is deployed and runs on your machine, so it asks you to run it. The governance floor is written and property-tested, so it asks you to run the suites and read the source. The rest is a specification, so it can ask you to read it, argue with it or implement it — and never to run something that does not exist. The verbs below are not chosen; they are the ones each rung allows, and the build refuses any other.
node test/laws.mjs && node test/compose-laws.mjs. The three open gaps print FALSIFIED in red by design, and the build fails if one starts passing.
Inspect the sourceThe playground wires the core suite into a browser sandbox, so you can watch a law hold — or break one and watch the bridge refuse.
spec.
Or come in as a researcher, a builder, a skeptic
Researcher
Read the specs and the cognitive-science grounding behind every protocol. Twelve numbered specs, full reference lists, no marketing.
Builder
Wire the loop into your own agent. Graphonomous is the shipped memory engine (npm + MCP); the governance shim is a hex package that wraps any OTP tree.
Start a Graphonomous session for this repo. 1. retrieve(action:"context", query:"session context") 2. route(action:"attention_survey") Then work, storing durable knowledge as we go.
Skeptic
Don't trust us — run it. The κ proof is right above. Or point PRISM at your own repo (BYOR) and benchmark any memory system, including ours, end to end.
config(action:"register_system", name:"graphonomous")
compose(action:"byor_register", repo_url:".")
compose(action:"scenarios") → interact(action:"run")
observe(action:"judge_transcript") → reflect("analyze_gaps")
Or tell us we have a number wrong
This page prints an exhaustive proof, two law counts and twelve
protocol statuses, and every one of them has a single author —
us. The most useful message this site can receive is the one
that says a figure on it does not hold. The form posts to
formspree.io when you press the button,
carrying what you typed and nothing else; it is the only thing
on this page that talks to anyone but this domain. If you would
rather the correction be public,
open an issue instead.
Standing on the work of others.
Cognitive Architectures
- [1] Newell, A. (1990). Unified Theories of Cognition. Harvard University Press.
- [2] Laird, J.E. (2012). The Soar Cognitive Architecture. MIT Press.
- [3] Anderson, J.R. (2007). How Can the Human Mind Occur in the Physical Universe? Oxford University Press. (ACT-R)
- [4] Sumers et al. (2023). "Cognitive Architectures for Language Agents (CoALA)." arXiv:2309.02427.
Memory & Neuroscience
- [5] Tulving, E. (1972, 1983). Distinction between episodic and semantic memory.
- [6] Baddeley, A. & Hitch, G. (1974). Working memory model.
- [7] O'Keefe, J. & Nadel, L. (1978). The Hippocampus as a Cognitive Map.
- [8] Burgess et al. (2002). Hippocampal function including temporal and spatial-associative retrievals.
- [9] Behrouz & Mirrokni (Google Research, NeurIPS 2025). "Nested Learning" — HOPE architecture for multi-timescale memory.
- [10] Zheng et al. (2025). "Machine Memory Intelligence: Inspired by Human Memory Mechanisms." Engineering, 55(12): 24-35.
- [11] Liu et al. (2025). "Memory in the Age of AI Agents: A Survey." arXiv.
Agent Protocols & Deliberation
- [12] Anthropic (2024-2025). Model Context Protocol (MCP). modelcontextprotocol.io.
- [13] Google (2025). Agent-to-Agent Protocol (A2A). github.com/google/A2A.
- [14] Kaesberg et al. (ACL 2025). Multi-agent deliberation protocols outperforming voting approaches.
- [15] Rodriguez-Sanchez et al. (Jan 2026). "DALIA: Declarative Agentic Layer for Intelligent Agents." arXiv:2601.17435.
- [16] IBM / Linux Foundation (2025). Agent Communication Protocol (ACP).
Modal Logic, Decision Theory & Measurement
- [17] Kripke, S.A. (1963). "Semantical Considerations on Modal Logic." Acta Philosophica Fennica, 16: 83-94. (alethic rung)
- [18] von Wright, G.H. (1951). "Deontic Logic." Mind, 60(237): 1-15. (deontic rung)
- [19] Pnueli, A. (1977). "The Temporal Logic of Programs." 18th FOCS: 46-57. (temporal rung)
- [20] Hintikka, J. (1962). Knowledge and Belief: An Introduction to the Logic of the Two Notions. Cornell University Press. (epistemic rung)
- [21] von Neumann, J. & Morgenstern, O. (1944). Theory of Games and Economic Behavior. Princeton University Press. (strategic rung)
- [22] Savage, L.J. (1954). The Foundations of Statistics. Wiley. (axiological / value rung)
- [23] Kahneman, D. (2011). Thinking, Fast and Slow. Farrar, Straus and Giroux. (dual-process grounding for κ-routing)
- [24] Rasch, G. (1960). Probabilistic Models for Some Intelligence and Attainment Tests; Lord, F.M. (1980). Applications of Item Response Theory. (PRISM difficulty calibration)
Industry & Surveys
- [25] Gartner (2025). 40% of enterprise apps will embed AI agents by end of 2026.
- [26] ICLR 2026 Workshop. "MemAgents: Memory for LLM-Based Agentic Systems."
- [27] VentureBeat (Jan 2026). "Continual learning shifts rigor toward memory provenance and retention."
- [28] Chen et al. (2025). "AI Meets Brain: A Unified Survey on Memory Systems." arXiv:2512.23343.