Scenario Audio Generation

Overview

Scenario generates audio through the same loop as images. The live catalog covers three generation lanes (music, sound effects, voice/speech) plus video-to-audio soundtrack models and audio utilities. Connection and the core generation loop: see the

scenario

skill. If a sibling skill named here is missing from your available skills, ask the user to install it (

npx skills add scenario-labs/skills --skill <name>

); unattended, proceed from tool schemas and flag the gap.

Quick reference

Step	Tool	Notes
Find a model	`recommend` with the need in the user's own words; `search` only for a member known by name	`capability="txt2audio"` covers music, SFX, and TTS; optional, inferred from the prompt when omitted
Inspect inputs	`model_schema_get`	audio schemas vary widely: durations, lyrics, voices, looping
Generate	`model_run`	schema-conformant parameters; wait=false for long jobs
Wait	`jobs_wait`	blocks server-side; on timeout re-call with pending_job_ids
Listen	`asset_display`	renders an inline audio player
Save	`asset_download`	returns a download URL: `curl -L -o out.mp3 "<url>"`

Find existing audio assets with

search

target="assets", filters={kind: "audio"}. Team and project scope (

team_id

project_id

): see the

scenario

skill.

What the audio surface covers

Music: text-to-music models produce short beds or full-length songs with vocals; the song lane has its own contract, below.
Sound effects: text-to-SFX models generate short clips from a description; some support seamless looping.
Voice and speech: text-to-speech with preset voices, multilingual output, and emotion or pacing controls; some clone a voice from a short clip, and speech-to-speech re-voices a recording.
Video to audio: models that score a silent video or add synchronized effects.
Utilities:
```
model_scenario-audio-cut
```
,
```
model_scenario-audio-split
```
,
```
model_scenario-audio-extract
```
, and
```
model_scenario-compose-video
```
(fixed ids: each is Scenario's single deterministic tool for its operation, so discovery would only re-derive them); the compositor lays a finished track (score, voiceover, re-voiced take) over a clip as an audio layer, per
```
scenario-video-assembly
```
; for speech-to-text transcription,
```
recommend
```
with the need in the user's own words.
Stem separation: one named stem per run (discover with
```
recommend
```
), vocals included, with no instrumental option. Voice isolation returns the clean speech and never the removed music and effects as a second stem, so a two-stem split (voice against everything else) is a gap to report, not a member to keep hunting for.

Per-family contracts:

scenario-elevenlabs

(speech, dubbing, re-voicing, music, SFX),

scenario-ace-step

and

scenario-minimax-music

(songs),

scenario-sonilo

(SFX and video scoring).

Worked example: a game sound effect

```
recommend
```
with
```
capability="txt2audio"
```
and the user's own words as
```
prompt
```
("a game sound effect: a heavy wooden chest creaking open"). The ranking returns txt2audio models such as
```
model_elevenlabs-sound-effects-v2
```
(example only).
```
model_schema_get
```
with that
```
model_id
```
. Returns the exact fields: prompt plus controls such as duration or looping.
```
model_run
```
with the same
```
model_id
```
and parameters={"prompt": "heavy wooden treasure chest creaking open, single event, dry, no music"}.
```
jobs_wait
```
job_ids=["job_xxx"] on any
```
job_id
```
returned without assets (
```
in_progress
```
after a timed-out wait, the backend's
```
queued
```
or
```
in-progress
```
after
```
wait=false
```
), re-calling with the returned pending_job_ids on timeout.
```
asset_display
```
asset_id="asset_xxx" to play it inline.
```
asset_download
```
with no
```
format
```
, then save the returned URL with
```
curl -L
```
.

Prompting tips:

SFX: name the source, material, action, and acoustic space, and say what to exclude ("no music", "no reverb"). One event per clip; generate variations as separate runs.
Music: give genre, mood, tempo, and instrumentation. Short beds usually take a single prompt, with duration or looping in the schema.
Speech: keep the text field to the words to speak; voice, language, emotion, and pacing live in separate schema fields or inline tags.

Speech and dialogue

Discover a voice member with

recommend

(

capability="txt2audio"

, the user's words, "two-person dialogue" when it is one), then read its text field's description in

model_schema_get

: that is where a member usually states its own delivery grammar.

Tag syntax is per member, even within one family: square brackets (
```
[whispers]
```
), angle brackets (
```
<sigh>
```
,
```
<short pause>
```
), parentheses (
```
(sighs)
```
), or wrapping pairs (
```
<whisper>text</whisper>
```
), and some read none. A tag in the wrong grammar can be spoken aloud, so copy the spelling from the text field's description; where it names none, from the member's catalog description or
```
recommend
```
's notes, and with no source write no tags. A correctly spelled tag is a request, not a guarantee: two identical runs have disagreed on one, so have the user listen before a take is final and re-run a take whose tag was skipped.
Two voices, one take. A member with a multi-speaker array (up to 2 rows of a speaker label and a voice at authoring time) reads the text as turns, one
```
Name: line
```
per turn, each
```
Name
```
matching a row's label exactly; an unprefixed line continues the previous turn, and the single-voice field is ignored in that mode. Preset voice names say nothing about gender, age, or tone, so state which preset plays whom and let the user confirm before the paid run. A scene with more speakers is split into takes of at most two, delivered in order or laid over the picture per
```
scenario-video-assembly
```
.
Text is capped and priced. The text field carries a
```
max_length
```
(5000 characters on one member at authoring time), an overrun is a 400, and
```
cost_impact
```
marks it as the price driver: split a long script at turn boundaries and
```
dry_run
```
the first take.
Pin the language through the schema's language field when there is one, rather than naming it in the text.

Songs with vocals

A full-length song is not a longer music bed, and song schemas vary more than the rest of the lane, so

model_schema_get

decides the shape: a style prompt plus a separate lyric sheet, one prose prompt carrying both, or an ordered section array with per-section text and styles.

Words never go in a style field. Where the schema splits the two, the style field carries genre, mood, tempo, key, vocal style, and instrumentation; the lyric field carries the words, shaped by section tags such as
```
[Verse]
```
and
```
[Chorus]
```
.
Instrumental and auto-lyrics are flags where the schema has them; asking for either in prose is unreliable, and where no flag exists the text fields are the only lever. Flipping the instrumental flag on a rerun gives a different take, not the same song:
```
seed
```
, where a model has one, only repeats identical settings. For an instrumental of a track you already have, try an audio2audio cover model (discover with
```
recommend
```
), checking the schema since not all carry the flag.
Text fields are length-capped per model and field, and going over is a 400 rather than a truncation.

Where the schema exposes a duration field (flagged

cost_impact

), it caps both length and price; where none exists, the lyric sheet or prompt sets both. Either way, price the song with

dry_run: true

before committing, then launch with

wait: false

; both are

model_run

arguments, not

parameters

keys.

Repeatability and batching are per member, not per lane: at authoring time the repaint members took

numOutputs

(1 to 4) and no

seed

, so a repaint that must keep the same singer is run as a batch and picked from, while the section composers had

seed

and no

numOutputs

. Read both off

model_schema_get

before promising either.

Extending a song

Making an existing track longer is its own

audio2audio

lane, not a longer text-to-music run:

recommend

with

capability="audio2audio"

and the extension need in the user's words; use

search

only when the member is already known by name. The member that does it takes the song as

audio

and an ordered

sections

array (up to 30 at authoring time) where each entry either keeps a slice of the original (

sourceStartSeconds

and

sourceEndSeconds

) or generates a new one (

text

with

[Verse]

-style tags,

durationSeconds

positiveStyles

as an array), with

contextAdherence

deciding how closely new sections follow their neighbors. Kept slices bill like generated audio of the same length, so

dry_run

the whole plan first. The repaint, edit and add-layer members regenerate inside the original's duration and never lengthen it, and

recommend

ranked an older text-to-music member for "extend a song" at authoring time: an extension is not a

txt2audio

need, so do not take that pick.

Common mistakes

Hardcoding generative model IDs: availability differs per team and evolves. Re-discover each session,
```
recommend
```
for the need or
```
search
```
for a name; only the fixed first-party tool ids above stay constant.
Skipping
```
model_schema_get
```
: one audio model's parameters will not fit another (voices, durations, and lyric fields all differ).
Polling
```
job_get
```
in a loop: music jobs can run minutes. Use
```
jobs_wait
```
; on timeout re-call with pending_job_ids.
Pasting raw asset URLs into chat: use
```
asset_display
```
to play audio.
Passing
```
format
```
to
```
asset_download
```
for audio: it converts image formats only, so omit it.
Putting voice direction inside TTS text ("say this angrily"): direction can end up spoken. Use the schema's emotion or voice fields.
Writing a dialogue as one voice reading both parts: on a multi-speaker member, fill the speaker rows and prefix every turn with its label, since with the rows empty the member reads everything in its single voice.
Pasting lyrics into the style field: the model then describes a song instead of singing one.
Answering "make it longer" with a repaint or a new text-to-music run: the first keeps the duration, the second loses the song; the extend lane above keeps the slices the user chose.
Putting
```
dry_run
```
or
```
wait
```
inside
```
parameters
```
: they are
```
model_run
```
's own arguments, so a stray
```
dry_run
```
still charges and a stray
```
wait
```
blocks up to 180s.

scenario-audio

NPX Install

Tags

SKILL.md Content