Skip to main content
Glama

Doseedo Film Score: spot a video, play your score on AI instruments, mix it to picture

Server Details

Score video as an agent: cue sheet from the cut, 100+ AI instruments play your MIDI, mix to picture

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-06-18
URL
ChatGPT
–
Claude
–

TDQS

A3.9/5.0

Scored across 27 tools

Disambiguation4/5

Each tool maps to a distinct stage or artifact of the film-scoring pipeline (spot, tempo map, render_midi vs render_score, mix vs mix_preset, deliver), and the long descriptions actively disambiguate neighbours. The only real overlap is the trio doseedo_check_task / doseedo_wait_task / doseedo_list_jobs, all of which inspect job state, plus analyze_midi vs check_take which both validate notes, so an agent may occasionally pick the wrong one of those.

Naming Consistency4/5

All tools carry the doseedo_ prefix and use snake_case, with the dominant pattern being verb_noun (spot_video, render_midi, separate_stems, train_instrument, score_to_picture). A handful of exceptions are noun/lookup-style names (doseedo_account, doseedo_instruments, doseedo_recipes, doseedo_quote, doseedo_tempo_map), but they remain readable and predictable within the convention.

Tool Count3/5

27 tools is heavy and beyond the comfortable 3-15 band, though the domain is genuinely sprawling (spotting, analysis, rendering, mixing, mastering, delivery, DAW export, instrument training, SFX, costing). Each tool does earn a distinct role, but the surface is large enough that an agent must navigate a lot of near-neighbours to complete one job.

Completeness3/5

The core scoring-to-picture chain is well covered end to end (upload → spot → tempo map → render → mix → score_to_picture, plus session_from_stems), and analysis/diagnostics are thorough. However several jobs referenced by doseedo_quote, doseedo_cancel_job and other descriptions have no exposed tool here (generate_music, generate_loop, cover_song, edit_lyrics, audio_to_session, convert_project, bounce_session, detect_chords, beat_grid), and the session-editing calls named in descriptions (set_midi_notes, attach_audio, place_local_files) are similarly absent, leaving dangling references an agent cannot act on.

Available Tools

27 tools
doseedo_accountAccount and creditsA
Read-onlyIdempotent
Inspect

Check the connected doseedo account: plan tier, the monthly credit pool (generation AND DAW conversions draw it), purchased extra-usage credits, and storage. Read-only — consumes nothing. Use it before starting expensive work to confirm there is budget.

Inputs: no named parameters.

doseedo_analyze_midiAnalyze MIDI harmonyAInspect

