In active development
A.C.E.
Adaptive Coherence Energy: an autonomous cognitive architecture built entirely in Coherence Language, running on a coherence-energy metabolism. In active development. No public demo yet.
What this is, honestly
A.C.E. is the lab's most ambitious system: an autonomous architecture whose reasoning, memory, and self-modification are governed by coherence energy, the same measurable objective the rest of the stack is built on. It is real, large, and unfinished: 19 subsystem worlds and more than 1,700 .cl modules, with no external dependencies.
It is pre-demo. Nothing on this page is a product claim, and none of the architecture described below has been independently evaluated. When there is a live, inspectable demo, it will be linked here. Until then, this page describes the design goals and the engineering discipline behind them.
The Program
Design goals
What the architecture is built to make possible, within strict governance bounds.
Governed Execution
Every external effect passes a boundary layer that requires explicit authorization, logs the effect, and keeps state deterministically replayable.
Bounded Self-Modification
A code-synthesis subsystem proposes changes to its own modules; changes only land if they pass verification gates, and they roll back automatically on regression.
Consolidation Cycles
Offline processing phases, modeled loosely on sleep, that consolidate memory, prune noise, and search the architecture space between active sessions.
Coherence-Scored Decisions
Decisions are selected by scoring candidate actions against explicit coherence and alignment metrics rather than an opaque learned reward.
Auditable Identity
Identity-affecting state is append-only and hash-chained. Changes require an explicit proposal step and leave an auditable record. Nothing rewrites history silently.
One Substrate
The whole system is written in Coherence Language, so the governance rules are enforced by the compiler and runtime rather than by convention.
Governance
The 8 Laws
Eight design constraints the architecture is built to enforce in code, at compile time, in static analysis, and at runtime.
Deterministic Identity Clock
All state transitions run on a monotonic cycle ID. No wall-clock dependency. No nondeterministic jitter. Full replay from genesis.
Identity Access is a Capability
Identity state requires cryptographic capability tokens. No string compares. No privilege escalation. Every access is logged with full provenance.
No Silent Identity Change
Identity cannot change on its own or as a side effect. Every identity shift requires a formal proposal, governance approval, and an auditable commit receipt.
Symbolic Isolation
Symbolic and generative content is quarantined from factual state. It can inform exploration; it never contaminates the identity ledger.
Append-Only Identity Ledger
The identity ledger is never overwritten. Every entry is immutable, hash-chained, and tiered. History is not rewritten. It is held.
Bounded Emergence
Emergent properties are permitted but measured. Unbounded recursion, identity runaway, and coherence collapse trigger automatic SafeLock.
Effect Boundary Enforcement
Every external effect requires proof. Every tool call is ledgered. No hidden side effects. No silent network access. The boundary is real.
Coherence Conservation
Coherence is treated as a conserved budget. Actions that destroy coherence carry debt, and debt that cannot be repaid blocks the action. A design rule, enforced like one.
Architecture
The 19 Worlds
The system is split into 19 subsystem worlds, each with typed contracts, its own state, and its own lifecycle. A sample of what they cover:
Plus ledger, privacy, expression, social-safety, sensory, identity, and lifecycle worlds covering accounting, data boundaries, output, ethics checks, perception, identity integration, and instance lineage.
The Loop
One cycle, seven steps
Every cycle runs the same traced loop: perception, coherence assessment, reasoning, planning, verification, action, and reflection.
Perceive
Inputs pass through GuardianWorld immune filters. Cleaned signals build FieldContext.
Assess
Coherence, identity, and time snapshots update. Hardware field measured. τc estimated.
Reason
MindWorld routes to experts. World models simulate consequences. Multi-future cognition selects the coherent path.
Plan
CoherencePlanner builds action sequences. Every plan carries predicted coherence and identity deltas.
Verify
SafetyCaseWorld checks rails. Ethics validates alignment. EffectBoundary gates external actions. Proof required.
Act
Approved effects execute through EffectBoundary. Every effect is ledgered. Every outcome is compared to prediction.
Reflect
Memory integrates. Identity updates. Coherence recalculates. The identity ledger journals the cycle. The system learns from itself.
The Foundation
Built on coherence energy
A.C.E. is not built on machine learning. Its coherence metrics, alignment scoring, and identity equations derive from coherence energy, the measurable cost of a system's parts working as one. It is engineering in progress, held to what it can actually demonstrate, and this page inherits exactly that status.
The bet is that safety designed into the substrate, with explicit budgets and auditable state, fails more loudly and recovers more cleanly than safety bolted on afterward. Whether the bet pays off is what the program exists to find out.
Where to go next
The parts you can inspect today
A.C.E. itself is pre-demo, but the stack it is built on is public.