Task Memory Engine (TME)

• Task Memory Engine (TME) is a modular memory framework that restructures traditional linear context into persistent, hierarchical, and graph-based representations for LLM agents.
• It employs dynamic prompt synthesis and the TRIM module to efficiently track task dependencies, corrections, and multi-step interactions.
• Empirical benchmarks indicate improvements in token efficiency, error reduction, and elimination of hallucinations, enhancing overall task accuracy.

The Task Memory Engine (TME) is a structured, modular memory framework designed to enhance LLM agents in multi-step, interactive tasks by introducing persistent, graph-based memory and dynamic prompt synthesis. TME systematically addresses the shortcomings of linear context concatenation—namely, susceptibility to hallucinations, weak executional coherence, and an inability to support dependency-tracked revision—by formalizing the agent’s working memory as hierarchical or graph-based structures capable of tracking task execution, dependencies, and user corrections across multiple steps and scenarios (Ye, 26 May 2025, Ye, 11 Apr 2025, Zhang et al., 9 Jan 2026).

1. Motivations and Limitations of Linear Context

LLM agents traditionally rely on flat, sequential concatenation of previous input/output exchanges into prompts, or on shallow sliding-window buffers. These approaches are brittle in extended multi-turn settings:

• Brittle state management: Agents lose relevance over which parts of the past context are pertinent, leading to contradictory or redundant actions.
• Hallucination risk: With no persistent record of completed steps or resolved corrections, LLMs may generate outputs unanchored in previous exchanges.
• Limited coherence: The history buffer grows rapidly, impeding the capacity of the model to reference or ground long-range dependencies, especially as token budgets are exhausted.

TME fundamentally restructures the agent memory by tracking task progress as a tree or more generally as a directed acyclic graph (DAG), supplying explicit dependency management and persistent, semantically interpretable state (Ye, 26 May 2025, Ye, 11 Apr 2025).

2. Core Architecture: Task Memory Structures

TME organizes the agent's execution memory as a dynamic, rooted tree (Task Memory Tree, or TMT), and extends this formalism to graph-based representations for subtask reuse and converging workflows (Ye, 11 Apr 2025):

• Node representation: Each node $n_i \in \mathcal{N}$ is a tuple

$$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$

where $\text{input}_i$ and $\text{output}_i$ are the data processed at step $i$, $\text{status}_i$ encodes execution (e.g., waiting, active, done, failed), and $\mathcal{C}_i$ is the set of child (subtask) nodes.

• Parent–child and dependency links: $\mathrm{parent}(n_j)=n_i$ if $n_j \in \mathcal{C}_i$. For DAG extensions, a dependency set $\mathcal{D}_i \subseteq \mathcal{N}$ encodes non-hierarchical cross-links, which enable subtask reuse (nodes with multiple parents) and shared dependencies.
• Active path extraction: For any node $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$0, its contextually relevant memory is the unique root-to-leaf path $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$1, allowing memory to be pruned to just the steps leading up to the current focus, possibly augmented with relevant cross-links.

This structure provides a persistent, interpretable record of the agent’s reasoning and state evolution, directly supporting corrections, merges, rollbacks, and step-dependent logic.

3. Prompt Synthesis and the Task Relationship Inference Module (TRIM)

TME's prompt generation is orchestrated via a Prompt Synthesizer operating on structured memory and a Task Relationship Inference Module (TRIM) (Ye, 11 Apr 2025):

• Dynamic prompt extraction: For each new action, TME synthesizes a prompt from the active path $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$2, aggregating, for each $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$3, the $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$4 triplets. Additional dependency information may be included if the path is augmented by DAG cross-links.
• Pseudocode summary:

$\text{input}_i$0 This mechanism guarantees token-efficient, relevant context for the LLM, supporting long-horizon execution and robust correction handling, starkly contrasting with flat history concatenation.

• TRIM operations: TRIM automatically infers relationships such as subtask creation, rollback, or merge events based on incoming user instructions and the extant node set, either through similarity heuristics or more advanced classifiers (potentially LLM-assisted or GNN-based in extensions), ensuring that the task graph remains consistent with user intent and operational semantics.

4. Empirical Effects and Performance Metrics

Empirical studies and benchmarks confirm TME's substantive improvements over traditional prompt-chaining (Ye, 11 Apr 2025):

