A 22-subsystem symbolic processing architecture implementing recursive-generative organizational bodies through typed symbolic values, async message passing, and four-phase process loops.
The name encodes the system's theoretical commitment: Organon (instrument of thought), Noumenon (the thing-in-itself, beyond mere appearance), Ontogenetic (the development of being through time), Morphe (form as structuring principle). Together: an instrument for apprehending the deep forms through which symbolic entities develop.
Package:
autogenrec(AutoGenRec — Recursive-Generative Organizational Body)
Problem Statement | Core Concepts | Architecture | Installation & Usage | Examples | Downstream Implementation | Validation | Roadmap | Cross-References | Contributing | License | Author & Contact
Most symbolic processing frameworks treat symbols as inert data: strings with lookup tables, tokens with embeddings, or nodes in static graphs. They lack a model for how symbolic meaning develops — how a narrative fragment accrues provenance, how a rule compiles into executable form, how a dream-symbol decays into echo and is eventually archived or transformed into currency.
Existing approaches fall into predictable traps:
- Rule engines (Drools, CLIPS) handle production rules but have no concept of symbolic value, identity, or temporal decay
- Agent frameworks (LangChain, CrewAI) orchestrate LLM calls but treat the orchestration layer as mere plumbing, not as a domain with its own semantics
- Message brokers (RabbitMQ, Kafka) provide pub/sub infrastructure but impose no type discipline on the symbolic content flowing through them
- Actor systems (Akka, Ray) manage concurrency but their actor model does not distinguish between a signal that should attenuate over distance and a message that should persist until consumed
Ontogenetic Morphe addresses the gap between these paradigms. It provides a typed symbolic processing architecture where every value carries provenance and lineage, every signal has physical properties (strength, threshold, attenuation), every subsystem follows the same recursive lifecycle, and the whole system communicates through a single async message bus with topic-based routing.
The core insight is that symbolic processing is not a pipeline but a metabolism — a recursive cycle of intake, processing, evaluation, and integration that mirrors biological ontogenesis. Each subsystem is a specialized organ within a larger body, and the body's coherence emerges from the message bus, not from a central controller.
Every computation in the system follows a single abstract protocol defined by ProcessLoop[InputT, OutputT, ContextT]:
INTAKE → PROCESS → EVALUATE → INTEGRATE
↑ │
└─────────────────────┘
(feedback: should_continue)
The evaluate phase returns a boolean should_continue flag, creating a natural recursion: a subsystem keeps cycling until its own evaluation criteria are satisfied. This is not an arbitrary design choice — it models the recursive self-modification that characterizes living systems. A rule compiler does not simply compile; it compiles, evaluates the result, and recompiles if the output fails its own criteria.
The generic type parameters (InputT, OutputT, ContextT) ensure that each subsystem's loop is fully typed. A SymbolicInterpreter takes SymbolicValue in and produces interpreted structures out; a CodeGenerator takes compiled rules in and produces executable artifacts out. The type system prevents cross-wiring at the interface level.
SymbolicValue is the atomic unit of meaning in the system — a frozen Pydantic model carrying:
- ULID identity — globally unique, time-sortable, no coordination required
- Value type — one of the enumerated kinds in
SymbolicValueType(NARRATIVE, DREAM, RULE, PATTERN, TOKEN, CURRENCY, MASK, SIGNAL, ECHO, REFERENCE, ARCHIVE, …) - Provenance chain — every value records its origin; the
derive()method creates a new value linked to its parent, building a directed acyclic graph of symbolic lineage
This is not a tagged union for dispatch convenience. The type system reflects an ontological claim: these categories constitute the morphological vocabulary of the system. A DREAM value behaves differently from a RULE value not because of arbitrary business logic but because dreams and rules have different ontogenetic trajectories — dreams decay into echoes, rules compile into executable form.
The system distinguishes three message primitives with distinct physical semantics:
- Signal — carries
strength,threshold, andattenuation. A signal propagates only whenstrength >= threshold, and its strength decreases by the attenuation factor at each hop. This models attention, salience, and the natural filtering that prevents every subsystem from responding to every event. - Echo — a signal's residue after it falls below threshold. Echoes decay exponentially over time, modeling how past events influence the present with diminishing force. The
EchoHandlersubsystem manages echo persistence and retrieval. - Message — the general-purpose envelope with TTL (time-to-live), priority levels, and correlation IDs for request/response patterns. Messages expire; signals attenuate; echoes decay. Each has the temporal semantics appropriate to its role.
MessageBus provides async pub/sub using anyio (backend-agnostic: works with both asyncio and trio). Topic matching supports two wildcard patterns:
*matches exactly one topic segment (e.g.,subsystem.*.startedmatchessubsystem.interpreter.started)#matches zero or more segments (e.g.,value.#matchesvalue.created,value.derived.from.dream, etc.)
This is deliberately modeled on AMQP topic exchanges, but implemented in-process with zero network overhead. The bus is the system's nervous system — all inter-subsystem communication flows through it, making the entire communication topology observable, interceptable, and testable.
Every subsystem extends ProcessLoop with a managed lifecycle state machine:
CREATED → STARTING → RUNNING → STOPPING → STOPPED
Transitions are enforced: you cannot call process() on a STOPPED subsystem, and start() is idempotent on a RUNNING one. Each subsystem maintains its own statistics (messages sent/received, processing cycles, errors) and declares its topic subscriptions at construction time.
The Orchestrator creates all 22 subsystems, starts them concurrently via anyio task groups, and provides ordered shutdown. This concurrent lifecycle management is the difference between 22 independent scripts and a coherent organism.
Organized into 8 functional categories:
| Category | Subsystems | Role |
|---|---|---|
| Meta | AnthologyManager | Manages collections of symbolic works across subsystems |
| Core Processing | SymbolicInterpreter, RuleCompiler, CodeGenerator | Intake → interpretation → compilation → executable output |
| Value Economy | ValueExchangeManager, BlockchainSimulator, ProcessMonetizer | Symbolic value creation, exchange, provenance ledger, monetization |
| Identity | MaskGenerator, AudienceClassifier | Identity construction, persona management, audience segmentation |
| Temporal | TimeManager, EvolutionScheduler, LocationResolver | Temporal coordination, evolutionary scheduling, spatial context |
| Data | ReferenceManager, ArchiveManager, EchoHandler | Reference tracking, archival, echo decay management |
| Conflict | ConflictResolver, ArbitrationEngine | Contradiction detection, multi-party arbitration |
| Routing | NodeRouter, SignalThresholdGuard | Message routing, signal strength filtering |
| Transformation | ProcessConverter, ConsumptionManager | Format conversion, consumption tracking |
| Academic | AcademiaManager | Citation management, academic output formatting |
This is not a microservices decomposition — it is an anatomical decomposition. Each subsystem exists because the symbolic processing domain requires a distinct organ for that function, not because of scaling or deployment concerns.
The subsystems communicate exclusively through the message bus. There are no direct imports between subsystem modules. This means:
- Any subsystem can be replaced without affecting others
- New subsystems can be added by subscribing to existing topics
- The full system can be tested by injecting messages and observing bus traffic
- Subsystem combinations can be composed for specific use cases (you do not need all 22)
- Python >= 3.11
- Dependencies:
anyio>=4.0,pydantic>=2.0,structlog>=24.0,python-ulid>=2.0
# From source
git clone https://github.com/4444J99/organon-noumenon--ontogenetic-morphe.git
cd organon-noumenon--ontogenetic-morphe
pip install -e ".[dev]"import anyio
from autogenrec.core.symbolic import SymbolicValue, SymbolicValueType
from autogenrec.core.signals import Message
from autogenrec.runtime.orchestrator import create_default_orchestrator
async def main():
# Create a symbolic value
dream = SymbolicValue(type=SymbolicValueType.DREAM, content="recursive mirror")
# Derive a new value with lineage tracking
pattern = dream.derive(type=SymbolicValueType.PATTERN, content="self-reference detected")
# Start the full 22-subsystem orchestrator
orchestrator = create_default_orchestrator()
async with orchestrator.run_context():
# Publish a message to the bus
await orchestrator.message_bus.publish(
Message.event(
"value.created",
"example",
{"value_id": pattern.id, "content": pattern.content},
)
)
anyio.run(main)Minimal supported imports (stable public SDK surface for downstream organs):
SymbolicValue,SymbolicValueType—autogenrec.core.symbolic(also re-exported fromautogenrec)ProcessLoop,ProcessPhase,ProcessState—autogenrec.core.processMessageBus—autogenrec.busOrchestrator,create_default_orchestrator—autogenrec.runtime.orchestratorMessage—autogenrec.core.signals
# Run tests
pytest
# Type checking
mypy src/
# Linting
ruff check src/
# Property-based tests (via Hypothesis)
pytest tests/ -m hypothesisThe repository includes 5 example scripts demonstrating progressively complex usage:
- Basic symbolic values — Creating, typing, and deriving symbolic values with provenance chains
- Message bus patterns — Topic subscriptions, wildcard matching, correlation-based request/response
- Single subsystem lifecycle — Starting, processing, evaluating, and stopping a subsystem in isolation
- Multi-subsystem composition — Wiring 3-4 subsystems together for a focused task
- Full system demo — A research-to-revenue pipeline across 10 subsystems: a narrative value enters the SymbolicInterpreter, gets compiled by RuleCompiler, passes through ConflictResolver, is monetized by ProcessMonetizer, and exits as a tracked academic output via AcademiaManager
The full system demo is the canonical integration test — it demonstrates that the message bus topology works end-to-end without any subsystem holding a direct reference to another.
Ontogenetic Morphe provides the theoretical substrate for concrete applications across the organ system:
- ORGAN-II (Poiesis) — Generative art systems can use
SymbolicValuewithDREAM,NARRATIVE, andMASKtypes as the semantic layer beneath generative processes. TheMaskGeneratorsubsystem directly supports identity-construction workflows in performance and experiential art. - ORGAN-III (Ergon) — The
ValueExchangeManager,BlockchainSimulator, andProcessMonetizersubsystems provide a typed value-economy framework that can underpin SaaS product logic, particularly for platforms involving digital asset provenance or process-based billing. - ORGAN-IV (Taxis) — The
Orchestratorpattern andMessageBusarchitecture serve as a reference implementation for the governance and routing layer, demonstrating how autonomous subsystems coordinate without central control.
The dependency direction is strictly I → II → III: downstream organs may import from Ontogenetic Morphe, but this library has zero dependencies on any other organ's code.
- 13 test files covering core abstractions, message bus, subsystem lifecycle, and integration scenarios
- Type checking via mypy in strict mode across the full
src/tree - Property-based testing via Hypothesis for symbolic value derivation invariants (provenance chains never break, ULID ordering is preserved, frozen models remain immutable after derive)
- 22 specification documents — each subsystem has a dedicated spec describing its topic subscriptions, message formats, and behavioral contracts
| Criterion | Status |
|---|---|
| All 22 subsystems instantiate and start | Passing |
| ProcessLoop generic types enforce at boundaries | Passing |
| SymbolicValue.derive() maintains provenance DAG | Passing |
| Signal attenuation below threshold produces Echo | Passing |
| MessageBus wildcard matching (*, #) | Passing |
| Full system demo completes without deadlock | Passing |
- Persistent echo store (currently in-memory only — echoes are lost on shutdown)
- Subsystem dependency declarations (explicit "requires" graph for partial orchestration)
- Metrics export (OpenTelemetry integration for bus traffic observability)
- Symbolic value serialization format (portable representation beyond Pydantic JSON)
- Distributed message bus option (bridge to NATS or Redis Streams for multi-process deployments)
- Visual topology inspector (render subsystem graph and live message flow)
- Plugin subsystem API (third-party subsystems that register via entry points)
- Formal verification of the ProcessLoop protocol (TLA+ or similar)
- Cross-organ symbolic value federation (shared provenance across ORGAN-I/II/III boundaries)
- recursive-engine — Recursive computation engine; shares the self-referential processing philosophy but operates at a different abstraction level (computation vs. symbolic metabolism)
- a- repos — Additional theoretical explorations within the organ
- ORGAN-II: Poiesis — Art organ; downstream consumer of symbolic value types
- ORGAN-III: Ergon — Commerce organ; downstream consumer of value economy subsystems
- ORGAN-IV: Taxis — Orchestration organ; reference consumer of bus and orchestrator patterns
- Meta-ORGANVM — Umbrella organization coordinating all eight organs
Ontogenetic Morphe draws on and departs from several traditions:
- Luhmann's autopoietic systems theory — The recursive self-production of the ProcessLoop echoes autopoiesis, but we add typed symbolic values as the medium of self-production, making the theory computationally tractable
- Whitehead's process philosophy — The four-phase loop (INTAKE → PROCESS → EVALUATE → INTEGRATE) parallels Whitehead's phases of concrescence, but grounds them in async Python rather than metaphysical speculation
- AMQP/Actor model hybrids — The message bus borrows AMQP topic semantics while the subsystem lifecycle borrows from actor supervision trees; the combination is original
- Digital humanities symbolic processing — Projects like HuCit and CIDOC-CRM provide symbolic ontologies for cultural objects; Ontogenetic Morphe provides the processing architecture that such ontologies lack
Contributions are welcome. The architecture is designed for extensibility — new subsystems can be added by:
- Extending
Subsystemwith appropriate generic type parameters - Declaring topic subscriptions in the constructor
- Implementing the four-phase
ProcessLoopmethods - Registering with the
Orchestrator
Please ensure all contributions include:
- Type annotations (mypy strict mode)
- Tests (pytest, property-based where applicable)
- A specification document following the existing 22-spec format
See the org-level contributing guidelines for code of conduct and PR process.
MIT License. See LICENSE for details.
@4444J99 — Creator of the eight-organ creative-institutional system.
- Org: organvm-i-theoria (ORGAN-I: Theory)
- Meta: meta-organvm