Abstract: RMSP (Reward-Modulated Structural Plasticity) proposes a new paradigm in which an agent's behavioral topology self-evolves through use. AGE (Attractor-Guided Engineering) proposes a methodology that enables a software repository to continuously converge under high-frequency AI perturbations. These two are not competing approaches—RMSP adjusts an agent's internal structure (on the order of seconds), while AGE stabilizes repository-level invariant contracts (on the order of days). nop-chaos-flux is a complete implementation of AGE at the framework level. Its owner-doc system has undergone structural evolution in four directions—responsibility splitting (split), high-level abstraction (lift), removal of obsolete structures (prune), and cross-referencing (connect)—which correspond exactly to the structural self-organization driven by RMSP's six rewrite rules. This paper analyzes this cross-scale structural correspondence and discusses the complementary boundaries of the two.
Sources:
- RMSP Paper — Self-Evolving LLM Agents as LLM + MAN: A New Agent Paradigm via Reward-Modulated Structural Plasticity, full text at mp.weixin.qq.com/s/HYCq2mKlIaSCRAJIp92NGQ
- AGE Template —
attractor-guided-engineering-template, github.com/entropy-cloud/attractor-guided-engineering-template- nop-chaos-flux Practice — github.com/entropy-cloud/nop-chaos-flux
1. Core Proposition Comparison
| Dimension | RMSP Agent Paradigm | AGE Methodology | nop-chaos-flux Practice |
|---|---|---|---|
| Core Diagnosis | Current agent = authoring artifact, structure is static | Current AI development relies on external tools to constrain behavior (harness-first), rather than letting the repository structure itself converge | Under high-frequency AI perturbations, the repository must become a verifiable source of truth |
| Core Proposition | Agent structure should self-evolve through use | The system should converge to stable attractors through iteration | The docs/architecture/ owner-doc system is the engineering carrier of attractors |
| Structural Object | MAN aspect graph | Owner-doc system | Architecture document tree with precedence |
| Evolution Rules | RMSP: reweight/connect/prune/split/merge/lift | AGE workflow: input → req → design → plan → implement → verify → close | Strengthened: plan closure gate + independent audit + deep-audit |
| Evaluation Function | F = Surprise + β·Complexity |
Attractor fidelity + trajectory convergence | Live repo baseline consistency (owner doc vs code vs test) |
All three paradigms originate from the same observation: static structure cannot adaptively evolve through interaction; some form of plasticity mechanism must be introduced.
2. Structural Plasticity at Three Scales
Structural plasticity occurs at three distinct time scales.
Scale 1: Agent Runtime — RMSP/MAN
RMSP models the agent's behavior topology as an aspect graph. Each aspect (a responsibility concern, containing pointcut matching conditions and advice processing logic) carries its own sliding window that tracks recent performance.
After each interaction, the reward is distributed to the aspects that participated in the decision, accumulating as contribution values. When the credit variance of an aspect exceeds a threshold, one of six rewrite rules is triggered. split divides a high-variance aspect into two specialized ones (top-down differentiation); lift abstracts a cluster of co-activated aspects into a higher-level coordinator (bottom-up abstraction); connect/prune manage edge evolution and elimination. The LLM can propose new structures, but they can only be committed after passing dual gating—κ estimation (evaluating expected benefit) and F-score (Surprise + β·Complexity)—generation and verification must be separated.
MAN explicitly divides the agent into two systems: the LLM is System 1, responsible for fast reasoning and generation in the current round; the aspect network is System 2, responsible for structural governance, scheduling, and self-evolution. The fast pathway (⇓_fast) completes a single inference under a fixed topology; the slow pathway (⇓_slow) only changes the graph structure after accumulating sufficient signal. The LLM is the effector, MAN is the nervous system—the two specialize at different time scales.
Scale 2: AI Development Session — AGE Plan/Closure/Audit
AGE organizes each development task as a convergence cycle: input/ → discussions/ → requirements/ → design/ + architecture/ → plans/ → implement → verify → close.
What grows here is not an aspect graph, but plan documents, closure gate judgments, and audit records. The cycle triggered by each task pushes requirements from ambiguity to implementation readiness, while simultaneously depositing stable design intentions into design/ and architecture/ (i.e., attractors). After each plan execution, an independent session must perform a closure audit—the implementer cannot self-report completion.
In nop-chaos-flux, this cycle is strengthened to 24 plan rules, 3 status levels, and deep-audit. Plan 143 is a typical example: closure assumptions were successively overturned by independent audits on 2026-04-26 and 2026-04-27, and were only allowed to close after the live repo truly passed the threshold.
Scale 3: Long-Term Project Evolution — AGE Attractor / Owner-Doc System
The slowest layer is the change of the docs/architecture/ document tree itself. New architecture docs are promoted from analysis/ or plans/ to stable architecture docs; old structures are excluded (e.g., CompiledSchemaNode removal); architectural layers deepen (from fewer package layers to three layers—flux-compiler, flux-action-core, flux-runtime—forming a five-layer pipeline: flux-core → flux-compiler → flux-action-core → flux-runtime → flux-react).
Changes at this layer are not driven by session-level tasks, but by the accumulation of cross-session design decisions + discoveries from deep-audits. Each deep-audit that finds a discrepancy between owner-docs and the live repo triggers a round of structural correction. After correction, the project returns to the vicinity of a more precise attractor.
| Agent Internal (RMSP) | Session Control (AGE Plan) | Project Evolution (AGE Attractor) | |
|---|---|---|---|
| Time Scale | Per interaction | Per task (hours ~ days) | Weekly ~ monthly |
| Structural Unit | aspect | plan + closure gate | owner-doc |
| Learning Signal | reward → credit assignment | audit finding → baseline drift | deep-audit → doc/code discrepancy |
| Drift Detection | sliding window variance | exit criteria not met | owner-doc vs live repo inconsistency |
| Adoption Gating | κ estimation + F-score | independent closure audit | deep-audit + decision record |
| Persistence Assumption | Continuous existence (single instance, single session) | Intermittent existence (multi-session) | Time-translation invariant (multi-instance, unaffected by instance lifecycle) |
3. Conceptual Mapping
Aspect ↔ Owner-Doc
RMSP's aspect is the minimum behavioral unit inside an agent (pointcut + advice + sliding window). AGE's owner-doc is the minimum stable unit of project knowledge (design intent + contract + precedence).
Both are the minimal structural units, both can be split/merged/lifted, and both have their own "pointcut" (when to trigger, docs/index.md routing) and "advice" (behavior after triggering).
Key difference: aspects are automatically grown driven by reward, and are proprietary to a single agent instance; owner-docs are collaboratively authored by humans and AI, versioned, and shared by the team.
Rewrite Rules ↔ Document Evolution
| RMSP Rule | AGE/nop-chaos-flux Correspondence | Real Examples in the Repository |
|---|---|---|
| split | One architecture doc split into multiple narrow-scope docs | Responsibility differentiation from flux-core.md into frontend-programming-model.md (top-level spec), form-validation.md, renderer-runtime.md
|
| merge | Merging docs with similar functions | Two docs expressing the same constraint merged into one |
| lift | Abstracting higher-level principle docs from concrete docs |
docs/architecture/README.md as the reading order and hierarchy for the whole set of architecture docs |
| connect | Establishing cross-references and new dependencies |
renderer-runtime.md referencing form-validation.md, field-binding-and-renderer-contract.md referencing renderer-runtime.md
|
| prune | Deprecating/archiving docs that no longer apply | Code and docs related to CompiledSchemaNode completely removed |
| reweight | Adjusting owner-doc precedence |
frontend-programming-model.md established as a top-level spec, overriding part of flux-core.md's responsibilities |
Reward Modulation ↔ Audit Signal
RMSP uses reward → credit assignment → contribution accumulation → structural rewrite. AGE uses audit finding → baseline drift detection → closure gate adjustment → structural update.
The signal must not come from the generator itself—this is a shared discipline of both. In RMSP, the LLM is the structure proposer, reward is the verifier; in AGE, the implementer cannot make the completion judgment—an independent session must perform the closure audit.
Soft Advice ↔ Hard Control Flow
Both RMSP and AGE transform soft signals into hard control flow. In RMSP, new structures proposed by the LLM must pass the hard gates of κ estimation and F-score before being written into the aspect graph—this is not a suggestion, but an unavoidable verdict. In AGE, the closure audit result is likewise not a "recommendation to close," but the actual decision on whether a plan can be marked completed. Both do the same thing: whether the structure changes is not decided by the proposer's soft opinion, but by a hard mechanism independent of the proposer.
From an engineering direction perspective, the long-term trends on both sides are also consistent: turning more soft constraints into enforceable control-flow nodes. The RMSP paper explicitly distinguishes "soft advice" (prompt injection, unreliable) from "hard advice" (intercepting tool calls, rejecting actions, rewriting parameters, reliable), and points out that improving agent reliability depends on the latter. AGE's closure gate, deep-audit, and 24 plan rules similarly solidify the soft intention of "should converge" into executable hard barriers.
Slow Pathway ↔ Closure Audit
RMSP's slow pathway does not participate in each fast inference; it only triggers structural rewriting after credit accumulates to a threshold. AGE's closure audit likewise does not participate in daily implementation; it performs an independent convergence judgment only after plan execution is complete.
4. Core Differences
Degree of Automation
RMSP's aspect growth is fully automatic—reward drives all rewrite rules with no human intervention required. AGE's attractor evolution is semi-automatic—human/AI collaboration proposes new structures, adopted after audit gating.
RMSP is more suitable for online learning of a single agent—small scale, dense feedback. AGE is more suitable for repository-level knowledge management—large scale, feedback sparse but each structural change has major impact.
Structural Carrier
RMSP's structural carrier is the runtime aspect graph (in memory, independent per agent instance). AGE's structural carrier is the owner-doc in the repository file system (on disk, versioned, team-shared).
RMSP can migrate aspect graphs across agent instances (export → import); AGE naturally supports multiple humans and multiple agents sharing the same attractor (version control + diff review).
Evaluation Metric
RMSP uses F = Surprise + β·Complexity to uniformly judge whether a structural change is accepted. The intuitive meaning of this formula is "structure must pay rent": new structure must reduce error (Surprise) to justify its complexity (Complexity). AGE does not have a unified numerical metric; it uses multiple practical signals to evaluate convergence: whether typecheck/build/test pass, whether owner-docs match the live repo, whether the closure audit verifies completion.
The state space at agent runtime (aspect graph × memory × tool calls) is far smaller than the state space of a software repository (files × dependencies × behaviors × tests × docs × configuration). In a small state space, a unified numerical evaluation function is feasible; in a large state space, evaluation must decompose into a combination of multiple orthogonal signals.
Adaptation vs. Convergence
RMSP's goal is adaptation—the agent better adapts to the current user, allowing the aspect graph to drift continuously (as long as F decreases). AGE's goal is convergence—the system converges toward predefined attractors; structures that deviate are pulled back by the harness.
nop-chaos-flux manages this by strictly distinguishing "scope-in changes" from "attractor updates." Design changes must go through both owner-doc update and closure audit; silent baseline shifts are not allowed.
Time-Translation Invariance
RMSP assumes the agent exists continuously—at least running throughout one session, the aspect graph in memory, reward signals continuously accumulating, structural rewriting occurring naturally between interactions.
AGE faces different constraints: AI sessions disappear when the user closes the window. Today Agent A modifies the same repository, tomorrow Agent B audits it, the day after Agent C continues development—all three must see the same repository, read the same owner-docs, and judge closure against the same live repo. All of AGE's state input and output pass through the file system; this is not a design preference, but a direct consequence of time-translation invariance: because sessions cannot persist, cross-session consistency can only be guaranteed by the file system as the sole persistent layer. ("Time-translation invariance" is borrowed from Noether's theorem in physics; here it means that the system's behavior does not change due to the agent operating it or the point in time.)
RMSP and AGE fundamentally do not face the same time structure.
- RMSP solves an adaptation problem for a single instance, continuously existing—an agent works better and better from the beginning to the end of a session.
- AGE solves a convergence problem for multiple instances, intermittently existing—no matter which agent, no matter when the repository is opened, they all see and maintain the same set of attractors.
When integrating RMSP and AGE, the data-flow problem that truly needs to be solved is not compatibility at the architectural abstraction level, but: After an agent instance is destroyed, which information from its aspect graph needs to be written into the repository? The RMSP paper does not define this step (it does not assume multiple instances), but this must be resolved in practical integration—for example, degrading stably converged aspect rules into operational rules in AGENTS.md, or exporting them as project-shareable skill packages. Conversely, after AGE's owner-docs are read into agent runtime, a mechanism is also needed to determine which constraints should be solidified into the aspect graph and which only need to be referenced during the current session.
Can an RMSP Agent encode AGE's owner-doc rules as pointcuts/advice in the aspect graph, thereby internalizing AGE's functionality? No. The reason is not technical difficulty—AI can certainly learn to read files—but that the time structures do not match. RMSP assumes the agent exists continuously; the aspect graph lives and dies with the instance. AGE requires time-translation invariance: the owner-doc written by Agent A today must be independently auditable by Agent B tomorrow, unaffected by whether A is still running. As long as repository users do not share the same persistent agent instance, internalization is a dead end. The file system is the only shared layer unaffected by instance lifecycles.
When the two conflict, attractor takes priority—cross-session project consistency has higher weight than the local optimum of a single agent's adaptation. If an agent's aspect graph drifts in a direction that conflicts with the owner-doc, AGE's harness (closure audit, deep-audit) will pull it back, not RMSP's reward signal. Coexistence of both requires a clear arbitration rule: the project baseline is defined by AGE; the agent can only self-adapt without breaking the baseline.
Integrate RMSP into agent runtime so that agents evolve skill preferences adapted to the current project through use; layer the AGE methodology on top so that the project repository maintains structure under high-speed agent iteration. Each handles its own convergence problem.
5. Implicit Confirmation in nop-chaos-flux
nop-chaos-flux does not implement RMSP, but its practices have deep correspondence with RMSP's ideas:
Separation of Generation and Verification: RMSP's core design—LLM proposes structure, reward decides whether the structure is committed. nop-chaos-flux's core discipline—the implementer cannot make the completion judgment; closure audit must be done by an independent session.
Explicit Externalization of Structure: RMSP designs the aspect graph as an inspectable, editable, exportable data structure. nop-chaos-flux uses the docs/architecture/ owner-doc as the stable carrier of where the system should converge. Both approaches believe structural information should be explicitly externalized, not relying on implicit internalization.
Structural Rewriting Predicated on Baseline Alignment: Before RMSP rewrites, the current MAN graph must be known (κ estimation requires a baseline). The first rule of nop-chaos-flux's plan guide: verify the live repo before writing a plan.
Deep Correspondence in Audit Algorithms: nop-chaos-flux's deep-audit has a whole set of drift classifications—doc-behavior drift, proof insufficiency, duplicate coverage, orphan contract. These are the repository-scale expressions of the Surprise signal in RMSP: when owner-doc description ≠ live repo behavior, Surprise increases, requiring structural correction.
6. AGE Template: The Middle Adhesive Layer
attractor-guided-engineering-template (GitHub) is a complete templating of AGE for application-layer projects. Its relationship with nop-chaos-flux is:
| Dimension | AGE Template | nop-chaos-flux |
|---|---|---|
| Positioning | Application-layer project scaffold | Framework-level low-code runtime |
| Document Count | ~20-30 files (core ~10) | Dozens of architecture docs + component design docs + plan + audit |
| Plan Complexity | Lightweight plans (~5-section template) | Full plan system (24 rules + 3 status levels) |
| Audit Requirements | Pre-plan audit + closure audit | Same as left + deep-audit + adversarial review |
| Project Scale | Small-to-medium applications | Large framework (~20 workspace packages) |
The AGE template serves as a bridge between RMSP and nop-chaos-flux: it does not require every layer to be in place from the start, but provides a scaffold that can be progressively strengthened. The RMSP paper calls the initial state of the agent the "zygote" (a single cortical aspect + a set of conserved reflex cores + zero synapses), corresponding to the AGE template's "minimal core" (AGENTS.md + docs/index.md + docs/context/ + verification commands); RMSP's "growth through interaction" corresponds to AGE template's "trigger on demand" (plans/, bugs/, logs/ appear only when actually needed, not pre-created in full).
7. A Unified Evolutionary Landscape
Scale Time Structure Structural Example Evolution Mechanism Evaluation Method
──── ────── ────── ────── ──────
Agent Runtime Continuous existence aspect graph RMSP F = Surprise + β·Complexity
(single instance) (6 rewrite rules)
↑
Development Intermittent existence plan + closure plan audit Independent closure audit
Session (multi-session) gate + audit + exit criteria
↑
Long-Term Time-translation invariant owner-doc tree deep-audit + owner-doc vs live repo
Project (multi-instance, unaffected architecture attractor decision record consistency check
by instance lifecycle)
↑
Methodology Time-translation invariant AGE template + copy → fill → project-context authenticity
Template (templatized) START-HERE progressive enhancement verification commands non-placeholder
Each layer solves a different convergence problem, and each layer has a different time structure. RMSP assumes continuous agent existence, converging an instance to a behavioral topology adapted to the current task; the Plan layer faces intermittently existing multi-sessions, converging a single development change to a predetermined scope and closure gate; the Owner-doc layer requires time-translation invariance, converging the project's long-term evolution toward a stable architecture attractor—no matter which agent reads it when, the attractor seen is consistent; the template layer also requires time-translation invariance, but targets new projects starting from scratch.
8. Conclusion
Shared Diagnosis: All three consider the static authoring artifact to be the core limitation of current practice and argue that structural plasticity must be introduced.
Scale Division of Labor: RMSP solves the structural self-evolution of the agent at runtime; AGE/nop-chaos-flux solves the structural convergence of project repositories under high-frequency AI iteration. The two are not substitutes, but complement each other at different scales.
Shared Gating Principle: Generation (LLM proposal / agent implementation) and verification (reward / audit) must be separated. In RMSP, this manifests as
κestimation +F-score; in AGE/nop-chaos-flux, as independent closure audit.nop-chaos-flux is a complete implementation of AGE at the framework level, and also an early validation of RMSP concepts at the repository management level—owner-doc's split/merge/lift/prune/connect/reweight achieves self-organizing evolution of document structures.
The AGE Template is the middle adhesive layer: attractor-guided-engineering-template connects the theoretical paradigm (RMSP) and framework-level practice (nop-chaos-flux), providing a path for application-layer projects to grow progressively from a zygote.
A Verifiable Prediction: If RMSP is engineered and verified in the future, its most natural integration method is not to replace AGE, but to combine with AGE at the agent runtime layer—RMSP drives the adaptation of the agent's own structure, AGE drives the convergence of repository attractors. Together they form a complete "self-evolving development" closed loop.
Top comments (0)