EvoMemState: Evolving Memory State for Personal Agents

Personal agents need to remember what a user said, track how that information changes, and decide how it should affect the current request. EvoMemState stores Persistent Facts in an evolving memory ontology. Retrieval produces a request-specific Relational State, and a policy generates a Reasoning State to guide a frozen response model.

1. Ontology-Guided Memory State Induction extracts Persistent Facts from dialogue and organizes them in a personal memory ontology. The ontology maintains validity, scope, source, time, and relations such as SUPERSEDES and CONFLICTS_WITH.
2. RL-Based State Evolution retrieves a Relational State containing relevant memories and their relations, then trains a Memory State Evolution Policy to generate a Reasoning State. The policy learns from the change in answer quality when that Reasoning State is supplied to a frozen response model.
3. State-Aware Reasoning combines the Relational State and generated Reasoning State to produce the final response.

The figure shows the full method from the manuscript, including policy training. This repository includes inference, GRPO policy training and the slime backend. Training data and model checkpoints are supplied separately.

The complete main table from the EvoMemState manuscript is reproduced below. All values are on a 0–100 scale. Bold and underlined values mark the best and second-best results within each response model, following the manuscript. Higher is better (↑), except for sycophancy rate (↓). Averages are copied directly from the paper.

WTU/HTU: When/How to Use memory. Syco.: sycophancy rate. Use: correct use. CogBias: cognitive bias. Bound.: boundary. The table reports manuscript results; the commands below describe how to run inference.

.
├── README.md
├── .env.example                    # Endpoint configuration template
├── assets/evomemstate_framework.png # Manuscript framework
├── config/                         # Ontology and benchmark configuration
├── evomemstate/
│   ├── builder.py                  # Memory construction
│   ├── extractor.py                # Ontology-guided extraction
│   ├── ontology.py                 # Persistent ontology and updates
│   ├── retrieval.py                # Relational State retrieval
│   ├── reasoning_state.py          # Reasoning State inference
│   ├── reasoning_state_reward.py   # Frozen-answer improvement reward
│   ├── reasoning_state_policy.py   # Policy prompts and training records
│   ├── training_data.py            # External manifest conversion
│   ├── slime_step_info.py          # Rollout metrics
│   ├── prompting.py                # Context for the answer model
│   ├── harness/                    # Context pipeline and rules
│   ├── memsyco_adapter.py          # MemSyco integration
│   ├── memtrap_adapter.py          # MemTrap integration
│   └── run_locomo.py               # LoCoMo-Refined inference
├── slime/                          # Vendored GRPO training backend
├── scripts/                        # Training and benchmark entry points
├── docs/                           # Installation and implementation notes
├── tests/                          # Offline checks
├── envs/                           # Environment definitions
├── pyproject.toml
└── requirements.txt

datasets/ and outputs/ are local runtime directories ignored by Git.

From the repository root, using Python 3.12:

pip install -e .
pip install -r datasets/MemSyco-Bench/requirements.txt

Place MemSyco-Bench at datasets/MemSyco-Bench first. Copy .env.example to .env and fill MEMORY_*, REASONING_STATE_*, GEN_B_*, and JUDGE_* with your model names, endpoints, and keys. Keep credentials in .env.

bash scripts/install_memsyco_adapter.sh
python -m evomemstate.prebuild_graphs --tasks all --limit 3

MODE=smoke bash scripts/run_evomemstate_memsyco.sh

The runner loads .env, reuses existing graphs, and runs inference and scoring on three examples per task. Results are saved to outputs/evomemstate_memsyco/. Use --limit 0 for full graph construction and MODE=full for full inference.

Requires a Linux CUDA training environment with PyTorch, SGLang, Megatron-LM and compatible fused kernels installed. Install the included backend:

pip install -e ./slime

Supply a policy checkpoint, its converted Megatron torch_dist checkpoint and prepared training JSONL. Set the frozen answer endpoint in your local environment, then train:

export MEGATRON_PATH=/path/to/Megatron-LM
export HF_CHECKPOINT=/path/to/Qwen3-4B-Instruct-2507
export REF_TORCH_DIST=/path/to/Qwen3-4B-Instruct-2507_torch_dist
export PROMPT_DATA=/path/to/reasoning_state_train.jsonl
export ANSWER_MODEL=YOUR_FROZEN_ANSWER_MODEL
export ANSWER_BASE_URL=https://YOUR_PROVIDER/v1
# Set ANSWER_API_KEY locally, or use GEN_B_API_KEY from .env.
bash scripts/run_reasoning_state_rl.sh

Training updates only the policy, using the frozen answer score improvement with and without the generated Reasoning State, plus format and answer-leakage penalties. Outputs default to outputs/slime_saved/evomemstate-reasoning-state-qwen3-4b/. No datasets or model weights are bundled. For checkpoint conversion and training input format, see RL setup. After training, export and serve the policy, then point REASONING_STATE_* at its endpoint for inference.

If you use this code, please cite the accompanying EvoTeam paper:

@article{xiang2026evomemstate,
  title={EvoMemState: Evolving Memory State for Personal Agents},
  author={Xiang, Zhishang and Tang, Yunbo and Liu, Zhongqiao and Chen, Junkai and Chen, Zerui and Hu, Qingguo and Zhang, Yuxuan and Grant, William and Zhang, Qinggang Zhang and Su, Jinsong},
  journal={arXiv preprint arXiv:2611.03743},
  year={2026}
}