ARISE: Practical Self-Evolving Memory for Accurate and Cost-Efficient Enterprise Agents

Jiangyun Zhang, Zhou Tang, Kristen Surrao, Zhiyu Chen, Albert Guan, Tor Nitayanont, Yupei Zhang, Roopali Singh, Yunkai Xiao, Shreya Pandit, Julia Huang, Shayan Ali Akbar, Erwin Cornejo, Yuan Li, Yi ZhangarXiv 2026 · arXiv

This paper from researchers at Amazon introduces ARISE (Agent Refinement through Iterative Self-Evaluation), a practical memory architecture designed to help enterprise LLM agents improve over time without the need for expensive model retraining or manual prompt engineering.

TL;DR

ARISE is a dual-memory system that allows LLM agents to learn from their own failures by automatically generating specific "micro-corrections" and general "macro-rules." By using a validation gate to ensure only helpful updates are kept, ARISE significantly boosts accuracy across complex enterprise workflows while actually reducing per-task costs and token usage.

What Problem Does This Paper Address?

Enterprise LLM agents operate in a "moving target" environment. Foundation models are updated monthly, and business Standard Operating Procedures (SOPs) change frequently. Traditionally, fixing an agent that fails a specific task requires manual prompt engineering or fine-tuning—both of which are labor-intensive and expensive. Furthermore, as prompts get longer to include more context or few-shot examples, the cost per request rises.

The authors identify a need for a system that:

  1. Self-Evolves: Learns from experience without human intervention.
  2. Stays Fixed: Works with frozen model weights and fixed workflow logic.
  3. Remains Efficient: Improves accuracy without ballooning inference costs.

Methods

ARISE employs an offline iterative loop to evolve the agent's memory (see Figure 2).

Figure 2: ARISE architecture. The deployed model weights, tools, and workflow logic stay fixed. An offline loop attributes failed tasks using the trace, the output, the post-task outcome and diagnostic feedback, stores micro corrections, consolidates macro rules, and accepts a rule update only if held-out validation accuracy improves.

The process consists of three main stages:

  • Failure Attribution: When an agent fails a task (identified by post-task feedback), an "attributor" (either the agent itself or a stronger "Teacher" model) analyzes the trace and writes a scoped correction in a [WHEN: condition] action format.
  • Memory Adaptation: These corrections are stored in two layers:
  • Micro Memory: A retrievable store of specific task-level corrections, accessed via embedding similarity at inference time.
  • Macro Memory: A small, bounded set (max $K$) of consolidated procedural rules that are injected into every prompt.
  • Validation Gate: This is a critical safety feature. Before any new macro-rule is deployed, it must pass a held-out validation set. If accuracy doesn't improve, the update is rejected.

At inference time, the agent receives the macro-rules and the most relevant micro-corrections, allowing it to avoid past mistakes.

Datasets

The researchers evaluated ARISE across 14 enterprise-workflow domains using two primary benchmarks:

  • SOP-Bench: 11 domains (1,813 tasks) involving complex industrial standard operating procedures where the agent must reach a specific decision.
  • $\tau^2$-bench: 3 domains (airline, retail, telecom) featuring multi-turn conversations and tool-use.

They tested the system across five different models, including Claude (Opus 4.6, Sonnet 4.6, Haiku 4.5), DeepSeek v3.2, and Qwen3-32B.

Key Insights and Ideas

  • The Efficiency Paradox: Counter-intuitively, adding memory to a prompt can lower costs. While the prompt is longer, the improved accuracy means the agent makes fewer redundant tool calls and generates shorter, more direct reasoning traces. ARISE-Teacher achieved a 5.2% reduction in output tokens.
  • Teacher vs. Self: While using a stronger model as a teacher (ARISE-Teacher) provides the best results, the "ARISE-Self" configuration—where the deployment model attributes its own failures—still captures the vast majority of the gains.
  • Validation is Essential: The validation gate rejected updates in 32% of training runs. Without this gate, "hallucinated" or over-generalized rules could easily regress performance.
  • Dual-Memory Synergy: Macro-rules provide the bulk of the accuracy gains, while micro-memory acts as a high-precision buffer for rare edge cases that don't warrant a global rule.

Key Results

ARISE consistently pushes the Pareto frontier of accuracy vs. cost (see Figure 1).

Figure 1: Overall accuracy over the 14 domains plotted against SOP-Bench cost per task, per model. The over- all accuracy is the 11:3 blend of the suite averages in
  • Accuracy Gains: ARISE-Teacher improved baseline accuracy by 10.9 percentage points (pp) on SOP-Bench and 5.8 pp on $\tau^2$-bench.
  • Outperforming Baselines: It outperformed GEPA (a state-of-the-art prompt evolution method) by 4.5 pp on $\tau^2$-bench.
  • Cost Efficiency: Despite the extra memory context, ARISE-Teacher reduced model calls by 4.0% and achieved a -1.0% change in per-task cost.
  • Rapid Convergence: Most accuracy gains are realized within the first 2-3 iterations of the training loop (see Figure 3).
Figure 3: Best SOP-Bench validation accuracy so far after each training iteration, averaged over training runs and models. Iteration 0 is the original prompt on the validation set.

Limitations and Future Work

  • Verifiable Outcomes: ARISE currently requires a clear "pass/fail" signal or expected output to trigger the attribution loop. Extending this to ambiguous tasks without clear ground truth is a future challenge.
  • Static Tools/Logic: The current system only evolves memory. The authors suggest that future work could extend this loop to allow agents to suggest updates to their own tools or workflow logic.
  • Governance: The paper does not deeply explore data governance or the long-term "safety" of self-evolved rules in a production environment, which would be critical for enterprise deployment.

Summary updated

Abstract

Enterprise LLM agents operate in dynamic environments where foundation models evolve rapidly, workflows update frequently, and deployments need to satisfy accuracy and cost requirements. We propose ARISE (Agent Refinement through Iterative Self-Evaluation), a practical memory architecture in which the agent's memory evolves from its own failures without updating model weights, tools, or workflow logic. ARISE uses the model itself or a teacher model to attribute the failures and propose corrections. Then, ARISE keeps the corrections as retrievable micro memory, consolidates them into macro rules, and accepts a rule update only if held-out accuracy rises. Across 14 enterprise-workflow domains from SOP-Bench and $τ^2$-bench using 5 models, ARISE-Teacher, which uses Claude Opus 4.6 for attribution and consolidation, gains 10.9 pp over the baseline on SOP-Bench and 5.8 pp on $τ^2$-bench. ARISE-Teacher also outperforms GEPA by 4.5 pp on $τ^2$-bench and 1.4 pp on SOP-Bench. With the deployment model as its own attributor, ARISE-Self still gains 10.0 pp on SOP-Bench. ARISE-Teacher uses 4.0% fewer model calls and 5.2% fewer output tokens at comparable per-task cost (-1.0%).
BibTeX
@misc{zhang2026arise,
  author = {Jiangyun Zhang and Zhou Tang and Kristen Surrao and Zhiyu Chen and Albert Guan and Tor Nitayanont and Yupei Zhang and Roopali Singh and Yunkai Xiao and Shreya Pandit and Julia Huang and Shayan Ali Akbar and Erwin Cornejo and Yuan Li and Yi Zhang},
  title = {{ARISE: Practical Self-Evolving Memory for Accurate and Cost-Efficient Enterprise Agents}},
  year = {2026},
  eprint = {2611.23588},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.23588},
}
Figure