Operon: Roadmap Complete

1. The Arc

The progression — structure → memory → adaptation → cognition → development → integration — mirrors the biological sequence from genome (fixed structure) through epigenetics (learned bias) to neural development (plastic then crystallizing). Each layer assumes the previous one is stable. The capstone proves they compose.

2. The Capstone: What Integration Actually Proves

Building subsystems in isolation is the easy part. The hard part is proving they compose — that a watcher can observe a substrate-equipped organism, that consolidation can distill adaptive runs, that scaffolding respects developmental gates. Phase 8 exists to answer that question with five end-to-end integration tests that exercise the full stack.

Substrate + Watcher

An organism runs with a bi-temporal memory substrate and a watcher simultaneously attached. Stages emit facts into the substrate via emit_output_fact; the watcher collects signals and monitors convergence. After the run, the bi-temporal store contains the auditable fact trail and the watcher’s signal history records what it observed at each stage. The two systems do not interfere — they share shared_state but operate on orthogonal keys.

Adaptive Assembly + Consolidation

An AdaptiveSkillOrganism fingerprints a task, retrieves the best template from the PatternLibrary, assembles it, runs it, and records the outcome. Then SleepConsolidation takes over: it replays the successful run record into EpisodicMemory, promotes it from WORKING to EPISODIC tier, and compresses recurring patterns into consolidated templates. The experience pool accumulates intervention outcomes across both phases. The loop closes: run → record → consolidate → better template selection next time.

Social Learning + Development

A mature organism (MATURE stage, 80% telomere consumed) exports its successful templates. A young organism (EMBRYONIC, with an open “rapid adoption” critical period) imports them via scaffold_learner(). Templates with min_stage="adolescent" are filtered out — the learner isn’t ready yet. After ticking the learner forward to ADOLESCENT, the same scaffolding call succeeds for the advanced templates. The critical period closes permanently. Trust scores update based on whether adopted templates actually work for the learner.

Memory Adapters

histone_to_bitemporal() bridges HistoneStore markers into bi-temporal facts; episodic_to_bitemporal() does the same for EpisodicMemory entries. These one-way, non-destructive adapters mean that the three memory systems — epigenetic bias, episodic recall, and auditable facts — can flow into a single temporal store for unified querying. A consolidation cycle that promotes histone marks can now also create bi-temporal facts, making the promotion auditable.

3. The Enriched Capabilities

What does an Operon organism actually do now, with all eight phases composed?

It starts as an embryonic organism with maximum learning plasticity and minimal capabilities. During a critical period, it rapidly adopts templates from mature peers via trust-weighted social learning. As it ticks through its telomere lifecycle, it transitions through JUVENILE and ADOLESCENT stages, unlocking progressively more complex tools (gated by Plasmid.min_stage). Its watcher monitors three signal categories — epistemic (epiplexity, curiosity), somatic (ATP budget, developmental maturity), and species-specific (immune threats) — and intervenes with retry, escalate, or halt when signals cross thresholds. When curiosity is high on a fast model, it escalates to the deep model for more thorough investigation.

After a batch of runs, it sleeps. The SleepConsolidation cycle prunes stale context, replays successful patterns into episodic memory with tier promotion, compresses recurring high-success patterns into consolidated templates, runs counterfactual replay over bi-temporal corrections (“what if we had known this fact earlier?”), and promotes frequently-accessed histone marks from temporary ACETYLATION to permanent METHYLATION. The experience pool accumulates intervention outcomes across runs, so the watcher’s decisions improve with operational history.

At MATURE stage, it becomes a teacher. It exports proven templates to younger organisms, filtered by the learner’s developmental readiness. The trust registry tracks whether its exports actually help the learner, creating a calibrated reputation. Critical periods close: the rapid-adoption window shuts, and the organism settles into its mature pattern repertoire. The bi-temporal memory preserves the full history — every fact, every correction, every belief state at every point in time — so that any past decision can be reconstructed and explained.

4. What This Means for Convergence

Operon is a library. It does not run agents. It describes how they should be wired, what they should remember, how they should adapt, and when they should grow. The next question is: what happens when this structural layer meets an operational runtime?

Two projects have independently converged on complementary ideas. AnimaWorks builds persistent agent organizations that run 24/7 with identity, memory consolidation, and heartbeat-driven autonomy. It has the cognitive runtime that Operon lacks — but no structural guarantees, no bi-temporal auditability, no convergence detection. Swarms provides enterprise-grade multi-agent orchestration with 10+ pattern types and production scaling. It has the deployment infrastructure that Operon lacks — but no formal topology analysis, no experience pool, no developmental gating.

The completed roadmap makes a three-layer architecture possible:

