license: cc-by-nc-4.0
language:
- en
task_categories:
- question-answering
- audio-text-to-text
pretty_name: VoxMem
tags:
- benchmark
- memory
- long-context
- spoken-dialogue
- conversational-memory
- paralinguistics
- speaker-recognition
- environmental-sound
size_categories:
- 1K<n<10K
configs:
- config_name: 8k
data_files: data/8k/*/*.parquet
- config_name: 16k
data_files: data/16k/*/*.parquet
- config_name: 32k
data_files: data/32k/*/*.parquet
default: true
- config_name: 64k
data_files: data/64k/*/*.parquet
- config_name: 8k_speech_semantics
data_files: data/8k/speech_semantics/*.parquet
- config_name: 8k_speaker_information
data_files: data/8k/speaker_information/*.parquet
- config_name: 8k_paralinguistic_information
data_files: data/8k/paralinguistic_information/*.parquet
- config_name: 8k_environmental_sound
data_files: data/8k/environmental_sound/*.parquet
- config_name: 16k_speech_semantics
data_files: data/16k/speech_semantics/*.parquet
- config_name: 16k_speaker_information
data_files: data/16k/speaker_information/*.parquet
- config_name: 16k_paralinguistic_information
data_files: data/16k/paralinguistic_information/*.parquet
- config_name: 16k_environmental_sound
data_files: data/16k/environmental_sound/*.parquet
- config_name: 32k_speech_semantics
data_files: data/32k/speech_semantics/*.parquet
- config_name: 32k_speaker_information
data_files: data/32k/speaker_information/*.parquet
- config_name: 32k_paralinguistic_information
data_files: data/32k/paralinguistic_information/*.parquet
- config_name: 32k_environmental_sound
data_files: data/32k/environmental_sound/*.parquet
- config_name: 64k_speech_semantics
data_files: data/64k/speech_semantics/*.parquet
- config_name: 64k_speaker_information
data_files: data/64k/speaker_information/*.parquet
- config_name: 64k_paralinguistic_information
data_files: data/64k/paralinguistic_information/*.parquet
- config_name: 64k_environmental_sound
data_files: data/64k/environmental_sound/*.parquet
VoxMem: Long-Term Spoken Conversational Memory
VoxMem evaluates whether a spoken-dialogue system remembers what it heard. A model is given many time-separated sessions of a conversation — every user turn as audio, every assistant turn as text — and is then asked a spoken question whose answer is somewhere in that history.
799 questions × 4 context lengths = 3,196 items.
What separates this from a text memory benchmark is where the answer lives. Three of the four evidence types are carried by the audio signal, not by the words, so a system that transcribes first and remembers later cannot reach them.
| Evidence type | The answer depends on | Items |
|---|---|---|
speech_semantics |
what the user said | 928 |
speaker_information |
who was speaking | 588 |
paralinguistic_information |
how it was said — vocal delivery | 1,056 |
environmental_sound |
what could be heard around the user | 624 |
Task
Session timestamp: 2025-06-17 09:27
user <audio>
assistant text
...
Session timestamp: 2025-06-23 01:52
user <audio>
...
Session timestamp: 2025-09-01 07:44
user <audio> <- the question
Sessions are days or weeks apart. The model answers from the history it was given; it is never given a transcript.
Memory operations
| Operation | The item asks the model to | Items |
|---|---|---|
information_extraction |
recover one fact from one session | 920 |
multi_session_reasoning |
combine evidence across sessions | 884 |
temporal_evolution_tracking |
track how something changed over time | 872 |
answer_refusal |
recognise that the history does not contain the answer | 520 |
Evidence type × memory operation gives 15 occupied cells.
speech_semantics × information_extraction is deliberately empty: reading one
fact out of one transcript is not what this benchmark is for.
Context lengths
Every question appears at four history lengths — 8K, 16K, 32K and 64K audio
tokens — under one question_id. The question, the gold answer and the
evidence are identical across the four; only the surrounding history grows, and
it grows by nesting:
sessions(8K) ⊆ sessions(16K) ⊆ sessions(32K) ⊆ sessions(64K)
so a length comparison holds the item fixed and varies only the distraction.
Four latest_state questions do not nest strictly — q_00154, q_00158,
q_00365, q_00645 — drop them from a strict length sweep.
What you download
Every row carries its own history and every clip in it, so no config depends on any other. Sessions are shared between questions in the source data, but they are materialised into each item, which is what lets you take a slice and run it.
The files are laid out by context length and then by evidence type:
data/<context length>/<evidence type>/train-000NN-of-000NN.parquet
and there is a config for each level, so you can take a whole context length, or a single evidence type within it:
| Config | Items | 8K | 16K | 32K | 64K |
|---|---|---|---|---|---|
<length> (all evidence) |
799 | 4.03 GB | 7.72 GB | 15.38 GB | 32.83 GB |
<length>_speech_semantics |
232 | 1.19 GB | 2.26 GB | 4.50 GB | 9.18 GB |
<length>_speaker_information |
147 | 0.73 GB | 1.41 GB | 2.80 GB | 6.52 GB |
<length>_paralinguistic_information |
264 | 1.33 GB | 2.55 GB | 5.12 GB | 10.38 GB |
<length>_environmental_sound |
156 | 0.79 GB | 1.50 GB | 2.96 GB | 6.75 GB |
load_dataset("AudioMemory/voxmembench", "32k") # 799 items
load_dataset("AudioMemory/voxmembench", "32k_paralinguistic_information") # 264 items
Testing whether your system hears vocal delivery at 32K costs 5.12 GB, not the whole benchmark.
History composition
Every session in an item's history is labelled with its role:
| Role | What it is |
|---|---|
evidence |
the session the answer comes from |
samekey_haystack |
shares the question's retrieval key, and is ruled out only by the selector the question states |
topical_haystack |
shares the topic but not the queried attribute |
filler |
unrelated conversation |
samekey_haystack is what stops length from being free. Without it, retrieval
succeeds on topic words alone; with it, the model has to apply the selector the
question actually states. It scales 1 / 2 / 4 / 8 with the context length. The
16 answerable questions that carry none at any length — the question names only
the topic, so nothing can be ruled out — are usable as a control group; filter
on samekey_haystack_session_count. Refusal items carry no haystack by design.
Loading
from datasets import load_dataset
ds = load_dataset("AudioMemory/voxmembench", "32k", split="train")
item = ds[0]
print(item["question_text"], item["gold_json"])
# the spoken question
question = item["question_audio"] # {"array": ..., "sampling_rate": 24000}
# the history, in order, with every user clip already decoded
for session in item["sessions"]:
print(session["timestamp"], session["role"])
for turn in session["turns"]:
if turn["audio"]:
audio = turn["audio"]["array"]
else:
assistant_text = turn["text"]
Audio arrives decoded because the shards declare their Hugging Face feature
types; datasets needs its audio extra (pip install "datasets[audio]"). To
avoid that dependency, read the parquet directly and decode the bytes yourself:
import pyarrow.parquet as pq, soundfile as sf, io
path = "data/32k/paralinguistic_information/train-00000-of-00005.parquet"
row = pq.read_table(path).slice(0, 1).to_pylist()[0]
wav, sr = sf.read(io.BytesIO(row["question_audio"]["bytes"]))
Streaming works too (streaming=True); row groups are about 128 MB, so a
reader fetches one group rather than a whole shard to see a row.
Item schema
One row per (question_id, context_length), self-contained.
| Field | Type | Description |
|---|---|---|
item_id |
string | <question_id>_<context length>, unique in the release |
question_id |
string | stable across the four context lengths, e.g. q_00142 |
context_length |
string | 8K, 16K, 32K, 64K |
family_id |
string | question family; one family may hold both an answerable and a refusal question |
evidence_type |
string | one of the four above |
memory_operation |
string | one of the four above |
subtype |
string | finer question type, e.g. cue_to_fact, latest_state, counting |
question_text |
string | transcript of the spoken question, for reference |
question_audio |
audio | the spoken question |
query_timestamp |
string | when the question is asked |
gold_json |
string | the gold answer, JSON-encoded |
answer_type |
string | categorical, short_text, ordered_list, yes_no, number, or null for refusal items |
answer_normalization |
string | how to compare an answer to the gold |
expected_response |
string | answer, or insufficient_evidence for refusal items |
sessions |
list[session] | the history, in order |
evidence_session_ids |
list[string] | the sessions holding the evidence |
evidence_session_indices |
list[int] | their positions in sessions |
evidence_relative_positions |
list[float] | the same positions as 0.0–1.0 |
session_count, evidence_session_count, filler_session_count, samekey_haystack_session_count, topical_haystack_session_count |
int | history composition |
history_audio_tokens, history_duration_seconds |
number | size of the history |
paired_question_id |
string | the refusal counterpart of an answerable question, where one exists |
A session has session_id, timestamp, role and turns. A turn has
role (user or assistant), text and, on user turns, audio. All audio is
24 kHz mono.
A user turn carries both its audio and the transcript of it, so the benchmark can be read as well as heard — a text-only run is the ceiling the audio numbers are measured against. The transcript is the words only: the cue markers that drove the delivery are not in it, which is what keeps the paralinguistic, speaker and environmental items out of reach of a reader.
session_id is stable across the whole release, so a session reused by two
questions carries the same id in both — useful for caching an encoder's output,
and for checking what a system has already seen.
Evaluation
Give the model the system prompt, the ordered history as audio plus assistant text, and the final spoken question. Do not give it a transcript.
evaluation/candidate_system_prompt.txt permits abstention
evaluation/candidate_system_prompt.no_abstain.txt always answer
evaluation/answerable_judge_prompt.txt grades answerable items
evaluation/ar_judge_prompt.txt grades refusal items
Metric. Accuracy, reported separately for two strata:
- answerable (2,676 items) — correct when the response is semantically
equivalent to
gold_jsonunder the item'sanswer_normalization. Answers are open-ended, so equivalence is settled by an LLM judge that sees only the question, the gold and the response — never the audio or the history.evaluation/answerable_judge_prompt.txtis that contract. Abstaining is incorrect. - answer refusal (520 items) — correct when the response says the evidence is insufficient. Score this stratum only under the abstention-permitting prompt; under the always-answer prompt it reads ~0 by construction.
Report per context length, and per evidence type × memory operation when comparing systems: the aggregate hides that the audio-only cells behave nothing like the semantic ones.
How the data was made
- User speech — voice cloned from 30 reference speakers of the
CSTR VCTK Corpus 0.92. The persona profiles
in
metadata/speakers.jsonare fictional and are not recoverable from the voice. - Assistant turns — text, never spoken.
- Environmental sound — clips from ESC-50, mixed into the user speech at a target SNR rather than appended, so the sound is present while the user talks.
- Paralinguistic cues — rendered as vocal delivery in the cloned speech.
Public annotations
Gold answers, evidence-session annotations and evidence positions are all public. There is no hidden split and no submission server: the benchmark is meant to be run locally and analysed — evidence-oracle conditions, retrieval error analysis, degradation against evidence position, modality ablations — which all need those fields.
Licence
CC BY-NC 4.0. The non-commercial term follows from ESC-50, whose clips supply
the environmental sound. Attribution is required for VCTK and for ESC-50; see
LICENSE, and metadata/environmental_sources.json for the licence of every
clip used.
Citation
@misc{voxmem2026,
title = {VoxMem: Benchmarking Multimodal Memory in Large Audio Language Models},
author = {The VoxMem authors},
year = {2026},
url = {https://huggingface.co/datasets/AudioMemory/voxmembench}
}