Maxwell Zhang
← All writing
WORKING DRAFT
Research notes / 002

Practical RSI for
Enterprise Agents

An introduction to RSI, why enterprise agents need continual adaptation, and the ARISE memory architecture we designed.

3 min read

01 / What’s RSI?

Recursive self-improvement (RSI) concerns systems that can modify themselves and carry the selected improvements into subsequent improvement rounds. The ambitious version includes improving the process of improvement itself.

The research spans different update surfaces. Darwin Gödel Machine explores agents that modify their code and evaluate the resulting versions. Reflexion instead reuses verbal feedback in memory without updating model weights. These are different mechanisms, with different boundaries.

A complete RSI cycle: try, evaluate, propose and validate a change, then carry accepted changes back into the next round.

Our focus is a bounded enterprise adaptation loop inspired by this direction: learn from failures through memory, while keeping the operational runtime fixed. We do not claim that ARISE demonstrates open-ended recursive capability growth.

02 / A Changing Environment

Enterprise agents operate in an environment that keeps evolving along two independent dimensions.

v1v2Model update

A new version can change how the agent reasons and uses tools.

Policy APolicy BWorkflow update

Policies and procedures change independently of the model.

A useful enterprise improvement loop must be rerunnable: collect fresh traces under the current configuration, adapt the guidance, and revalidate before release.

03 / RSI in Enterprise Applications

Open-ended self-improvement carries real risks in enterprise settings. An agent that freely rewrites its tools can change how production actions are executed. Expanding its own access can expose sensitive data or enable unauthorized operations. Rewriting the base prompt can weaken policy instructions, change task objectives, or remove escalation requirements. Better performance on a few tasks does not justify changing these boundaries.

SELF-EVOLUTION / ENTERPRISE RISKS
Rewrite tools

Unintended
production actions

Expand access

Data exposure
or unauthorized access

Edit base instructions

Policy drift
or skipped escalation

Memory is a more practical starting point for enterprise self-evolution. An agent can learn from failures through scoped corrections and reusable rules while its tools, permissions, workflow, and base instructions stay fixed. Memory updates can be inspected, validated, versioned, and rolled back without giving the agent authority to rewrite its operating contract.

This is the boundary we use in ARISE: evolve the memory injected into the agent’s context. Memory can still introduce harmful guidance, so proposed updates need evaluation before deployment.

04 / Our Solution: ARISE

We designed ARISE—Agent Refinement through Iterative Self-Evaluation—to turn an agent's failures into compact, inspectable memory while leaving model weights, tools, and workflow logic unchanged.

ARISE Figure 1: fixed runtime produces traces and feedback; self or teacher attribution produces micro corrections, consolidation proposes macro rules, held-out validation accepts or retains prior rules, and operational memory is retrieved back into runtime. Micro retrieval is screened separately.
Micro memory preserves the lesson
We attribute failures using traces and feedback, then store corrections with a clear scope. Attribution can use the deployment model or a teacher.
Macro memory distills reusable guidance
We consolidate corrections into a bounded rule set rather than injecting an ever-growing history into every request.
The gate controls rule updates
We evaluate macro candidates on held-out tasks and retain the previous rules unless the update clears the acceptance margin. Micro retrieval is screened separately.
Optional demo: try the memory update gate

A toy refund agent ignores the return deadline. Compare a scoped correction with an overgeneralized rule, then see what validation allows into runtime memory.

Interactive / ARISE mechanism walkthrough
Tools fixedPermissions fixedMemory can change

Changing the scenario resets this round. The selected workflow stays fixed while the round runs.

01Observe failure
02Build memory
03Validate
04Release or retain

Step 0 of 4

Replay a new request

Current refund window: 30 days.

Without memoryAPPROVE
Active runtime memoryAPPROVE

Inspect active macro memory

Local, deterministic simulation. No LLM or enterprise tools are called. The demo illustrates the macro update gate; micro retrieval and its separate gate are not simulated.

05 / Results: Accuracy and Cost

Our Figure 2 compares five models on the same accuracy–cost plane. Overall accuracy spans 14 domains; the horizontal axis uses actual SOP-Bench inference cost per task on a logarithmic scale.

ARISE Figure 2 setup: overall accuracy across 14 domains versus actual SOP-Bench inference cost per task in USD on a shared logarithmic axis. Hollow baseline points and filled ARISE-Teacher points form separate Pareto frontiers for five models.
Research & sources

RSI background: Schmidhuber on meta-learning and RSI; Darwin Gödel Machine; Reflexion. The animations are our explanatory drawings, not figures copied from these papers.

Our design is described in the ARISE working manuscript, ARISE: Practical Self-Evolving Memory for Accurate and Cost-Efficient Enterprise Agents, especially Sections 3 and 5. Its accuracy gate is not a substitute for application-level safety checks. Results follow Figure 2 and Table 9. The blog and demo are drafts for author review.