• Token savings: In a six-round form-filling setting, TME achieved 19.4% reduction in token usage (peaking at 26.4% during corrections) compared to flat history replay.
• Coherency and correction: TME eliminated redundant prompt requests for already-corrected fields, avoiding confusion from prior values—a failure mode observed in baseline agents.
• Task accuracy and error reduction: Systematic reduction in error rates (by 5–12%), zero re-asking of corrected data, and proportionally lowered LLM API costs.
• Generalization: When task correction or step reuse was required, TME efficiently merged history nodes, maintaining a minimal and accurate prompt reflecting only the effective correction.
• Multi-scenario evaluation: In scenarios including trip planning, cooking, scheduling, and shopping cart editing, TME eliminated 100% of hallucinations and misinterpretations in most tasks, and reduced remaining errors by 66.7% and 83.3%, respectively, across 27 agent-user exchanges (Ye, 26 May 2025).

StackPlanner (Zhang et al., 9 Jan 2026) further demonstrates the effectiveness of a TME-like module in hierarchical, multi-agent settings, particularly with procedures such as context condensation (“Revise”) and the integration of persistent, procedural “Experience Memory.” Empirical results confirm that both short-term Task Memory and cross-task Experience Memory significantly enhance agent performance (e.g., 2–10 F1 point improvements on agentic benchmarks and a >15% boost in cross-task generalization when procedural memory is enabled).

5. Advanced Features: Task Experience Memory and RL-Based Memory Control

In multi-agent systems, the Task-Experience Memory Engine is extended with specialized memories (Zhang et al., 9 Jan 2026):

• Task Memory Stack: Maintains per-task, short-term coordination actions as discrete records $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$5, representing planner actions and summarized sub-agent outputs.
• Experience Memory: Stores long-term, reusable knowledge as profiles, semantic facts, and procedural scripts in key-value form, indexable via vector embeddings of context.
• RL-based memory optimization: StackPlanner implements Group Relative Policy Optimization (GRPO), wherein the planner’s policy $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$6 learns to retrieve, condense, or update memory entries for efficient, minimal context during decision-making. No separate replay buffer exists; the Experience Memory itself serves as a stochastic, nonparametric retrieval bank.

These designs allow the agent to dynamically retrieve relevant standard operating procedures (SOPs), perform context condensation, and support procedural knowledge transfer, all under bounded memory and token budgets.

6. Implementation, Complexity, and Integration Guidelines

TME is released as open-source code comprising modular components (Ye, 11 Apr 2025):

• Repository: https://github.com/biubiutomato/TME-Agent
• Key modules:
  • tmt.py: TaskMemoryTree with node addition, update, serialization, and path extraction.
  • trim.py: TRIM module for relationship inference and memory graph maintenance.
  • prompt_synthesizer.py: Dynamic prompt generation.
• Complexity overview:
  • Memory scales linearly, $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$7, in completed task steps; prompt synthesis is $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$8 in active path length; TRIM is $$n_i = \bigl(\text{input}_i,\,\text{output}_i,\,\text{status}_i,\,\mathcal{C}_i\bigr)$$9 per inference, with heuristics possible for pruning.
  • The computational and memory overhead is minor compared to LLM inference, and prompt/token savings are substantial.
• Integration guidance: Practitioners are advised to carefully choose step granularity, customize TRIM rules for domain specificity, and adapt prompt templates for application-specific requirements. A plausible implication is that the choice of graph granularity directly affects both prompt interpretability and memory overhead.

7. Extensions and Future Directions

TME research identifies several avenues for further exploration (Ye, 11 Apr 2025):

• DAG-native memory: Full generalization to DAG structures enables subtask reuse and convergent flows, requiring enhanced cycle prevention and rollback mechanisms.
• Graph Neural Networks: Using GNNs for global relationship inference within memory graphs is proposed to replace local heuristics and support more nuanced dependency modeling.
• LLM-augmented relationship management: In ambiguous memory update cases, LLMs themselves can arbitrate relationship classification, blending symbolic and neural reasoning.
• Visual debugging tools: Interactive graph visualization supports debugging, tracing, and optimization of agent workflow.
• Cross-task transfer: Empirical results indicate that persistent procedural memory enables significant zero-shot generalization improvements in multi-step QA and planning tasks (Zhang et al., 9 Jan 2026).

The TME paradigm thus provides a robust, extensible, and computationally efficient foundation for deploying reliable LLM agents in complex, interactive, and correction-prone environments, with broad applicability across research and industrial automation contexts.