AutoAgent: Evolving Cognition and Elastic Memory Orchestration for Adaptive Agents

AutoAgent is a self-evolving multi-agent framework that integrates evolving cognition, on-the-fly contextual decision-making, and elastic memory orchestration to enable autonomous agents to adaptively learn from experience and make reliable, context-aware decisions in dynamic environments without external retraining.

The Gist

Imagine you have a brilliant but very rigid assistant. This assistant is great at following instructions, but it has three major flaws:

1. It never learns from mistakes. If it tries a tool and it breaks, it tries the exact same broken tool again next time.
2. It follows a strict script. If the plan goes wrong, it panics because it wasn't told what to do in that specific situation.
3. It has a terrible memory. It remembers everything you ever said, word-for-word, even the boring parts. Eventually, its brain gets so full of old chatter that it can't think clearly anymore.

AutoAgent is the solution to these problems. It's a new kind of AI assistant designed to be self-evolving. Think of it not as a robot following a manual, but as a human apprentice who learns, adapts, and gets smarter every single day.

Here is how AutoAgent works, broken down into three simple concepts:

1. The "Living Notebook" (Evolving Cognition)

Most AI assistants have a "static notebook." You write the rules in it once, and they never change. If you write "The search tool works on Mondays," the AI will try to use it on a Tuesday even if it's broken.

AutoAgent has a Living Notebook.

• How it works: Every time the AI tries to use a tool (like a search engine or a calculator) and it works (or fails), it updates its notebook.
• The Analogy: Imagine a chef. A static chef follows a recipe card that says "Add salt." If the salt is actually sugar, the dish tastes bad, and the chef tries again next time with the same recipe.
  • AutoAgent is a master chef. After the first mistake, the chef writes in their notebook: "Wait, the salt shaker was actually sugar! Next time, I'll taste it first."
  • It also updates its knowledge about its "colleagues" (other AI agents). If one colleague is bad at math but great at writing, AutoAgent learns to ask the math one for numbers and the writing one for stories. It stops asking the wrong person for help.

2. The "Smart Decision Maker" (Contextual Decision-Making)

Old AI systems are like a train on a fixed track. Once the train leaves the station, it can't turn left or right, even if there's a bridge out ahead. It just crashes.

AutoAgent is like a ride-share driver with a GPS.

• How it works: Instead of following a pre-written script, AutoAgent looks at the road right now. It asks: "Do I have the skills to fix this myself? Or should I call a specialist?"
• The Analogy:
  • Emic Action (Self-Drive): The driver sees a pothole and steers around it themselves because they are good at driving.
  • Etic Action (Call for Help): The driver sees a massive truck blocking the road. Instead of trying to push it, they immediately call a tow truck (another AI agent) because they know that's the best move.
  • AutoAgent switches between "doing it myself" and "asking for help" instantly, based on what's happening in the moment.

3. The "Elastic Memory" (Elastic Memory Orchestration)

Imagine you are trying to solve a mystery, but your detective partner keeps reading you the entire history of the world, starting from the Big Bang, every time you ask a question. You'd never get to the point.

AutoAgent has a Magic Filing Cabinet (The Elastic Memory Orchestrator).

• How it works: It doesn't just store everything. It organizes it.
  • Raw Data: It keeps the full, detailed story just in case you need to check the facts later.
  • The Summary: For daily use, it creates a "highlight reel." It says, "On Tuesday, we searched for a hotel, found one, and booked it. We don't need to read the whole conversation again; just remember 'Hotel Booked'."
  • The Analogy: Think of it like a video editor. If you have a 10-hour recording of a trip, a normal AI tries to show you the whole thing. AutoAgent cuts out the boring parts (sleeping, waiting in line) and creates a 5-minute "Best Moments" movie. But if you ask, "What did we eat on day 3?", it can instantly zoom in and show you the raw footage of that specific meal.
  • This keeps the AI's brain light and fast, so it doesn't get overwhelmed by too much information.

The "Self-Improvement Loop"

The magic of AutoAgent is that these three parts talk to each other in a circle:

1. Action: The AI tries to do something.
2. Result: It sees if it worked or failed.
3. Memory: It files the result in its Magic Filing Cabinet.
4. Evolution: It reads its own notes and updates its Living Notebook. "Okay, that tool was slow. Next time, I'll try a different one."

Why Does This Matter?

In the real world, things change. Tools break, websites update, and new problems appear that no one predicted.

• Old AI: "I don't know what to do because my manual doesn't say this."
• AutoAgent: "I've never seen this exact problem, but I've seen similar ones. I'll try this, learn from the result, and get better next time."

In short: AutoAgent is the difference between a robot that follows a script and a smart, adaptable partner that learns from experience, remembers the important stuff, and knows exactly when to ask for help. It turns AI from a "calculator" into a "learner."

Technical Summary

Here is a detailed technical summary of the paper "AutoAgent: Evolving Cognition and Elastic Memory Orchestration for Adaptive Agents."

1. Problem Statement

Current autonomous agent frameworks face three critical limitations that hinder their performance in open-ended, non-stationary environments:

• Static Cognition: Agents rely on fixed, human-written prompts to describe tools, peers, and capabilities. These descriptions cannot be updated through experience, leading to rigid decision-making and the repeated misuse of tools or collaborators.
• Workflow Inflexibility: Agents are often confined to pre-defined, linear reasoning loops. They struggle to adapt when faced with novel situations, unexpected outcomes, or dynamic constraints because their planning logic is not context-sensitive.
• Inefficient Context/Memory Management: Existing systems often treat interaction history as a flat, growing stream of raw text appended to prompts. This leads to token redundancy, slowed reasoning, and an inability to retrieve critical information or distill reusable skills from past experiences.

