AutoAgent: Evolving Cognition and Elastic Memory Orchestration for Adaptive Agents

📝 Paper Summary

Self-evolving Agentic reasoning Memory organization Multi-agent collaboration

AutoAgent enables autonomous agents to continuously refine their understanding of tools and peers through experience while dynamically managing memory to make efficient, context-aware decisions without external retraining.

Core Problem

Current autonomous agents rely on static, hand-written prompts for tools/peers and rigid pre-defined workflows, leading to inability to learn from mistakes and inefficient context management that slows reasoning.

Why it matters:

Static descriptions cause agents to repeatedly misuse tools or overlook capable collaborators because initial prompts are incomplete or outdated
Fixed reasoning loops fail in non-stationary environments where optimal actions depend on evolving context rather than pre-set plans
Linear memory growth leads to token redundancy and high costs, as agents treat history as raw text rather than structured, reusable knowledge

Concrete Example: An agent may repeatedly fail to use a specific tool because the provided documentation omits a critical precondition. In standard frameworks, this error repeats endlessly; AutoAgent would analyze the failure, update the tool's internal description to include the missing precondition, and succeed in future attempts.

Key Novelty

Closed-Loop Evolving Cognition with Elastic Memory

Formalizes agent state as 'Cognition' (internal self-knowledge and external peer models) that is explicitly rewritten and updated based on interaction outcomes, rather than remaining static.
Unifies action selection into a single space containing both 'Emic' (self-reliant tool use) and 'Etic' (help-seeking) actions, replacing rigid workflow graphs with on-the-fly decision making.
Introduces an Elastic Memory Orchestrator that actively compresses history into episodic abstractions and reusable skills, reducing token overhead while preserving decision-critical evidence.

Architecture

The AutoAgent architecture illustrating the interaction between Cognition, Decision, Memory, and Evolution components across two cycles (Execution and Evolution).

Evaluation Highlights

Consistent improvements in task success and tool-use efficiency across retrieval-augmented reasoning and embodied task environments compared to static baselines.
Demonstrates robust collaborative performance by dynamically updating peer expertise models, outperforming fixed-role multi-agent systems.
Reduces token overhead significantly through elastic memory compression while maintaining or improving reasoning accuracy in long-horizon tasks.

Breakthrough Assessment

8/10

Strong contribution in unifying memory management with continuous self-improvement. The explicit rewriting of agent prompts (cognition) based on experience is a practical step toward truly adaptive agents.

⚙️ Technical Details

Problem Definition

Setting: Open-ended autonomous problem solving in non-stationary environments involving tool use and multi-agent collaboration

Inputs: Task objective, available tools/peers, and evolving interaction history

Outputs: Sequence of actions (tool calls, communication, generation) leading to task completion

Pipeline Flow

Cognition Layer (Stores tool/peer knowledge)
Elastic Memory Orchestrator (Provides compressed context)
Contextual Decision Engine (Selects Emic/Etic action)
Environment/Peers (Executes action)
Cognitive Evolution Module (Updates Cognition based on outcome)

System Modules

Cognition Layer

Maintains updatable textual descriptions of tools (Internal) and peers (External)

Model or implementation: Text-based storage (Prompt Components)

Elastic Memory Orchestrator

Compresses raw history, summarizes episodes, and retrieves relevant context

Model or implementation: LLM-based summarizer/retriever

Contextual Decision Engine

Selects next action from unified space (Emic/Etic) based on context and cognition

Model or implementation: LLM Inference (Planner)

Cognitive Evolution Module

Analyzes trajectories to identify intent-outcome discrepancies and generates text updates

Model or implementation: LLM-based Reflector

Novel Architectural Elements

Dual-cycle architecture: Fast Execution Cycle for action selection vs. Slow Evolution Cycle for knowledge updating
Unified action space merging Emic (self) and Etic (social) actions, replacing fixed workflow graphs
Explicitly updatable Cognition Layer where prompt components (tool docs, peer profiles) are rewritten by the system itself

Modeling

Base Model: Large Language Models (specific model variants not explicitly detailed in summary text)

Training Method: In-context evolution / Self-reflection updates

Adaptation: None (Prompt/Memory evolution only)

Compute: Not reported in the paper

Comparison to Prior Work

vs. ReAct/Toolformer: AutoAgent updates tool descriptions/cognition at runtime without retraining
vs. MemGPT: AutoAgent actively distills experience into reusable skills and cognitive updates, not just memory retrieval
vs. Reflexion: AutoAgent couples reflection with a structured, persistent cognitive state (Internal/External cognition) rather than just episodic verbal feedback

Limitations

Reliance on LLM capability for self-diagnosis and prompt rewriting
Potential for error propagation if the Evolution Module misinterprets a failure and corrupts the Cognition Layer
Latency costs associated with the dual-cycle processing (execution + evolution analysis)

Reproducibility

Code: https://github.com/vicFigure/AutoAgent

Codebase will be released at https://github.com/vicFigure/AutoAgent. Paper claims specific benchmarks (tool-augmented, embodied) but specific hyperparameters are not detailed in the provided text.

📊 Experiments & Results

Evaluation Setup

Evaluated across retrieval-augmented reasoning, tool-use benchmarks, and embodied task environments

Benchmarks:

Retrieval-Augmented Reasoning tasks (Information seeking and reasoning)
Tool-Augmented Agent benchmarks (Complex tool usage)
Embodied Task Environments (Interactive environment tasks)

Metrics:

Task success rate
Tool-use efficiency
Collaborative robustness
Statistical methodology: Not explicitly reported in the paper

Main Takeaways

AutoAgent consistently improves task success rates compared to static and memory-augmented baselines.
The framework demonstrates higher tool-use efficiency, likely due to the evolving Internal Cognition that refines tool preconditions.
Collaborative robustness is enhanced through External Cognition, allowing agents to adapt to peer capabilities better than fixed-role systems.
Elastic Memory Orchestration effectively reduces token overhead while retaining critical information for long-horizon reasoning.

📚 Prerequisite Knowledge

Prerequisites

Agentic workflows (ReAct, Toolformer)
Large Language Models (LLMs) as reasoning engines
Basic understanding of episodic vs. semantic memory

Key Terms

Emic Action: Self-driven problem-solving actions using the agent's internal capabilities and tools

Etic Action: Collaborative actions involving seeking assistance from external peer agents

Internal Cognition: The agent's structured knowledge about its own tools and capabilities (skills)

External Cognition: The agent's model of peer agents, their expertise, and environmental dynamics

Elastic Memory Orchestrator: A module that dynamically organizes, compresses, and retrieves interaction history to optimize context usage

Cognitive Evolution Loop: The cycle where experience is analyzed to update the text-based descriptions in the Cognition Layer

SFT: Supervised Fine-Tuning—training a model on labeled examples to specialize it for a task