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.

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.
A new version can change how the agent reasons and uses tools.
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.
Unintended
production actions
Data exposure
or unauthorized access
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.
Scoped corrections + reusable rules
↓
Validate, version, and release
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.

- 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.
Changing the scenario resets this round. The selected workflow stays fixed while the round runs.
Step 0 of 4
Failure → scoped feedback
Micro experience → macro guidance
The second option deliberately overgeneralizes a useful correction. Memory generation alone is not sufficient.
Check separate validation cases
| Validation case | Expected | Current | Candidate |
|---|
Toy gate: candidate accuracy must be greater than current accuracy + 5 percentage points.
Five invented cases, separate from the displayed training failure. These are deterministic toy results, not the paper's scores or gate hyperparameters.
Update context, or keep the previous version
Replay a new request
Current refund window: 30 days.
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.

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.