π±VitaBench 2.0: Evaluating Personalized and Proactive
Agents in Long-Term User Interactions
π Paper β’ π Website β’ π€ Dataset β’ π± VitaBench 1.0
π English version benchmark coming soon.
## π News
- [2026-06] **VitaBench 2.0** is released β extending VitaBench from one-shot tasks to **long-term, multi-session user interactions**, with an extensible memory interface and a personalization leaderboard. π
- [2026-01] VitaBench has been accepted to **[ICLR 2026](https://openreview.net/forum?id=rtcX9qOBaz)**! π
- [2025-10] The original [VitaBench](https://github.com/meituan-longcat/vitabench) suite is released, including the **codebase, dataset and evaluation pipeline**.
## π Introduction
Large language models (LLMs) have evolved into interactive agents that collaborate with users in real-world tasks. Effective collaboration increasingly depends on understanding the user *beyond what is explicitly stated*: user intent is often reflected in fragmented daily interactions and requires both **personalized modeling** and **proactive interaction**. We introduce **VitaBench 2.0**, a benchmark for evaluating personalized and proactive agent behavior in long-term user interactions.
**VitaBench 2.0** extends [VitaBench](https://github.com/meituan-longcat/vitabench) from one-shot tasks to **long-term, multi-session user interactions**, where an agent must *infer*, *utilize*, and *update* user preference across fragmented conversations and behaviors that span days, weeks, or months. While VitaBench 1.0 measures whether an agent can complete a single complex life-serving request, VitaBench 2.0 further asks: **can an agent understand the user from daily interactions, anticipate their evolving needs, and act on their behalf β over time?**
Concretely, each evaluation is a **single user with a sequence of subtasks** drawn from the three life-service domains of VitaBench (food **delivery**, in-store consumption, and online travel / **OTA**). Between subtasks the agent's memory module is updated from the prior interaction; at the start of each subtask the memory is injected into the system prompt. The benchmark's core question is: *which memory backend lets the agent answer personalized queries correctly?*
To support systematic analysis, we provide an **extensible memory interface** that enables controlled comparison across representative memory architectures:
- **Full Context** β the entire interaction history is appended to the prompt, an upper bound on what the model can possibly leverage.
- **Agentic / Rewrite Memory** β the agent maintains a single consolidated memory store, deciding what to write and read across subtasks.
- **RAG Memory** β past interactions are chunked, embedded, and retrieved on demand.
Our results show that even SOTA models reach only **~50% Avg@4** under Full Context and degrade further under realistic memory settings, indicating that long-horizon personalization and proactivity remain open challenges for current LLM agents.
> *The name "Vita" derives from the Latin word for "Life", reflecting our focus on life-serving applications.*
## π± Benchmark Details
VitaBench 2.0 reuses the three life-service environments of VitaBench and recomposes them into **per-user, multi-subtask sequences**. Each task represents a single user, and each subtask within it provides:
- **An instruction** β what the user is asking for in this subtask.
- **The user's ground-truth preferences** β the correct personalized preferences the agent is expected to have learned and applied, used as the reference for scoring.
- **Prior interaction history** β the user's earlier conversations and behaviors that the agent can draw on to infer those preferences.
- **A rubric** β the criteria used to judge whether the agent's response is correct.
- **A candidate environment** β a pool of real-world entities (restaurants, shops, hotels, trains, flights, or attractions, depending on the domain) that mixes the correct target with plausible distractors, so the agent must select the right one rather than guess.
| Personalization dataset | |
| :---------------------- | :------: |
| Users (tasks) | 56 |
| Subtasks (total) | 771 |
| Subtasks per user (avg) | ~14 |
| Domains covered | delivery Β· instore Β· ota |
Within a task, the agent works through the user's subtasks one at a time. Before each subtask (except the first), the agent's memory is updated from the previous interaction and injected into its context, so knowledge about the user accumulates over time. The agent then handles the current subtask by conversing with the user and calling tools in the relevant domain, and its response is scored against that subtask's rubric. Once all subtasks are done, the per-subtask scores are aggregated into an overall result for the user.
## π οΈ Quick Start
### 1. Install
```bash
git clone https://github.com/meituan-longcat/VitaBench-2.0.git
cd VitaBench-2.0
pip install -e .
```
This installs the `vita` CLI.
### 2. Download the dataset
VitaBench 2.0 tasks are hosted on Hugging Face: [meituan-longcat/VitaBench-2.0](https://huggingface.co/datasets/meituan-longcat/VitaBench-2.0).
```bash
pip install -U "huggingface_hub[cli]"
huggingface-cli download meituan-longcat/VitaBench-2.0 \
--repo-type dataset \
--local-dir data/vita/domains/personalization
```
After downloading you should have `data/vita/domains/personalization/tasks.json` (56 users, 771 subtasks).
> The original VitaBench domains (`delivery`, `instore`, `ota`, cross-domain) are still supported β download them from the [VitaBench 1.0 dataset](https://huggingface.co/datasets/meituan-longcat/VitaBench) and place each under `data/vita/domains//tasks.json`.
### 3. Configure the LLM
```bash
cp src/vita/models.yaml.example src/vita/models.yaml
export OPENAI_API_KEY=sk-...
```
`src/vita/models.yaml` supports any OpenAI-compatible endpoint β change `default.base_url` to point at Azure, vLLM, Together, llama.cpp, etc. The YAML supports `${VAR}` placeholders expanded from your shell at startup; an unset variable raises a clear error. To relocate the file, set `VITA_MODEL_CONFIG_PATH`:
```bash
export VITA_MODEL_CONFIG_PATH=/path/to/your/models.yaml
```
For RAG / embeddings, optionally override the embedding provider:
| Env var | Default | Purpose |
|---------|---------|---------|
| `VITA_EMBEDDING_URL` | `models.yaml default.base_url` | Embedding endpoint |
| `VITA_EMBEDDING_KEY` | `models.yaml default.api_key` | Embedding API key |
| `VITA_EMBEDDING_MODEL` | `text-embedding-3-large` | Embedding model name |
| `VITA_EMBEDDING_MAX_CONCURRENCY` | `64` | Per-event-loop semaphore size |
### 4. Run a personalization evaluation
```bash
vita run \
--domain personalization \
--memory-type rewrite \ # null | rewrite | rag | rag_cache | full_context | groundtruth
--agent-llm gpt-4.1 \
--user-llm gpt-4.1 \
--evaluator-llm gpt-4.1 \
--max-steps 50 \
--max-concurrency 50 \
--save-to mytest/rewrite.json \ # resolved under data/simulations/
--log-level INFO
```
Subset the run with `--num-tasks N` or `--task-ids β¦`. Results are written under `data/simulations/`.
### 5. Run all memory backends in parallel
`scripts/run_memory_benchmark.sh` launches one `vita run` per memory type concurrently, holding `--max-steps`, `--max-concurrency` and the agent/user/evaluator LLMs identical across runs (the only fair way to compare backends):
```bash
bash scripts/run_memory_benchmark.sh full_context rewrite
```
Logs and per-backend results land in `data/simulations/memory_benchmark_/`, with a reward summary table printed on completion.
### Memory backends
| `--memory-type` | Behaviour |
|-----------------|-----------|
| `null` | No memory (baseline lower bound) |
| `groundtruth` | Injects the canonical preference memory directly (oracle upper bound) |
| `full_context` | Appends every prior interaction, token-truncated from the head |
| `rewrite` | LLM rewrites a single consolidated memory string each update (*agentic*) |
| `rag` | Async vector retrieval (`text-embedding-3-large` by default) |
| `rag_cache` | Same retrieval as `rag`, but embeddings are precomputed (see `scripts/precompute_rag_cache.py`) |
Per-backend defaults (RAG `top_k` / `similarity_threshold` / `chunk_size`, Rewrite / FullContext `max_tokens`) live in `src/vita/memory.yaml`; constructor kwargs override the YAML. Plug in a custom backend with `--memory-class my_pkg.MyMemory` (takes precedence over `--memory-type`).
### Re-evaluate existing simulations
```bash
vita run \
--re-evaluate-file \
--evaluation-type \
--evaluator-llm gpt-4.1 \
--save-to
```
### View results
```bash
vita view --file
```
### Other CLI knobs worth knowing
| Flag | Effect |
|------|--------|
| `--enable-think` | Enable agent thinking mode |
| `--enable-outcome-reward` | Personalization only: combine trajectory reward with action-level outcome reward via `min()` |
| `--num-trials N` | Repeat each task N times (for Avg@N / Pass@N / Pass^N) |
| `--language chinese\|english` | Prompt / task language (default `chinese`) |
| `--max-errors N` | Max consecutive tool errors before aborting a task |
| `--csv-output ` | Append per-task results to a CSV |
## π Leaderboard
Performance of non-thinking and thinking models under three memory settings, sorted by **Avg@4** under **Full Context**. Best results in each column are in **bold**.
Non-thinking Models
Model |
Full Context |
Agentic Memory |
RAG Memory |
| Avg@4 | Pass@4 | Pass^4 |
Avg@4 | Pass@4 | Pass^4 |
Avg@4 | Pass@4 | Pass^4 |
| GPT-4o-mini | 0.067 | 0.180 | 0.006 | 0.084 | 0.229 | 0.008 | 0.094 | 0.227 | 0.011 |
| GPT-3.5-Turbo | 0.140 | 0.314 | 0.019 | 0.231 | 0.467 | 0.056 | 0.205 | 0.409 | 0.059 |
| LongCat-Flash-Chat | 0.298 | 0.510 | 0.123 | 0.302 | 0.537 | 0.105 | 0.290 | 0.471 | 0.136 |
| GLM-4.5 | 0.307 | 0.529 | 0.127 | 0.330 | 0.569 | 0.112 | 0.316 | 0.523 | 0.152 |
| Doubao-Seed-1.6 | 0.326 | 0.512 | 0.171 | 0.340 | 0.576 | 0.129 | 0.351 | 0.543 | 0.174 |
| GLM-4.6 | 0.342 | 0.612 | 0.113 | 0.336 | 0.623 | 0.084 | 0.317 | 0.555 | 0.123 |
| Kimi-K2.6 | 0.378 | 0.632 | 0.147 | 0.397 | 0.674 | 0.145 | 0.383 | 0.621 | 0.163 |
| GLM-5.1 | 0.420 | 0.654 | 0.204 | 0.423 | 0.664 | 0.182 | 0.383 | 0.585 | 0.200 |
| Doubao-Seed-2.0-pro | 0.428 | 0.649 | 0.218 | 0.426 | 0.665 | 0.198 | 0.406 | 0.625 | 0.208 |
| DeepSeek-V4-Pro | 0.456 | 0.652 | 0.267 | 0.427 | 0.658 | 0.207 | 0.424 | 0.618 | 0.247 |
Thinking Models
Model |
Full Context |
Agentic Memory |
RAG Memory |
| Avg@4 | Pass@4 | Pass^4 |
Avg@4 | Pass@4 | Pass^4 |
Avg@4 | Pass@4 | Pass^4 |
| o4-mini | 0.210 | 0.433 | 0.047 | 0.270 | 0.533 | 0.073 | 0.261 | 0.452 | 0.091 |
| Gemini-2.5-Flash | 0.282 | 0.556 | 0.063 | 0.312 | 0.567 | 0.098 | 0.309 | 0.544 | 0.107 |
| Qwen3-Max | 0.284 | 0.499 | 0.105 | 0.324 | 0.599 | 0.091 | 0.315 | 0.519 | 0.134 |
| Gemini-2.5-Pro | 0.331 | 0.605 | 0.109 | 0.378 | 0.638 | 0.138 | 0.320 | 0.579 | 0.109 |
| MiniMax-M2.7 | 0.349 | 0.585 | 0.136 | 0.376 | 0.629 | 0.150 | 0.335 | 0.534 | 0.148 |
| GLM-4.6 | 0.359 | 0.612 | 0.116 | 0.351 | 0.625 | 0.107 | 0.336 | 0.574 | 0.135 |
| GLM-4.5 | 0.369 | 0.620 | 0.157 | 0.330 | 0.581 | 0.114 | 0.343 | 0.559 | 0.160 |
| Doubao-Seed-1.6 | 0.373 | 0.599 | 0.176 | 0.383 | 0.646 | 0.123 | 0.375 | 0.591 | 0.179 |
| DeepSeek-R1-0528 | 0.396 | 0.691 | 0.131 | 0.412 | 0.712 | 0.118 | 0.390 | 0.643 | 0.153 |
| o3 | 0.403 | 0.653 | 0.169 | 0.401 | 0.669 | 0.154 | 0.362 | 0.587 | 0.158 |
| Claude-4.5-Sonnet | 0.417 | 0.658 | 0.197 | 0.397 | 0.642 | 0.178 | 0.374 | 0.573 | 0.186 |
| GPT-5 | 0.441 | 0.658 | 0.226 | 0.421 | 0.647 | 0.204 | 0.410 | 0.591 | 0.236 |
| GLM-5.1 | 0.450 | 0.650 | 0.270 | 0.453 | 0.680 | 0.239 | 0.383 | 0.540 | 0.226 |
| DeepSeek-V4-Pro | 0.472 | 0.649 | 0.295 | 0.449 | 0.656 | 0.255 | 0.430 | 0.584 | 0.271 |
| Doubao-Seed-2.0-pro | 0.474 | 0.683 | 0.270 | 0.428 | 0.650 | 0.225 | 0.339 | 0.496 | 0.205 |
| Kimi-K2.6 | 0.481 | 0.685 | 0.266 | 0.450 | 0.696 | 0.223 | 0.434 | 0.611 | 0.253 |
| Claude-Opus-4.6 | 0.503 | 0.664 | 0.337 | 0.454 | 0.645 | 0.259 | 0.430 | 0.566 | 0.299 |
> **Avg@4** β mean success rate over 4 independent rollouts per task (single-attempt success).
> **Pass@4** β fraction of tasks solved in *at least one* of 4 rollouts (best-of-4).
> **Pass^4** β fraction of tasks solved in *all* 4 rollouts (consistency).
## π Citation
If you use VitaBench 2.0 in your research, please cite:
```bibtex
@article{chen2026vitabench,
title={VitaBench 2.0: Evaluating Personalized and Proactive Agents in Long-Term User Interactions},
author={Chen, Yuxin and Zhang, Yi and Cai, Zhengzhou and Shi, Yaorui and Yao, Zhiyuan and Cui, Chenhang and Zheng, Jingnan and Huo, Yaqi and Su, Xi and Gu, Qi and others},
journal={arXiv preprint arXiv:2605.27141},
year={2026}
}
```
And the original VitaBench paper this work builds on:
```bibtex
@article{he2025vitabench,
title={VitaBench: Benchmarking LLM Agents with Versatile Interactive Tasks in Real-world Applications},
author={He, Wei and Sun, Yueqing and Hao, Hongyan and Hao, Xueyuan and Xia, Zhikang and Gu, Qi and Han, Chengcheng and Zhao, Dengchang and Su, Hui and Zhang, Kefeng and Gao, Man and Su, Xi and Cai, Xiaodong and Cai, Xunliang and Yang, Yu and Zhao, Yunke},
journal={arXiv preprint arXiv:2509.26490},
year={2025}
}
```
## π€ Acknowledgement
VitaBench 2.0 is built on top of [VitaBench](https://github.com/meituan-longcat/vitabench), which itself adapted part of [tau2-bench](https://github.com/sierra-research/tau2-bench)'s codebase. We greatly appreciate their contributions to the agent community.
## π License
This project is licensed under the MIT License β see the [LICENSE](./LICENSE) file for details.
## πͺ Support
For questions and support, please open an issue on GitHub or contact the maintainers.