A language model that can't remember yesterday, weigh evidence across sessions, or learn from where it's deployed is a generator — not a system. OpenSentience is the open research program defining the protocols that close that gap.
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.
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
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.
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.
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.
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.
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.
κ 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.
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.
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.
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.
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.
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.
&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.
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.
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.
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.
Graphonomous (OS-001), shipped · graph-backed memory beats flat RAG
0 counterexamples · exhaustive, and it runs in your browser below
the governance floor, property-tested — every verdict ships a certificate
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 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.
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.
| n | Graphs | With SCCs | Failures | r(κ, β₁) | Time | Status |
|---|
| n | Maps | Periodic | Failures | Time | Status |
|---|
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.
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
routing: deliberate max_kappa: 1 scc_count: 1 fault_line: Product Quality → Market Share deliberation: max_iterations: 2, agents: 1, confidence: 0.75
[&] 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.
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.
A research program publishes its unknowns. These are genuine open questions driving the work — the honest edge of the protocols.
OS-005's hypothesis is that topological routing matters more on an 8B local model — because it tells you when to skip expensive inference entirely. Plausible, but unproven at scale.
PRISM rewrites its own scenarios as systems improve. If the benchmark optimizes against the system it measures, when does the score stop meaning anything?
OS-011 emits a SurpriseSignal (forward-model prediction error) into the memory loop. Should learning fire on surprise, on a schedule, or both — and which actually crystallizes better knowledge?
SCOPE lets agents broadcast typed SpatialClaims and detect conflict pairwise. Does that converge to safe coordination, or does it need a referee after all?
If a system holds the right relationships at high confidence and can navigate them to answer, does it understand the domain? This is the question OpenSentience exists to explore.
OpenSentience is open research. Whoever you are, there's a way to use it, build on it, or try to break it.
Read the specs and the cognitive-science grounding behind every protocol. Twelve numbered specs, full reference lists, no marketing.
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.
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")