2. Methodology: The AutoAgent Framework

AutoAgent is a self-evolving multi-agent framework designed to address these limitations through a closed-loop system of Evolving Cognition, On-the-fly Contextual Decision-Making, and Elastic Memory Orchestration.

A. Core Architecture

The framework operates via two tightly coupled cycles:

1. Execution Cycle (Real-time): Handles immediate task progression.
2. Evolution Cycle (Long-term): Analyzes outcomes to refine the agent's knowledge base.

B. Key Components

1. Agent Cognition (The Learnable State)
Instead of static prompts, cognition is structured as an updatable knowledge base with two facets:

• Internal Cognition: A dynamic model of the agent's own capabilities, including Tool Profiles (APIs, preconditions, failure patterns) and a Skill Library (reusable procedural templates distilled from success).
• External Cognition: A dynamic model of the environment and peers, tracking the reliability, expertise, and response patterns of other agents.

2. Contextual Decision-Making (The Action Loop)
Agents operate on an atomic Select-Execute-Update cycle.

• Unified Action Space: Decisions are made from a unified space containing:
  • Emic Actions: Self-driven problem-solving (e.g., tool calls, internal generation) based on Internal Cognition.
  • Etic Actions: Strategic help-seeking or collaboration with peers based on External Cognition.
• Adaptivity: Unlike rigid workflows, the agent dynamically selects the next action based on the current context and evolving cognition, allowing for replanning and recovery from errors.

3. Elastic Memory Orchestration (EMO)
To manage long-horizon tasks efficiently, the EMO module actively organizes history:

• Dual Representation: Maintains both Raw Records (lossless) and Compressed Summaries (semantic essence) for every step.
• Dynamic Retrieval: A selector determines, for each step, whether to use raw data, a summary, or discard the step entirely based on current relevance.
• Episodic Abstraction: Clusters sequences of related steps into Episodic Memories (high-level narratives of sub-tasks). These can be distilled into new skills, bridging the gap between granular experience and generalized knowledge.

4. Cognitive Self-Evolution
This is the meta-cognitive engine that closes the loop:

• Trajectory Analysis: The system compares intended actions with observed outcomes.
• Knowledge Refinement: It generates explicit updates to the Cognition Layer (e.g., correcting a tool's precondition, updating a peer's reliability score) without retraining the underlying LLM.
• Skill Synthesis: Successful sequences of atomic actions are abstracted into Composite Actions (new tools), expanding the agent's capability set autonomously.

3. Key Contributions

1. Evolving Cognition as an Agent State: Introduces a structured, dual-faceted (Internal/External) cognition that is continuously refined through interaction, replacing static prompts with a learnable knowledge base.
2. Unified Contextual Decision-Making: Formulates agent operation as an iterative loop unifying Emic (self-reliant) and Etic (collaborative) actions, enabling adaptive, moment-to-moment reasoning.
3. Elastic Memory Orchestration: Proposes a mechanism for dynamic compression and hierarchical memory construction (episodic abstraction) that reduces token overhead while retaining critical evidence for decision-making.
4. Closed-Loop Cognitive Evolution: Develops a self-improvement mechanism that aligns action outcomes with cognition, allowing agents to adapt to non-stationary environments and create new skills without external retraining.

4. Experimental Results

AutoAgent was evaluated across Retrieval-Augmented Generation (RAG), Tool-Augmented Agents, and Embodied Task environments using both closed-source (GPT-4o, Gemini-3-Pro) and open-source (DeepSeek-R1, QwQ-32B) models.

• RAG Benchmarks (Multi-hop QA): AutoAgent achieved State-of-the-Art (SOTA) results on HotpotQA, 2WikiMultihopQA, and Bamboogle, significantly outperforming baselines like IRCoT and Self-Ask. It demonstrated superior accuracy (e.g., 0.530 on HotpotQA vs. 0.434 for IRCoT) and better context management.
• Tool-Augmented Benchmarks (GAIA, HLE-Bench):
  • On GAIA, AutoAgent achieved a 54.5% overall success rate on Gemini-3-Pro, outperforming the strong DeepAgent baseline by 27.2 percentage points.
  • On HLE-Bench, it consistently achieved the best scores across all model backbones, validating its ability to handle hierarchical planning.
• Embodied Tasks (ALFWorld): Achieved near-perfect success rates (99.3%) on Gemini models, surpassing DeepAgent.
• Ablation Studies:
  • Removing Elastic Memory caused significant performance drops, confirming the necessity of dynamic context compression.
  • Under simulated tool instability, agents with evolving cognition showed substantial improvements (e.g., +12.00% EM on Python code tasks) by learning to identify and avoid unreliable tools, whereas static agents failed to adapt.

5. Significance

AutoAgent represents a paradigm shift from static, script-based agents to adaptive, self-improving systems.

• Practicality: It provides a unified foundation for agents that must learn from experience in dynamic environments without requiring expensive model retraining.
• Scalability: The elastic memory mechanism solves the context-window bottleneck, enabling agents to operate over long horizons efficiently.
• Robustness: By continuously updating its understanding of tools and peers, the system is resilient to changing environments and unreliable external resources.
• Generalizability: The framework successfully bridges single-agent tool use and multi-agent collaboration under a single decision-making logic, offering a scalable path toward general-purpose autonomous problem solvers.