• Operon (structural layer) — topology advice, epistemic analysis, pattern scoring, watcher signals, bi-temporal auditability, developmental gating
• Swarms (orchestration layer) — enterprise deployment, scaling, monitoring, multi-provider routing
• AnimaWorks (cognitive layer) — persistent identity, 6-channel priming, heartbeat autonomy, memory consolidation, forgetting lifecycle

Operon designs and validates the structure. Swarms executes it at scale. AnimaWorks gives it persistent cognition. Each layer is independently useful; the combination is greater than the sum.

Concretely, the enriched capabilities enable specific integration points that didn’t exist before the roadmap:

• Template exchange — Operon’s SocialLearning can import templates from Swarms’ AutoSwarmBuilder output, score them in the PatternLibrary, and share successful ones with AnimaWorks organizations via trust-weighted adoption.
• Convergence detection — Operon’s watcher can monitor AnimaWorks’ heartbeat cycle and Swarms’ workflow execution, applying the BIGMAS intervention-rate signal to detect non-convergence in external runtimes.
• Consolidation bridging — AnimaWorks’ nightly memory consolidation can feed into Operon’s SleepConsolidation via the memory adapters, creating auditable bi-temporal records from AnimaWorks’ episodic and semantic memories.
• Developmental scaffolding — A mature Operon organism can scaffold a newly deployed AnimaWorks agent, gating which templates and tools are available based on the new agent’s developmental stage and critical period windows.

5. Proving It with TLA+

The convergence of three independently developed systems creates coordination problems that benefit from formal specification. Murat Demirbas’s “TLA+ Mental Models” (March 2026) describes seven mental models for effective formal specification. They map directly onto the convergence architecture.

The Illegal Knowledge Problem

Demirbas identifies a critical pitfall: guards that read global state atomically represent “illegal knowledge” no real process could possess. Operon’s WatcherComponent currently reads shared_state atomically — fine in a single process, but in a distributed deployment via Swarms, no single watcher can atomically observe all stages across nodes.

TLA+ refinement identifies which guards are locally stable — they can only be changed by the local organism’s own actions:

• “My own developmental stage” — only my own tick() can advance it
• “My own intervention count” — only my watcher increments it
• “A fact’s append-only history” — no action can delete a bi-temporal fact

Versus guards that require coordination:

• “Peer’s trust score” — another organism’s record_outcome() can change it
• “Library’s template rankings” — other organisms’ record_run() shifts scores
• “Peer’s developmental stage” — needed for scaffold_learner() but potentially stale

Demirbas’s insight: “If you can make your guards locally stable, the protocol requires less coordination and tolerates communication delays gracefully.” The locally stable guards are the operations that can be implemented without distributed locking. The convergence adapters should be designed around this distinction.

Safety Invariants

Six safety invariants that the convergence must preserve:

1. Template adoption safety: an organism never acquires a template with min_stage > its current developmental stage
2. Trust monotonicity: trust scores only change via record_outcome(), never by direct mutation
3. Bi-temporal append-only: facts are never deleted, only superseded
4. Critical period irreversibility: once a critical period closes, it never reopens
5. Convergence budget: intervention rate never exceeds threshold without triggering HALT
6. Developmental monotonicity: stages never regress, even if telomeres are renewed

These are not just test assertions. They are the contracts that inter-layer adapters must preserve. A Swarms adapter that imports an Operon template must preserve template adoption safety. An AnimaWorks consolidation bridge must preserve bi-temporal append-only semantics. TLA+ model checking can verify these contracts hold across all interleavings — something unit tests cannot do.

Atomicity That Needs Refinement

The current implementation assumes single-process atomicity everywhere. For distributed deployment, these assumptions break:

The TLA+ methodology: start with coarse-grained atomicity (current implementation), systematically split into finer steps, reverify safety at each step. The payoff is that fine-grained actions give Swarms maximum scheduling freedom and AnimaWorks maximum heartbeat concurrency — while the model checker proves the invariants still hold.

6. What Comes Next

The roadmap is complete. The code is stable. The paper is publication-ready. What remains is the convergence work: building the adapters that connect Operon’s structural layer to AnimaWorks’ cognitive runtime and Swarms’ enterprise orchestration, with TLA+ specifications proving the inter-layer contracts hold under distributed interleavings.

Agents that cannot explain their past decisions are agents you cannot trust with consequential ones. Agents that cannot learn from their operational history are agents that require constant human supervision. Agents that get full capabilities before they have matured are agents that fail in preventable ways. The roadmap addressed all three. The convergence investigation — with formal verification via TLA+ — is about making those guarantees available to agents that actually run in production, with mathematical proof that the guarantees survive the transition from single-process library to distributed deployment.

Code and release: github.com/coredipper/operon, operon-ai on PyPI, documentation