Self-Learning Agent

What It Is

A domain-agnostic four-loop self-learning architecture with constitutional governance, built in Python. Four interconnected loops -- Sensing (data to state delta), Learning (state to skill via Claude API), Flare (escape local minima via structured discontinuity), and Propagation (identify growth substrates) -- governed by an immutable soul seed. Runs on a three-speed runtime informed by Collatz convergence theory. The only product in the practice built in Python, reflecting its role as a research prototype.

Why It Matters

An AI agent that executes tasks has a ceiling. One that learns autonomously has a growth trajectory. Current agent frameworks execute. They follow instructions, call tools, and produce outputs. None of them learn.

The self-learning agent closes this gap with four formal loops. Sensing detects what changed in the environment. Learning converts changes into new skills through Claude API calls. Flare breaks out of local optima through structured discontinuity -- a mechanism inspired by simulated annealing but governed constitutionally. Propagation identifies where the agent can grow next by scanning for unoccupied capability substrates. The immutable soul seed provides the critical guarantee: the agent can learn new capabilities but cannot modify its core axioms. The three-speed runtime (2-adic event-driven, Archimedean continuous, 3-adic cycle-driven) matches governance frequency to decision type -- fast decisions at event speed, continuous monitoring at steady state, slow governance at constitutional cadence.

Proof Points

Four interconnected loops: Sensing, Learning, Flare, Propagation -- each implemented as a separate Python module
Three-speed runtime: 2-adic (fast/event-driven), Archimedean (continuous), 3-adic (slow/cycle-driven)
Immutable soul seed: axioms, target manifold, schema stored in soul/seed.json -- cannot be modified by the agent
Ma'at Gate enforcement with provability boundary governance
Four Faces (A-D): enterprise-ops, portfolio-mgmt, research-pipeline, and AgentOS reference implementation
6 test files: soul immutability, axiom checker, sensing loop, flare detection, Ma'at gate, spec compatibility
Face A includes 3 domain configurations with custom sources and axioms
Bridge module for MCP integration (mcp_stub.py)

Market Position and IP

Patent-protected architecture (USPTO 19/418,922). The four-loop self-learning architecture is original -- no competing framework implements autonomous learning with constitutional governance. The Collatz-informed three-speed runtime is a novel approach to matching governance frequency to decision type, with no equivalent in the agent framework market. The immutable soul seed provides formal guarantees that autonomous learning cannot compromise core values -- a critical requirement for enterprise adoption that no competing agent framework addresses. The four-Face architecture (consulting IP, AgentOS reference implementation, standalone product, research output) demonstrates that the same core architecture serves four distinct markets.

Novel Research Contribution

The self-learning agent is the research frontier of the practice. Existing autonomous agent research either allows unconstrained learning (safety risk) or constrains learning so tightly that the agent cannot grow (capability ceiling). The four-loop architecture with soul seed governance resolves this tension constructively -- the agent learns without limit within constitutionally defined boundaries. The Flare loop applies structured discontinuity to escape local minima, adapting ideas from simulated annealing and evolutionary computation with formal governance constraints. The soul seed immutability guarantee is a constructive proof that autonomous learning and constitutional governance are compatible, not opposed.

Implementation and Impact

The self-learning agent is currently a research prototype demonstrating that autonomous agent learning can operate within constitutional constraints. Its primary impact is architectural: the four-loop pattern and soul seed governance inform AgentOS's production design. The bridge between research prototype (Python) and production system (TypeScript/AgentOS) is the AgentOS MCP Bridge. For research lab founders, this represents the most ambitious and theoretically grounded component of the architecture -- the frontier where formal mathematics meets deployed agent systems.

Connections

Imperatives: Constraint Surface Governance, Harmonic Alignment
Builds: AgentOS (constitution bridge planned), AgentOS MCP Bridge (integration path)
Papers: harmonic-soul-architecture, brachistochrone-asp
Capabilities: Agentic System of Systems