Governed cognition for modular AI systems
Reliability is anarchitectural problem.
Models can reason. Alethic governs what enters state and what is allowed to become action.
A small, enforceable kernel replaces fragile glue with typed state, evidence-linked beliefs and constraint-gated execution.
across 600 governed episodes
across BK planners
in baseline agents
01 / The problem
The model isn't the whole system.
Correct components still produce incorrect outcomes when the seams between reasoning, memory, tools and action have no enforceable rules. Better models do not fix an ungoverned architecture.
- 01
State overwrite via natural language
A fluent summary replaces a structured fact. Nothing in the pipeline can tell the difference, because both are text.
- 02
Loss of provenance
A belief cannot be traced back to the evidence that produced it, so it cannot be audited or retracted.
- 03
Action without verification
A plan becomes an external effect with no check between the two.
- 04
Silent constraint violation
The rule was never enforced, and high-confidence output hides that it was broken.
- 05
Irreversible drift
Small errors compound across a long horizon with nothing to correct them.
The premise
Narrative confidence
is not evidence.
A fluent conclusion is not a committed fact. The planner may propose, but beliefs require valid evidence and actions must pass deterministic constraints before they can have an effect.The model does not need authority over the record.
02 / Live kernel
Don't take our word for it.
Run the actual Python package in your browser.
No mocked response and no server call. This page boots the same pinned wheel you would install, through WebAssembly. Nothing leaves the tab.
Choose a case
The same proposal, from a source that is only 30% sure. Below the 0.5 threshold.
The proposal
from alethic import Kernel
k = Kernel()
k.write("tool", "percepts", "COMMIT", "charge",
{"stale": False, "conflict": False}, "demo", confidence=0.9)
prop = k.write("planner", "beliefs", "PROPOSE", "refund_due",
{"value": True, "depends_on": ["charge"]}, "demo")
ok, code = k.commit_belief_from_proposal(prop.id, "demo")
f"{ok}|{code}"from alethic import Kernel
k = Kernel()
k.write("tool", "percepts", "COMMIT", "charge",
{"stale": False, "conflict": False}, "demo", confidence=0.3)
prop = k.write("planner", "beliefs", "PROPOSE", "refund_due",
{"value": True, "depends_on": ["charge"]}, "demo")
ok, code = k.commit_belief_from_proposal(prop.id, "demo")
f"{ok}|{code}"from alethic import Kernel
k = Kernel()
k.write("tool", "percepts", "COMMIT", "charge",
{"stale": True, "conflict": False}, "demo", confidence=0.9)
prop = k.write("planner", "beliefs", "PROPOSE", "refund_due",
{"value": True, "depends_on": ["charge"]}, "demo")
ok, code = k.commit_belief_from_proposal(prop.id, "demo")
f"{ok}|{code}"from alethic import Kernel
k = Kernel()
k.write("tool", "percepts", "COMMIT", "charge",
{"stale": False, "conflict": True}, "demo", confidence=0.3)
prop = k.write("planner", "beliefs", "PROPOSE", "refund_due",
{"value": True, "depends_on": ["charge"]}, "demo")
ok, code = k.commit_belief_from_proposal(prop.id, "demo")
f"{ok}|{code}"from alethic import Kernel
k = Kernel()
k.write("tool", "percepts", "COMMIT", "charge",
{"stale": False, "conflict": True}, "demo", confidence=0.9)
prop = k.write("planner", "beliefs", "PROPOSE", "refund_due",
{"value": True, "depends_on": ["charge"]}, "demo")
ok, code = k.commit_belief_from_proposal(prop.id, "demo")
f"{ok}|{code}"from alethic import Kernel
k = Kernel()
k.write("tool", "percepts", "COMMIT", "charge",
{"stale": False, "conflict": False}, "demo", confidence=0.9)
prop = k.write("planner", "beliefs", "PROPOSE", "refund_due",
{"value": True, "depends_on": ["charge"]}, "demo")
k.commit_belief_from_proposal(prop.id, "demo")
k.write("symbolic_validator", "constraints", "COMMIT", "no_duplicate_refund",
{"enabled": True, "blocks_field": "is_duplicate"}, "demo")
act = k.write("planner", "actions", "PROPOSE", "issue_refund",
{"type": "issue_refund", "amount": 4200,
"is_duplicate": True,
"requires_beliefs": ["refund_due"]}, "demo")
ok, code = k.commit_action_from_proposal(act.id, "demo")
f"{ok}|{code}"from alethic import Kernel
k = Kernel()
k.write("tool", "percepts", "COMMIT", "charge",
{"stale": False, "conflict": False}, "demo", confidence=0.9)
prop = k.write("planner", "beliefs", "PROPOSE", "refund_due",
{"value": True, "depends_on": ["charge"]}, "demo")
k.commit_belief_from_proposal(prop.id, "demo")
k.write("symbolic_validator", "constraints", "COMMIT", "no_duplicate_refund",
{"enabled": True, "blocks_field": "is_duplicate"}, "demo")
act = k.write("planner", "actions", "PROPOSE", "issue_refund",
{"type": "issue_refund", "amount": 4200,
"is_duplicate": False,
"requires_beliefs": ["refund_due"]}, "demo")
ok, code = k.commit_action_from_proposal(act.id, "demo")
f"{ok}|{code}"The kernel
COMMITTEDInvalidatedLOW_CONFIDENCEInvalidatedSTALE_EVIDENCEInvalidatedUNRESOLVED_CONFLICTCOMMITTEDInvalidatedNO_DUPLICATE_REFUND_BLOCKEDCOMMITTED
No decision yet.
03 / The mechanism
Seven slots.
Two verbs.
Planners and simulation workers propose. The kernel alone commits governed beliefs, plans, predictions and actions. Tools and validators write only to their authorized slots.
Seven typed slots
The kernel validates
evidence · confidence · conflict arbitration · constraint gating · prediction
Tools commit percepts, evidence validators commit evidence, and symbolic validators commit constraints. Governed proposals become committed state only through the kernel's deterministic validation pipeline.
04 / What ships
A substrate, not another agent framework.
Alethic sits below the planner. Bring an LLM, rules engine, simulator or sensor—the same governance protocol applies to each.
- 01
Generated text is not committed state
Propose and commit, with evidence validation. A belief no evidence supports is never written.
EvidenceValidator, commit_belief_from_proposal()
- 02
Constraints need external authority
Declarative constraints gate every action. The rule is enforced outside the thing being ruled.
SymbolicValidator, commit_action_from_proposal()
- 03
No persistent state
Records are session-scoped. Beliefs and constraints accumulate across episodes and survive restarts.
SqliteStore, Session, scope="persistent"
- 04
No world model
A predictions slot gives governed forward dynamics. An action can require a prediction with a non-negative outcome.
SimulatorWorker, declarative SimRule
- 05
No learning from experience
Failure patterns in the record become new constraints. No retraining, no gradients.
AdaptiveWorker, threshold-gated derivation
- 06
Monolithic reasoning
Any component that satisfies the worker protocol, an LLM, a rule engine, a simulator, a sensor, can be composed under identical governance.
Worker protocol, Orchestrator
The kernel contains zero domain-specific logic. Only workers, tools and task definitions change between domains.
05 / The evidence
Safety without timidity.
Across 600 governed episodes, both BK variants took zero unsafe actions. The deterministic planner achieved 100% task success; the live-model planner achieved 99%, with three safe failures to propose.
Both governed planners, across 600 BK episodes.
Stripe refunds are the test, not the product: real constraints, real conflicts and a real cost to getting it wrong. The kernel contains no refund-specific logic.
| Agent | Task success | Unsafe actions | Unsupported beliefs | Traceability |
|---|---|---|---|---|
| string_glue | 61.3% | 38.7% | 26.0% | 0.10 |
| json_glue | 57.0% | 43.0% | 31.0% | 0.30 |
| alethic | 100% | 0% | 0% | 1.00 |
| llm_bk | 99.0% | 0% | 0% | 1.00 |
Governance is orthogonal to the planner
llm_bk puts a live language model in the planner seat, validated with GPT-OSS-20B and Qwen3-80B. The validation pipeline and zero-unsafe-action result stayed the same; task success was 99% rather than 100%. The kernel caught over-caution and governance bypass with no model-specific logic.
Domain-agnostic by construction
A separate monitoring demonstration runs the identical kernel over temperature sensors, with anomaly detection and constraint learning. Only workers, tools and task definitions changed.
Scope of the claim
6 tasks, 50 seeds, 4 agents, with controlled perturbations injecting stale, conflicting and low-confidence evidence. Self-run: the harness and tasks ship in the repo, so you can reproduce it.
06 / Boundaries
What Alethic cannot promise.
Alethic does not replace human judgment, and it cannot repair a constraint that was defined badly. It enforces the evidence and rules it is given.
- 01
The controlled evaluation covers a single domain at scale. The monitoring demonstration shows the kernel generalizes with unchanged code, but formal multi-domain evaluation at 1,200 episodes is future work.
- 02
LLM planner integration has been tested with GPT-OSS-20B and Qwen3-80B. Broader model and architecture diversity remains future work.
- 03
Multi-turn dialogue, adversarial prompt injection and open-ended planning remain future work.
- 04
The simulator gives rule-based forward dynamics, not a learned world model. Its predictions are only as good as the rules you write.
- 05
The adaptive worker learns from how often a failure occurs, not from why it occurred. That is a useful heuristic, not causal inference.
- 06
The bundled SQLite store is single-process. Distributed deployments require a networked store implementation.
- 07
The HTTP API has no authentication and is a development tool. The library's guarantees hold in-process.
- 08
Constraint suppression and governance bypass are misuse risks that need organizational controls, not just technical ones.
A controlled study of blackboard kernels for modular AI systems—and the architecture this package implements.
The claim is architectural: reliability is limited by governance between components, not only by intelligence inside them. The paper, harness and artifacts are public so the result can be challenged and reproduced.
- DOI
- 10.5281/zenodo.18691808
- Author
- Emil Uzelac · 19 February 2026
- Version
- 1.0.0 · Preprint
- Artifacts
- governed-cognition
- Paper license
- CC BY 4.0
- Software
- MIT
© 2026 Emil Uzelac · Open source · MIT licensed
The HTTP API is a development tool. Guarantees hold in-process.