AudioMemory/voxmembench

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_json under the item's answer_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.txt is 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.json are 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}
}