Check the HARMONY of notes before rendering or placing them: factor a MIDI progression into its sonorities (mode "midi", default — chord-detection-free: each segment of simultaneously sounding pitches reduced to an anchor pitch class + register-exact shape, covered with recurring shape cells) or into chord symbols (mode "chord": one estimated chord per ~2 beats + a corpus-grammar cell cover with a schedule). Input: notes[] (the rows you would give doseedo_render_midi / set_midi_notes) with bpm, or midi_url (a .mid ≤2 MiB: a doseedo result link such as a stem's MIDI, or a public URL). Synchronous (~2–10 s), CPU, no credits. Returns sonorities[] or chords[], cover, cells, compression — read chords[].chord / sonorities[].anchor to confirm the key and progression you intended. Cancel: not applicable — the result is returned in the submit response; the job is already finished.

Inputs: bpm, mode, notes, midi_url, +4 more.

doseedo_analyze_songAnalyze a songAInspect

Key detection, BPM/tempo detection, song structure and chords — musical analysis of a recording in one call: key (e.g. "D minor"), bpm + per-beat tempo_map, meter / beats_per_bar, downbeats (seconds), sections (intro/verse/chorus… with times), chords (a progression on the beat grid), dynamics, and cues: the pieces a recording holds (a film's temp: each piece's start, end, tempo, key and level). USE THIS to learn the key and tempo of a reference before writing a part — never guess or ask the user for what the audio already says. Pass audio_key (an upload) or audio_url (a result URL from another job as returned, or any public https URL). Up to 10 minutes of audio is analyzed. Synchronous (~5–20 s for a song, up to ~1–2 min for 10 minutes of audio): the result is in this response. No separation, so a dense mix's chords are a draft — for a chord chart from stems use doseedo_detect_chords on the separated stems. Cancel: not applicable — the result is returned in the submit response; the job is already finished.

Inputs: audio_key, audio_url, idempotency_key.

doseedo_cancel_jobCancel a jobA
DestructiveIdempotent
Inspect

Cancel a queued or running job. What that stops and refunds depends on the kind — generate_music / render_midi / cover_song: a render not yet on the GPU is stopped and its credits refunded; one already rendering finishes (credits spent), the job ends as canceled, output discarded. audio_to_session: cooperative — stops at the next stage boundary and refunds the build's sound-tool unit (a separation already run stays charged). bounce_session: a bounce still queued never renders (budget refunded); one mid-render has its result dropped. spot_video / score_to_picture / reframe_video: one still queued never starts and one running stops within seconds, refunded either way. separate_stems / transcribe / convert_project: no plane-side stop — the work completes (credits spent), the job ends as canceled and its output is discarded. The synchronous analyses are already finished (409 already_terminal).

Inputs: job_id (required).

doseedo_check_takeCheck a take against its notesAInspect

MEASURE a take instead of guessing: give the audio (a render_midi take URL, any recording) and the notes it should play — notes[] + bpm (and tempo_map) or a midi_url — and get back how many written notes were heard at the right pitch and time (recall / precision / f1, octave errors, the first missed notes with their beats), the timing error in ms, loudness (integrated LUFS, peak dBFS, clipped share), any stretch where a note was written but nothing sounds, and a verdict (good / check / bad) with reasons in plain words. doseedo_render_midi results already carry this per take (takes[].check) when the part was given as notes. Method: an independent note transcriber (basic-pitch) — dense chords and very fast runs read less reliably; use it as a screen, and listen to anything marked check. Synchronous (~3–15 s), CPU, no credits. Cancel: not applicable — the result is returned in the submit response; the job is already finished.

Inputs: bpm, notes, midi_url, audio_key, +6 more.

doseedo_check_taskCheck a jobA
Read-onlyIdempotent
Inspect

Check an async doseedo task once. Returns current status, and the result (file URLs / notes) when finished. A big result comes back as a brief (each row cut to its deciding fields): parts: ["" or index, …] returns those rows of the job record IN FULL — a render_score part's every receipt, a mix part's strip, rides (every point) and loudness, a supervised cue's full card (parts: ["1M7"]).

Inputs: from, kind, parts, job_id, +1 more.

doseedo_generate_soundGenerate sound effects (SFX & foley)AInspect

SOUND EFFECTS (SFX) from words with Stable Audio Open — SOUND DESIGN and FOLEY for game audio, apps and video: impacts, whooshes, door slams, footsteps, UI blips, creature and sci-fi sounds, ambiences ("rain on a tin roof", "busy café"), risers, drum one-shots. A one-shot hit ("punchy house kick", "snare with a short room", "a riser into the drop"), a loop on the tempo grid ("glitchy percussion"), or a texture ("vinyl crackle", "rain"). kind picks which (hit | loop | texture); omitted, the server reads it off the words. Don't put a tempo in a hit's prompt — tempo words make it write a loop. Wrong tool for a part with notes (doseedo_render_midi) or a piece of music (you write it; doseedo_render_score plays it). Async: job_id → doseedo_wait_task (typically 15–40 s) → audio URLs (pre-signed: curl -OJ , no auth header, valid 24 h). Each sound is one 30 s window = 10 credits: before sending a batch, doseedo_quote {job: "generate_sound"} or doseedo_account says how many the account has room for now. Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.

Inputs: prompt (required), bpm, kind, name, +4 more.

doseedo_get_upload_urlGet an audio upload URLA
Idempotent
Inspect

Get a presigned upload for your own audio file — or a SCORE (.mid / .midi / .musicxml / .xml / .mxl / .mscz / .mscx → a score_key for doseedo_render_score: send a big score as a file, not as notes in the call). Returns an upload_url (PUT the raw file bytes there, e.g. curl -X PUT -H "Content-Type: <content_type>" --data-binary @song.wav "<upload_url>") and an audio_key to pass to doseedo_separate_stems / doseedo_transcribe / doseedo_cover_song / doseedo_audio_to_session, or to doseedo_add_audio_to_session. A FILM (mp4, mov, m4v, webm, mkv; ≤ 2 GB) uploads the same way: pass the key as video_key to doseedo_spot_video / doseedo_score_to_picture. Formats: WAV, AIFF, FLAC, MP3, M4A/AAC, Ogg/Opus, WebM — all accepted for processing on every plan. Storing audio IN A SESSION (doseedo_add_audio_to_session) keeps WAV/AIFF/FLAC lossless only on Pro+; below Pro+ lossless is not kept there, so send Opus (audio/ogg). Samples/regions for a session that are on this machine need NO upload: use load_quick_sampler_sample sample_path / attach_audio local_path / set_track_clips audio_ref.local_path and run place_local_files after the download. A FILE ALREADY ONLINE (a film an editor exported — Canva, Adobe Express — or any public https URL): pass source_url and doseedo copies it in itself — nothing to PUT; the key comes back ready (≤ 256 MB).

Inputs: filename (required), source_url, content_type.

doseedo_identify_soundIdentify a soundAInspect

Instrument recognition + genre classification of audio (a stem, a loop, a whole mix): instrument (e.g. "sub_bass", "drum_machine", "synth_lead", "string_section"), family, render (the doseedo_render_midi fields that play it), write (how its part is written), candidates[], resembles[] (what it sounds like without being it: a synth lead that resembles a brass section), confidence, notes {low, high, most} (its register), genre[] (top 3), character {tone bright|dark, drive clean|driven, length short|sustained, weight}, reads (playful | neutral | sleek: does it sound like a toy advert or a cartoon?) + playful 0–1, tags[] (AudioSet) and measured {rms_dbfs, centroid_hz, low_share, onsets_per_s}. USE THIS on a reference track and on each of its stems (doseedo_separate_stems returns stem_identity already) before writing: you cannot hear, and tempo and key say nothing about the SOUND. Run it on your own mix too and compare genre and character with the reference. A whole mix: read genre and character (instrument names only its loudest element). A silent stem answers silent:true — nothing to copy there. Pass audio_key (an upload) or audio_url (a result URL from another job as returned, or any public https URL). Up to 10 minutes of audio is analyzed. Synchronous (~1–5 s), no credits. Cancel: not applicable — the result is returned in the submit response; the job is already finished.

Inputs: want, audio_key, audio_url, idempotency_key.

doseedo_instrumentsInstrument catalog (the sound palette)A
Read-onlyIdempotent
Inspect

The instrument list — the sound palette: every instrument doseedo can PLAY YOUR NOTES on (doseedo_render_midi) — orchestral strings, brass and winds, guitars, basses, keys, drums and percussion, and World instruments (koto, sitar, banjo, pedal steel, tabla, congas…). Each entry gives the EXACT render call (call: instrument, plus timbre_preset where one is needed — a koto is the acoustic_guitar model with the koto timbre), its playable range in concert MIDI pitch, whether it plays chords, its presets (pizz, muted, sax registers…) and a demo render. No args → the whole catalog; query:"warm low brass" / family / culture:"India" (a culture's own instruments: "Indian", "Japanese", "Celtic", "Latin America"…) / pitches:[…] (instruments whose range holds them) / chords:true narrow it; id:"cello" → one instrument in full. Read-only, free, no key needed — read it before writing a part.

Inputs: id, query, chords, family, +2 more.

doseedo_list_jobsList jobsA
Read-onlyIdempotent
Inspect

List the jobs this account submitted (generate / render_midi / cover / stems / transcribe / session / convert / bounce / the analyses), newest first — to find an earlier result, check what is still running, or resume after a lost connection. Each row names its artifacts (e.g. ["vocals", "drums", "midi_piano"]); doseedo_check_task {job_id} returns the full result with fresh links. Read-only.

Inputs: kind, limit, before, status, +1 more.

doseedo_mixMix and master stemsAInspect

MIXING and MASTERING: each part levelled, panned, high-passed, given its depth on a shared reverb, mastered to a loudness target — a WAV AND mixgraph, the mix as a document. After doseedo_render_score pass from_job (its parts and the instruments they play are the stems); or stems: [{name, audio_url, instrument?}]. An orchestra (strings / winds / brass / timpani / harp…) is SEATED by default (film-orchestral: violins left, low strings right, brass behind, each seat at its depth in a 2.3 s hall, written dynamics riding the faders); others mixed blind. style: an id or words — the style parameter lists every id (scoring halls, jazz-combo, big-band, brass and marching bands, soul, rock-band and the other guitar bands, blues, country, reggae, disco, the decades). guitar_tone = guitar sound. balance {part: dB} moves parts on top of the levelling (+3 = a melody forward). Change the mix: edit the returned mixgraph — strips[] {stem, gain_db, pan, seat, chain, sends}, buses[] (verb = the hall; a section's fader_db = its level), master.chain, automation [{target: "strips..gain_db", points: [[seconds, dB]…]}] for rides (dB off the strip's gain_db: 0 = as set, -60 mutes) — and call again with mix_job (this job_id) + only your edits (or the whole mixgraph + the same stems): rendered as written, rails reported, no credits. Then doseedo_session_from_stems {from_job, mix_job: } → the DAW project at this mix's levels and pans. TO PICTURE: dialogue (the VO; the music ducks under it), music_offset_s (bar 1 on the picture), length_s (cut + end fade). Async: job_id → doseedo_wait_task (~15–90 s). Cancel: the plane has no stop for a running mix — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: bpm, duck, loop, name, +28 more.

doseedo_mix_presetPolish a mix with a mix presetAInspect

POLISH A MIX: a mix preset is a model trained on finished, professionally mixed recordings. It covers YOUR mix and folds what it hears back in by frequency range. preset: "cinematic_score" (the default) = a whole orchestral / film-score mix, the tone and width of a finished score moved onto yours, below 8 kHz, with none of the model's own audio heard. "jazz_mix" = the same for a JAZZ mix (a combo, bossa / latin jazz — what the jazz band generators play), trained on finished jazz records: use it for those in place of cinematic_score. "big_band_mix" = the same for a BIG BAND (saxes, trumpets, trombones and a rhythm section — what the big_band_* generators play), trained on big-band records alone: use it for a big band in place of jazz_mix. Input: audio_url (a doseedo_mix mix_url as returned) or audio_key, a stereo mix of up to 10 minutes. The preset brings its own strength; cns (0.1–0.5) overrides it: how much of your mix's own sound the model's take keeps (higher = closer to the input). Async: job_id → doseedo_wait_task (~15–90 s) → mix_url (the polished mix, WAV), take_url (the model's raw take) and report: balance_vs_input_db per band and side_vs_input_db (the width change). Cancel: the plane has no stop for a running mix preset — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: cns, name, seed, preset, +3 more.

doseedo_quotePrice a jobA
Read-onlyIdempotent
Inspect

Estimate what a job will cost in credits BEFORE submitting it, and whether the connected account can afford it right now. Spends nothing. Pass the job (generate_music, generate_sound, generate_loop, cover_stem, edit_lyrics, fill_gap, render_midi, train_instrument, cover_song, separate_stems, split_soundtrack, transcribe, audio_to_session, convert_project, bounce_session, spot_video, score_to_picture, reframe_video, analyze_song, detect_chords, beat_grid, identify_sound, supervise_cues, analyze_midi, render_score, mix, mix_preset, session_from_stems, check_take) and the same args you would give the job tool (duration_seconds, models, instruments; for render_midi: notes + bpm / tempo_map or duration_seconds, voice_split / voices, takes — takes are free, voices cost one batch per ~6; for render_score: parts + bpm / tempo_map — planned exactly as the job plans it (lines, player rows, length), and refused says when the job would refuse it). The estimate follows the planes' own price table; the gate is authoritative and a refusal names the exact price.

Inputs: job (required), args.

doseedo_recipesRecipes (named pipelines)A
Read-onlyIdempotent
Inspect

The named pipelines people actually ask for — stems, session (mix → DAW project), cover, transcribe, generate, render-midi (your notes played by an instrument model), custom-instrument (train your own from a recording), timbre-transfer (your notes, a recording's tone), sound-design (SFX / foley / one-shots), analyze-song (key/tempo/sections/chords), convert, bounce, and the compose-part guide (a part in the session's key at its tempo: analyze → you write the MIDI → place or render it) — each with its inputs, the tool calls in order, outputs, a credit/time estimate and how to VERIFY success from the response. Call with no name for the index (pick by use_when), or with a name for the full recipe. Read-only.

Inputs: name.

doseedo_render_midiRender MIDI on AI instruments (MIDI to audio)AInspect

MIDI to audio, a virtual instrument: plays a part you wrote. An AI instrument model (orchestral strings, brass, woodwinds, piano, guitar, bass, drums, World) performs your exact notes, in your key, at your bpm, and returns audio takes. Input ONE of: notes[] ({pitch, start_beats, duration_beats, velocity} — beats from bar 1), midi_url (a .mid ≤2 MiB: a doseedo result link or a public https URL), or session_id + track_id (that track's notes, read from the session). Required: instrument (an entry's call from doseedo_instruments, no key — stay inside its range) and bpm. The notes are sent AS GIVEN — no pitch snapping, no quantizing. One voice per part: a chord part is rendered one voice per output with voice_split:true (result.voices maps each voice to its files and notes). Takes come back best-first (takes[0] = the scorer's winner). Async: job_id → doseedo_wait_task (~1–3 min). Result: takes[{url, rank, score}] (pre-signed: curl -OJ, no auth header, 24 h), seed, duration, voices?, refine?, chain. A take may miss or change a note — read takes[].check (measured against your notes) or listen; offer the takes, never promise note-perfection. Free harmony check first: doseedo_analyze_midi. DRUMS (GM notes): the drum model (default) PLAYS a kit — the sound of acoustic drums; it can drop a hit (takes[].fit.missing). drum_engine:"oneshot" = a programmed sampler kit for drum_genre (default for "electronic"/"808"), every hit as written — drum machines only; real drums (a kit, boom bap) stay on the model (drop a hit: take again). "synth" = a one-shot patch (synth_role, synth_genre; "performed" = played, less 1-shot); result.oneshots = the samples. SOUND: a preset (timbre_preset), a recording's tone (timbre_audio_url = timbre transfer; a drum kit too: a ride / snare recording), or YOUR OWN instrument (lora_id from doseedo_train_instrument; result.lora.applied). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.

Inputs: instrument (required), bpm, key, name, +35 more.

doseedo_render_scoreRender a whole scoreAInspect

Plays a whole arrangement you wrote in one call — film scoring, orchestral arrangement, background music, a song or instrumental (a film cue, a string quartet, a big-band chart): each part played by its doseedo instrument, one stem per part from bar 1 at your tempo, plus a summed mix. Input ONE of: parts[] ({name, instrument, timbre_preset?, lora_id?, players?, notes[]} — doseedo_instruments calls), midi_url (multi-track SMF), or musicxml_url (notation played as marked, at concert pitch). A file's parts are matched by name, then GM program; name any part with instruments {"": {instrument, timbre_preset?, players?}}. A chord on a one-line instrument is split into voices (one stem each). ★ SECTIONS: an instrument is ONE player; give a part players: N (2–8) and its line is played by N different players, summed into ONE section stem — an orchestra = violins I / II, violas, cellos, basses as five parts with players 6 / 6 / 4 / 4 / 3, horns 2–4 in unison; a choir = S/A/T/B parts on "choir" (an opera SATB chorus by default, or YOUR singer: parts[].timbre_audio_url), which SINGS parts[].lyrics ("Ooh" without), players 4–8 (recipe "choir"); a solo: no players. The WHOLE orchestra in one call: ≤ 32 lines and ≤ 96 player rows (players: N = N rows), any instruments together, ≤ 600 s. Drums: the drum model is a real kit, drum_engine "oneshot" a drum machine. Synths: synth_role + synth_genre. Timing: bpm and/or tempo_map ([{beat, bpm}]; doseedo_tempo_map lands film hits on downbeats). Result: parts[{name, instrument, url, fit, timbre, lora, players}] — fit.verdict / coverage = did it PLAY its notes (a failed part is re-rolled once; fit.rolls.missed = a roll not played as one), lora.applied = its adapter played — plus mix_url. Next: doseedo_mix {from_job}, then doseedo_session_from_stems {from_job, mix_job}. Async: job_id → doseedo_wait_task (~1–4 min). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.

Inputs: bpm, mix, name, seed, +16 more.

doseedo_score_to_pictureLay the score on the pictureAInspect

SCORE TO PICTURE: the last step of scoring a film. Lays each mixed cue (and any sound effect) on the video at its SMPTE timecode, with dialogue ducking (the lines found on the video's own soundtrack by VAD, or the spans you pass; the music dips ahead of each line and comes back after it), normalises the program to a delivery loudness (web −16, streaming −14, broadcast/ebu −23, atsc −24 LUFS, or a number; true peak under the ceiling) and muxes it onto the picture untouched (no re-encode). Returns the scored video, the printmaster WAV and the music-and-effects stem, plus a report of what it MEASURED: where each track landed (and what was cut at the film's edges), how far the music sits under the lines, and the final loudness and true peak. CPU, no credits. tracks: [{audio_url (a doseedo_mix mix_url as returned, or any public https URL) | audio_key, start_timecode (in the film's timecode) | start_s, gain_db?, role?: music|dialogue|effects, duck?, name?}], ≤ 64. Keep the production audio (default) or drop it (production_audio:"drop"). A FILM THAT ALREADY HAS MUSIC: keeping its audio mixes the old music under yours — split it first (doseedo_split_soundtrack) and lay its dialogue and effects stems back (start_s 0, role dialogue / effects) with production_audio:"drop": the old music is gone, the lines are kept, and the duck reads the lines off the dialogue stem; lay the old music stem back too with duck:false to keep it (or a part of it). With dialogue tracks the delivery also returns the dialogue / music / effects stems. Up to 25 minutes of film per call (a reel). Async: job_id → doseedo_wait_task. Cancel: a delivery still queued never starts and one running stops within seconds; either way its credit is refunded and the job ends as canceled.

Inputs: tracks (required), duck, name, dialogue, +7 more.

doseedo_separate_stemsSeparate stems (vocal remover)AInspect

STEM SEPARATION and VOCAL REMOVER: split an uploaded mix into stems (vocals, drums, bass, guitar, piano, other — or orchestral/auto-detected instruments) to isolate vocals (the vocals stem is the acapella; the other stems are the karaoke backing), with optional per-stem MIDI transcription and DAW-session export. Async: returns a job_id — poll with doseedo_wait_task (~2 minutes). Result: stems{name: url}, midi{name: url}, drum_substems{kick, snare, …} (drum_split), vocals_lyrics / vocals_notes, session_tracks + session_tempo_bpm when session_id was given, models_effective (what the auto family gate actually ran), other_classification (what the "other" stem was heard as), guitar_split (outcome). Cancel: the plane has no stop for a running separation — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: name, export, models, audio_key, +9 more.

doseedo_session_from_stemsStems → a DAW sessionAInspect

Build a native DAW PROJECT from stems: each stem on its own audio track from bar 1, optional MIDI tracks (the written parts) beside them, on your tempo (bpm or tempo_map) — Logic Pro (.logicx) or Ableton Live (.als), zipped. The deliverable after doseedo_render_score (pass from_job: its job_id and the stems, MIDI and tempo come from that job) or after any renders / separations you made (stems: [{name, audio_url}] — result links work as-is). After doseedo_mix add mix_job: each track at that mix's level and pan, the mix as a muted reference track. Async: job_id → doseedo_wait_task (~30–90 s) → file (pre-signed zip, curl -o session.zip , 24 h). Cancel: the plane has no stop for a running session build — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: bpm, cues, name, stems, +11 more.

doseedo_split_soundtrackSplit a film's soundtrack (dialogue / music / effects)AInspect

SPLIT A FILM'S SOUNDTRACK (dialogue / music / effects — "DME" — separation): the film's own audio into three stems that sum back to it, plus a report of what it holds: whether there is music already, where it plays (spans in seconds) and how much of the film it covers, where the dialogue is (cleaner than VAD on the full mix: a song's singer stays in the music stem), each part's level, and how far the music sits under the lines. Use it before scoring a film that already has music (soundtrack.stems.music.present): to REPLACE that music, lay the dialogue and effects stems under your score with doseedo_score_to_picture (production_audio:"drop", tracks role "dialogue" / "effects"); to REMIX or RE-ORCHESTRATE it, the music stem goes to doseedo_separate_stems / doseedo_transcribe / doseedo_analyze_song; to KEEP it, score where the report shows no music. Input: video_key (the upload doseedo_spot_video read) or video_url; audio_key / audio_url for a soundtrack already on its own. One reel per call (≤ 30 min). The split is good, not perfect: a line the separator heard as music is moved back to the dialogue (soundtrack.dialogue_rescue says what moved; a sung or rapped voice stays in the music as the film's song), while some of the old music (its percussion most) reads as effects — about −10 dB of it stays in the dialogue + effects bed, which the new score masks. Async: job_id → doseedo_wait_task (about a third of the soundtrack's length: a 3-min scene ≈ 1 min, a 20-min reel ≈ 6 min). Cancel: the plane has no stop for a running split — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: name, audio_key, audio_url, video_key, +2 more.

doseedo_spot_videoSpot a video → cue sheetAInspect

SPOT A FILM: a video in, the music editor's cue sheet out — the first step of scoring to picture. Scene detection on EVERY frame, and it listens to the soundtrack (CPU, no credits): hard cuts frame-exact (dark, low-contrast footage included), fades, flashes and visual impacts; each shot's brightness, colour, warmth, contrast, motion and mood, with a keyframe JPEG per shot so you can SEE what it shows; SCENES — where the picture moves to a new place, at a cut or with none (a camera move, a dissolve) — each with its start, how it arrives, how fast the camera travels (pace) and a 640-px frame; and a storyboard: the whole film on one JPEG, a frame every few seconds; where dialogue is (Silero VAD) and loud audio hits; INTENSITY — the picture's energy (motion, cutting, camera, the sound) as sections [{start_s, end_s, level, rel: low | medium | high | peak}], and each scene's own: where the music steps up, settles and peaks; then cues placed where the picture wants music and the dialogue lets it (1M1, 1M2 …: start/end SMPTE timecode, emotion, energy, tension arc, hit points ranked by strength, a suggested bpm that lands them, and tempo_map_input — pass it to doseedo_tempo_map as is). It sees light, movement and editing, not meaning: read the scene frames and the storyboard for what each scene is about. Input: video_key (doseedo_get_upload_url accepts mp4/mov/m4v/webm/mkv) or video_url (public https), ≤ 2 GB and ≤ 3 h. Optional start_timecode (the first frame's, e.g. 01:00:00:00; default the file's own), coverage (0.05–0.98, default 0.55: how much of the film gets music), reel (cue ids M), keyframes (0–60), spotter. Async: job_id → doseedo_wait_task (~1 min for a 10-min 1080p reel). Next: doseedo_tempo_map per cue → write the notes → doseedo_render_score → doseedo_mix → doseedo_score_to_picture. Cancel: a spotting pass still queued never starts and one running stops within seconds; either way its credit is refunded and the job ends as canceled.

Inputs: name, reel, spotter, coverage, +6 more.

doseedo_supervise_cuesCut cues from public-domain scoresAInspect

MUSIC SUPERVISION, for a film whose direction is classical or orchestral: instead of writing every note, each cue is CUT FROM A REAL PUBLIC-DOMAIN SCORE (~1,000 orchestral pieces, Baroque to late Romantic, free to use in a film — no rights holds, no ShareAlike). The search fits each cue: its length to the frame (a passage bent ≤ ~17 % in tempo, cut on a bar line where it must), the cue sheet's turns on the score's own section changes, its hits on real accents, its mode and meter, its level over time (a quiet cue thins a tutti's doublings; the loudest moment lands on the source's own rise), and cues of one piece play fresh bars. SAY WHO PLAYS AND HOW BUSY IT IS, or a quiet piano-and-strings cue is cut from a tutti: instruments = the cue's players (the source plays only its parts for those); density = sparse | moderate | busy | driving, or notes a second; per film, or per_cue. Input: spot_job (the doseedo_spot_video job id — spotter "model" gives each second its level) or cue_sheet; cues (ids, default every score cue); direction {era: ["Baroque"|"Classical"|"Romantic"…], genre, composer: ["Antonín Dvořák"…], mode: major|minor}; prefer {cue: file} = take that cue from an alternative an earlier answer listed. Async: job_id → doseedo_wait_task (~5–60 s; a bad direction, cue or prefer fails at once), CPU, no credits. Result per cue: source {composer, title, licence, credit — the line a CC BY edition asks for}, edit (bars, stretch, cuts), render {score_url, instruments, name} = the doseedo_render_score call that plays it (pass it as is; change an instrument by editing instruments), mix_lufs_offset_db (master the cue at the delivery loudness plus this: doseedo_mix target_lufs), alternatives [{composer, title, file, cost}]. Cancel: the plane has no stop for a running catalogue search — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: cues, name, prefer, density, +6 more.

doseedo_tempo_mapTempo map from hit pointsA
Read-onlyIdempotent
Inspect

Scoring to picture: turn HIT POINTS (a cut, an impact, the title card — as seconds from the cue start or SMPTE timecodes) into a TEMPO MAP that lands each hit exactly on a downbeat (or a beat / an eighth — per hit with hits[].land), staying near your tempo and inside bpm_range. A cue whose pace changes (she runs faster, then stops): give the hit where it changes a bpm, and the map moves to that tempo from there, every hit still landed. An AD or any cue that must hold ONE tempo: fixed_bpm: true (+ max_deviation_bpm, tolerance_ms) finds the tempo and the bar-1 offset (music_offset_s) landing the most hits, and says which ones it could not. Returns tempo_map [{beat, bpm}] to pass unchanged to doseedo_render_midi / doseedo_render_score / doseedo_session_from_stems, and hits[] with the beat, bar and beat-in-bar each hit lands on — write the accent, stinger or change there. Handles 23.976 / 24 / 25 / 29.97 (";" = drop-frame) / 30 / 50 / 59.94 / 60 fps timecode. Pure math: free, instant, no key needed.

Inputs: bpm (required), hits (required), fps, land, +8 more.

doseedo_train_instrumentTrain a custom instrumentAInspect

Make a CUSTOM INSTRUMENT in your own sound: upload 30 s–3 min of ONE instrument playing (your own player, a rare or folk instrument, a prepared/invented instrument, a vintage synth) and doseedo trains a private adapter (LoRA) on its serving instrument model in about 1–2 minutes. After that, doseedo_render_midi {instrument: , lora_id} plays ANY notes you write in that sound. Several takes help (up to 8 files; the first 3 min are used, ≥8 s required); a clean, solo, dry recording works best. instrument = the closest catalog instrument — it picks the model voice the adapter trains on (a shamisen trains as acoustic_guitar, a whistle as flute: doseedo_instruments lists each one's call.instrument). The notes are transcribed for you (pass notes to skip that). 20 credits. Result: lora_id, name, the windows it trained on, loss first→last, and use (the render args). Earlier ones: doseedo_list_jobs {kind:"train_instrument"}. Owner-only: no one else can render with it. Async: job_id → doseedo_wait_task (~1–2 min). Cancel: the plane has no stop for a running training — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: instrument (required), bpm, name, seed, +8 more.

doseedo_transcribeAudio to MIDI (transcribe notes)AInspect

AUDIO TO MIDI transcription: a melody, a bass line or a part as notes (pitch, onset/offset seconds, velocity, confidence as JSON — not a MIDI file; for .mid files per stem use doseedo_separate_stems with transcription or doseedo_audio_to_session). Works from an uploaded audio_key or an audio_url — any public https URL, including a result URL from another doseedo job (a generate take, a stem) as it was returned. Async: returns a job_id — poll with doseedo_wait_task (usually ~15–60s). For the KEY / tempo / chords of a whole mix use doseedo_analyze_song instead. Cancel: the plane has no stop for a running transcription — it runs to completion (credits spent), the job ends as canceled and its output is discarded. Only a job still queued at the plane is refunded by the plane's own failure refund.

Inputs: want, chairs, family, roster, +10 more.

doseedo_wait_taskWait for a jobA
Read-onlyIdempotent
Inspect

Wait for an async doseedo job to finish: polls server-side for up to timeout_seconds (5–50; one call can never hold longer than 50 s), then returns the result or the latest status. If it returns still_running:true, call it again — a submit reply's eta_seconds says how long the whole job usually takes (transcribe ~15 s, a render 1–3 min, audio_to_session ~4 min), so a 3-minute job is three or four calls, not one. A finished job answers with its output, artifacts (pre-signed links) and note.

Inputs: kind, job_id, task_id, timeout_seconds.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      A
      maintenance
      Analyzes video footage to detect mood, energy, pace, speech, and scene cuts, then returns license-safe royalty-free/CC BGM shortlists with hook windows, beat-synced cut suggestions, and ffmpeg ducking and mix specs. Lets agents preview mixes and export ready-to-render specs with attribution printed on every recommendation.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      AI-assisted sheet music transcription and notation workflow via Agent and MCP.
      1
      Apache 2.0
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources