# ToolTalk Samples: Technical Reference The reference behind the [data page](https://huggingface.co/datasets/fluid-concepts/tooltalk-samples): what ships in each set, how it was recorded and processed, the schema, and how to load it. Use is governed by the Terms on the data page ([TERMS.md](https://huggingface.co/datasets/fluid-concepts/sample-page-assets/blob/main/tooltalk-samples/TERMS.md)). ## Deliverables and file naming Every call ships as separate files on one time axis: the studio tracks (forms 1 to 3) and a combined stereo file (form 4). All files of a take have the same length and start on the same instant as the tool-call clock. The **Noisy** set has all four forms. The **Clean** set has no noise bed, so it has forms 1, 2 and 4, and its combined file is the two clean tracks side by side. | Form | File | What it is | In | Processing | Format | |---|---|---|---|---|---| | **1. Clean agent** | `_agent.wav` (`agent_file`) | The agent's microphone | All sets | None | 48 kHz / 32-bit mono WAV | | **2. Clean customer** | `_customer.wav` (`customer_file`) | The customer's microphone | All sets | None | 48 kHz / 32-bit mono WAV | | **3. Ambient noise** | `_noise.wav` (`noise_file`) | The car-interior bed played into headphones | **Noisy** only | None. In 4 of 12 takes the bed touches full scale at its loudest moments (passing vehicles), in runs of at most 1.6 ms and for at most 0.13 s per take | 48 kHz / 32-bit mono WAV | | **4. Combined call** | `_stereo.wav` (`file_name`, the `audio` column) | The whole call in one stereo file: customer LEFT, agent RIGHT | All sets | **Noisy** only: customer channel through a simulated car cabin, mixed with the ambient bed at a signal-to-noise ratio of +5 dB(A), the customer's speech 5 dB louder than the bed, measured while the customer is talking; agent channel clean; both channels normalized to -27 LUFS under a -1 dBTP ceiling (`stereo_content: renoised`). **Clean** only: the two clean tracks side by side, unprocessed (`stereo_content: clean`) | 48 kHz / 32-bit stereo WAV (Clean); 48 kHz / 24-bit stereo WAV (Noisy) | | **5. Transcripts** | `transcripts/_{agent,customer}.json` (`agent_transcript_file`, `customer_transcript_file`) and `_transcript.txt` | Each speaker's track transcribed on its own, plus both merged in time order | All sets | Machine speech recognition (nvidia/parakeet-tdt-0.6b-v3); not human-reviewed | JSON (segments with start/end and word timings) and plain text | ## Recording specifications All recordings are in-person in-studio. Mono files are 48 kHz, 32-bit PCM WAV, speaker-separated, recorded on 20 Hz–20 kHz flat-response large-diaphragm condenser microphones into high-quality preamps and converters. The recording environment and signal chain have a sub -60 dB noise floor and RT60 < 90 ms. The 48 kHz / 32-bit recordings are produced without any compression or EQ. This is fully raw audio, which gives you the most flexibility to preprocess for your own pipeline. We can also provide training-ready audio: normalized, equalized and denoised for high-fidelity speech generation. ## Noise collection and post-processing During the calls in the **Noisy** set a recorded car-interior noise bed (city street or freeway) was played into both talents' headphones, so they spoke, listened and worked the tools against that noise. The microphones stayed clean: the speech files carry no noise. `_noise.wav` is the bed itself, cut to the exact window of the call and sample-aligned with the speech files, so mixing it under either speaker reproduces what that person heard. Its level is the studio playback file's level. The combined stereo's customer channel was mixed with this same bed span, at its own gain. The **Clean** set was recorded with no bed playing. ### The combined stereo file In the **Noisy** set, every take's combined file is a simulation of the call as the agent's side would have received it with the customer calling from a car: the customer channel (LEFT) is the customer's clean recording passed through a simulated car-cabin room and mixed with the very noise bed that was playing in the studio at that moment, with the bed's gain set for a signal-to-noise ratio of +5 dB (A-weighted, measured while the customer is talking), so the customer's speech is 5 dB louder than the bed; the agent channel (RIGHT) is the agent's clean recording. Both channels are loudness-normalized independently to -27 LUFS (ITU-R BS.1770-4) under a -1 dBTP true-peak ceiling, and the file is 24-bit. Speech is high-passed at 20 Hz and the bed at 80 Hz before mixing; there is no compression or limiting. The per-take numbers (target and measured SNR, room RT60, gains) are in the `renoised` column and in `stereo.renoised` of the manifest. The mono files are untouched. In the **Clean** set the combined file is the two clean tracks side by side, customer LEFT, agent RIGHT, unprocessed (`stereo_content: clean`). ## Transcripts Each speaker's microphone track was transcribed on its own with nvidia/parakeet-tdt-0.6b-v3. Tracks were transcribed in voice-activity chunks of up to 20 seconds, which recovers speech that a single pass over a whole track drops. **These are model-generated transcripts, not human-reviewed**: expect recognition errors on names, numbers, spellings and overlapping speech, and no punctuation or casing guarantees. Per take: `transcripts/_agent.json` and `_customer.json` (segments with `start`/`end` in seconds from the start of every wav, word timings, the model and run time) and `_transcript.txt`, both speakers merged in time order (one header line naming the model and the time format, a blank line, then one line per segment); the `transcript` column carries the merged lines without the header. ## Episode design and outcomes Two humans improvise a customer-service call. The caller is given a persona and an objective; the agent talks with the caller while operating the environment's tools. Nothing is scripted line by line. Each domain has a live database, functions that read and write it, and a written domain policy. State is dynamic (a booking made mid-call changes later searches), and the final database state is a checkable outcome. Every call is captured as three synchronized tracks: speaker-separated audio (caller and agent on their own channels, overlaps preserved); the function-call log (tool, arguments, result, timing against the audio); and the agent's digital behavior (clicks, typing, record selections, on the same clock). The collection spans eight domains: ✈️ airline reservations, ❤️‍🩹 healthcare appointment booking, 🏨 hotel booking, 🪑 restaurant reservations, 🍝 restaurant take-out and pick-up, 🚗 roadside assistance, 🛵 food delivery and 🏦 banking. These samples cover seven of them; there is no banking call in this release yet. Domains in this sample release: | Domain | `domain` | Clean | Noisy | |---|---|---|---| | ✈️ Airline reservations | `airline` | 2 | 2 | | 🛵 Food delivery | `food_delivery` | 2 | 0 | | ❤️‍🩹 Healthcare appointment booking | `healthcare_appts` | 2 | 2 | | 🏨 Hotel booking | `hotel` | 2 | 2 | | 🪑 Restaurant reservations | `restaurant` | 2 | 2 | | 🚗 Roadside assistance | `roadside_assistance` | 2 | 2 | | 🍝 Restaurant take-out and pick-up | `takeout` | 2 | 2 | Episodes are written in three validity classes against the domain policy: **valid** (the caller's objective is consistent with policy and the agent fulfills it), **partially valid** (part is allowed, part is not; the agent fulfills some and holds the line on the rest) and **invalid** (the objective is at odds with policy; the correct outcome is a refusal or an alternative while the caller pushes back). Every episode has a reference solution and ideal tool-call sequence (although successful calls may deviate from the ideal sequence). ## Dataset schema and organization Each set is one config: `load_dataset("fluid-concepts/tooltalk-samples", "")` (sets: `clean`, `noisy`) returns one row per call with the columns below; the wav files and transcripts named in the path columns sit beside the metadata under `sets//data/`. All wavs of a take are the same length and start at the same instant as the tool-call clock. | Column | Type | What it is | |---|---|---| | `file_name` | audio | The combined stereo wav of the call (customer LEFT, agent RIGHT). The viewers play the separate tracks (forms 1 to 3); where this file is renoised, the set's viewer also offers it as the example combined output | | `take_id` | string | Unique id of the take: `TLT_______ep__`; the prefix of every file of the take | | `short_id` | string | Short form of the take id: studio session code and take token (`SC023-6xe1a6`) | | `sample_set` | string | The set this call belongs to (one card config per set) | | `domain` | string | Customer-service domain key (`airline`, `hotel`, `restaurant`, `takeout`, `healthcare_appts`, `roadside_assistance`, `food_delivery`); the Domains table above gives the names | | `episode_number` | string | Three-digit episode index within the domain | | `scenario` | string | Short name of the episode's situation | | `description` | string | Hand-written one-paragraph summary of what happens in the call | | `duration_s` | float | Length of the call in seconds; every wav of the take has exactly this length | | `n_tool_calls` | int | Number of tool calls the agent made | | `session` | string | Studio session the take was recorded in | | `agent_id, customer_id` | string | Anonymous studio codes of the two people, `-` (`FC-012`, `FR-033`, ...) | | `stereo_content` | string | `renoised` (customer channel through the car-cabin simulation with the noise bed, agent clean) or `clean` (the two mono tracks side by side) | | `agent_file, customer_file` | string | Paths of the two raw mono wavs, relative to `sets//data/` | | `noise_file` | string | Path of the noise-bed wav the talents heard, relative to `sets//data/`; null if no bed was playing | | `agent_transcript_file, customer_transcript_file` | string | Paths of the per-speaker machine transcripts (JSON: segments with `start`/`end` in seconds and word timings), relative to `sets//data/` | | `transcript_file` | string | Path of the merged, time-ordered, speaker-labeled transcript (plain text: one header line naming the model and the time format, a blank line, then one line per segment), relative to `sets//data/` | | `transcript_model` | string | The speech-recognition model that produced the transcripts; they are machine-generated and not human-reviewed | | `noise_bed` | string | Which bed was playing (`STREET`, `FREEWAY`); null in sets without a bed | | `noise_dbfs, noise_dbfs_a` | float | Level of the Ambient file over the whole call: broadband RMS in dBFS, and the same after IEC 61672 A-weighting (what a sound-level meter reads; it discounts the low-frequency rumble these beds are mostly made of); null in sets without a bed | | `noise_lufs` | float | Integrated loudness of the Ambient file (ITU-R BS.1770-4, gated), the scale the combined file is normalized on; null in sets without a bed | | `noise_peak_dbfs` | float | Loudest sample of the Ambient file in dBFS; 0.0 means the bed touches full scale at some point; null in sets without a bed | | `noise_active_fraction` | float | Share of the call during which the bed was playing: the fraction of 20 ms frames of the Ambient file above -60 dBFS; null in sets without a bed | | `agent_prompt, customer_prompt` | string | The full text each side was given before the call | | `transcript` | string | The merged machine transcript as text: one line per segment, `m:ss.mmm Speaker: words`; the lines of the text file without its header | | `tool_events` | string (JSON) | List of `{call_seq, tool_name, tool_input, tool_result, onset_time, land_time, is_error}`; times are seconds from the start of every wav | | `renoised` | string (JSON) | The render record of a renoised combined file: room simulation, high-pass filters, noise mix with the SNR target and measurement, per-channel loudness before and after normalization, output format; null for clean stereo | `sets//manifest.json` holds the same information in nested form, keyed by take id: the two participants, one block per audio stream with its format, the noise-bed details, and the tool events. `sets//descriptions.csv` is the hand-written `description` column (`take_id,description`), and `sets.json` at the root indexes the sets for the viewer. `sets//derived/` (waveform peaks and MP3 proxies) serves the viewer and is not part of the dataset config. ## Synchronizing tool calls with audio All wavs of a take start at the same instant as the tool-call clock, so a tool call's position in the audio is its `onset_time` in seconds from the beginning of any of the take's files: seek to `onset_time` to hear what was being said as the agent submitted the call, and to `land_time` to hear the moment the result came back. For example, to cut the ten seconds around the first tool call of a take: `ffmpeg -ss -t 10 -i _stereo.wav clip.wav`. Participant ids (`FC-012`, `FR-033`, ...) are anonymous studio codes, written `-`. ## Loading and downloading Access is per Hugging Face user and covers every set: request it with the form at the top of the data page and we will approve it. Once granted you can play and download every file from the **Files** tab, and from Python (sign in first with `hf auth login`, or set `HF_TOKEN`): ```python import json from datasets import Audio, load_dataset REPO = "fluid-concepts/tooltalk-samples" ds = load_dataset(REPO, "clean") # one config per set: "clean", "noisy"; `audio` is the combined stereo row = ds["train"][0] samples = row["audio"].get_all_samples() # torchcodec AudioDecoder: .data is a (channels, samples) tensor, .sample_rate its rate row["short_id"], row["description"], tuple(samples.data.shape), json.loads(row["tool_events"])[:2] # The file paths instead of decoded audio files = ds["train"].cast_column("audio", Audio(decode=False)) files[0]["audio"]["path"] ``` The plain `load_dataset` call downloads every wav and transcript of the set before it returns (Clean 2.0 GB, Noisy 1.8 GB); casting `Audio(decode=False)` afterwards does not avoid that. To look around without the download, read the metadata with the second snippet and fetch single files with `hf_hub_download`. Decoding needs `pip install "datasets[audio]"` (torch and torchcodec; the same packages decode video) and FFmpeg 4 to 7 installed on the system. Without FFmpeg the first decode fails with a torchcodec loader error. Reading the paths needs neither. `row["audio"]["array"]`, the older dict form, still works but averages the two channels into one mono signal, which throws away the customer/agent separation these files exist for; keep the channels with `get_all_samples().data` (row 0 the customer, row 1 the agent). ```python import pandas as pd from huggingface_hub import hf_hub_download, snapshot_download # The manifest of one set, without the audio; dtype=False keeps ids such as "031" as strings meta = pd.read_json(hf_hub_download(REPO, "sets/noisy/data/metadata.jsonl", repo_type="dataset"), lines=True, dtype=False) meta[["short_id", "domain", "scenario", "duration_s", "n_tool_calls", "noise_bed"]] # One whole set ... snapshot_download(REPO, repo_type="dataset", allow_patterns=["sets/noisy/**"]) # ... one stream across every set ... snapshot_download(REPO, repo_type="dataset", allow_patterns=["sets/*/data/audio/*_agent.wav"]) # ... or everything snapshot_download(REPO, repo_type="dataset") ``` From the command line: `hf auth login`, then `hf download fluid-concepts/tooltalk-samples --repo-type dataset --include "sets/noisy/**" --local-dir tooltalk-samples`. The raw mono and noise wavs are the `agent_file`, `customer_file` and `noise_file` columns, relative to the set's `data/` folder. Questions: hello@fluidconcepts.ai.