Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server
com.doseedo/doseedodoseedo.comstreamable-httpv0.22.1Scanned
Score video, make music as an agent: 100+ AI instruments play your MIDI, audio, stems, Logic/Ableton
53 tools: 3 can delete or cancel things, 44 change things and 6 only read.
- Reads private data · 4
- Reads text others write · 49
- Can send data out · 0
- 9 findings
Tools listed without sign-in. Remote posture
With Anlyon
3 tools here can delete or cancel things. Govern them.
- Anlyon lists the tools and adopts none.
- Each tool you adopt gets approvals and receipts.
- Your agent never holds the key.
A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.
What the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server can do
The Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server is published by doseedo.com, a domain the MCP Registry verified. It has 53 tools. It can delete or cancel things (3 tools: doseedo_cancel_job, doseedo_delete_sessions and doseedo_edit_session) and create or change data (44 tools: doseedo_generate_music, doseedo_generate_sound, doseedo_generate_loop, doseedo_cover_stem and 40 more). 6 tools only read.
4 tools read private data (doseedo_analyze_midi, doseedo_get_project_upload_url, doseedo_get_upload_url and 1 more); 49 tools bring in text other people can write (doseedo_generate_music, doseedo_generate_sound, doseedo_generate_loop and 46 more).
The fixed checks matched 9 findings (long-description and annotation-conflict). Each one comes with the text it matched.
Its remote endpoint lists its tools without sign-in, and its tools changed 7 times since Anlyon Radar first saw them.
Last scanned Nov 17, 2026, version 0.22.1.
Tools
Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.
53 tools
Deletes or cancels 3Claude Code: deny
doseedo_cancel_jobCancel a queued or running job.Reads text others writeNo findings
Why it is in this group
- The name "doseedo_cancel_job" says "cancel": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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).
Annotations the server declares
- readOnlyHint: false
- destructiveHint: true
- idempotentHint: true
- openWorldHint: true
doseedo_delete_sessionsDelete DAW sessions in bulk — a SOFT delete (the sessions disappear from the account and every listing; nothing on the user's disk is touched).Reads text others writeNo findings
Why it is in this group
- The name "doseedo_delete_sessions" says "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Delete DAW sessions in bulk — a SOFT delete (the sessions disappear from the account and every listing; nothing on the user's disk is touched). Select by ids, or by filters (daw_kind, created_before / created_after, name_contains); filters combine with AND. SAFE BY DEFAULT: without confirm:true this is a DRY RUN that deletes nothing and returns {matched, ids}. Always run the dry run first, show the user the count (and names if few), and call again with confirm:true only after they agree. Never delete sessions the user did not ask to remove.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: true
- idempotentHint: true
- openWorldHint: true
doseedo_edit_sessionEdit a DAW session with a list of ops (regions, MIDI notes, sampler samples, tracks, mixer faders/pans/mutes, plugins, tempo, markers, key, …): ids and current values from doseedo_…Reads text others writeNo findings
Why it is in this group
- The name "doseedo_edit_session" says "edit": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Edit a DAW session with a list of ops (regions, MIDI notes, sampler samples, tracks, mixer faders/pans/mutes, plugins, tempo, markers, key, …): ids and current values from doseedo_get_session, op arguments from doseedo_edit_ops_reference. When sync.live_edits is true Dø Desktop puts it into the user's Logic project (it saves, backs up, closes and reopens the project, ~10–20 s — tell the user); otherwise stored and applied at next open. CONTRACT: every op is validated before anything is stored; a rejection carries a code — unknown_op / unknown_plugin (with did_you_mean), unknown_id (with the valid ids), duplicate_id, forbidden_group, read_only_key — and a reason. atomic (default true): one rejection → NOTHING stored, all rejections listed; atomic:false stores the good ops. RETRY: re-send a timed-out call with the SAME batch_key and it dedups (deduped:true); without batch_key a retry duplicates. Ops apply on the desktop one at a time in order, no per-batch undo — verify with doseedo_download_session (replay).
Annotations the server declares
- readOnlyHint: false
- destructiveHint: true
- idempotentHint: false
- openWorldHint: true
Changes things 44Claude Code: ask
doseedo_accountCheck the connected doseedo account: plan tier, the monthly credit pool (generation AND DAW conversions draw it), purchased extra-usage credits, and storage.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_add_audio_to_sessionAdd an audio file to a session — from a public URL (a doseedo-generated song, a separated stem, any https audio) OR from a LOCAL file you uploaded (doseedo_get_upload_url → PUT the…Reads text others writeNo findings
Why it is in this group
- The name "doseedo_add_audio_to_session" says "add": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Add an audio file to a session — from a public URL (a doseedo-generated song, a separated stem, any https audio) OR from a LOCAL file you uploaded (doseedo_get_upload_url → PUT the bytes → pass the returned audio_key here). Ingested server-side and returned as a sha256 you then use: place it on a track with attach_audio, or load it into a Quick Sampler with load_quick_sampler_sample {track_id, sample_path: "<the sha>"} (bakes into the exported .logicx, no desktop needed — the drum-pack/sample-swap path). Give audio_url OR audio_key.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_analyze_midiCheck 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 simultaneou…Reads private dataReads text others write1 finding
Why it is in this group
- The name "doseedo_analyze_midi" says "analyze": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- private-dataThe description's first sentence says "note": it reads notes.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "doseedo_analyze_midi" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":false,"openWorldHint":true}; The name "doseedo_analyze_midi" says "analyze": a word for reading.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_analyze_songKey detection, BPM/tempo detection, song structure and chords — musical analysis of a recording in one call: key (e.g.Reads text others write1 finding
Why it is in this group
- The name "doseedo_analyze_song" says "analyze": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "doseedo_analyze_song" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":false,"openWorldHint":true}; The name "doseedo_analyze_song" says "analyze": a word for reading.
Description, as the server wrote it 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): 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_audio_to_sessionTurn an uploaded full mix into a complete multitrack DAW session (separated stems as tracks, tempo map, optional per-stem MIDI and chord guide).Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Turn an uploaded full mix into a complete multitrack DAW session (separated stems as tracks, tempo map, optional per-stem MIDI and chord guide). The result is a downloadable session zip for Logic Pro or Ableton. Async: returns a job_id — poll with doseedo_wait_task (~4 minutes). Cancel: cooperative — the build stops at its next stage boundary and the build's sound-tool unit is refunded (a GPU separation already run stays charged).
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_beat_gridBeat detection / beat tracking: bpm, beats[] (seconds), downbeats[] (seconds), beats_per_bar, downbeat_offset, beat_map[{t, pos}], duration — the grid to place a part against a rec…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Beat detection / beat tracking: bpm, beats[] (seconds), downbeats[] (seconds), beats_per_bar, downbeat_offset, beat_map[{t, pos}], duration — the grid to place a part against a recording (beat n is at beats[n] seconds). 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 (~3–15 s). For key + sections + chords as well use doseedo_analyze_song. Cancel: not applicable — the result is returned in the submit response; the job is already finished.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_bounce_sessionBounce a session (or specific tracks) to audio on the user's Mac — Dø Desktop renders them in the background WITHOUT the user opening the DAW (engine "headless"): each AUDIO track'…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Bounce a session (or specific tracks) to audio on the user's Mac — Dø Desktop renders them in the background WITHOUT the user opening the DAW (engine "headless"): each AUDIO track's regions as the arrangement places them, from bar 1, through the track's third-party Audio Units. Logic's own plug-ins and instrument/MIDI tracks render only inside Logic: each stem names the plug-ins it does not include (plugins_not_rendered), and an instrument track is reported, not rendered. engine "live" (Logic's own bounce) needs a live Logic connection, which the public Dø Desktop does not have. Each stem says its format: the requested wav/aiff, or "opus" when the plan cannot store lossless (the lossless file is then on the Mac at local_path). A track that could not render is named in the error with its reason. Async: returns a job_id — poll with doseedo_wait_task. The result is downloadable stem URLs. Needs Dø Desktop to run at some point to pick up the job; until then it stays queued. No credits (rendered on the user's machine). Cancel: a bounce still queued never renders (its budget is refunded); one mid-render has its result dropped on arrival.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_check_takeMEASURE 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…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_check_taskCheck an async doseedo task once.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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: ["<name>" 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"]).
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_complete_project_uploadFinish a MULTIPART project upload started by doseedo_get_project_upload_url: pass every uploaded part's number and ETag (from the PUT response header; quotes optional).Reads text others writeNo findings
Why it is in this group
- The name "doseedo_complete_project_upload" says "upload": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Finish a MULTIPART project upload started by doseedo_get_project_upload_url: pass every uploaded part's number and ETag (from the PUT response header; quotes optional). Returns the project_key to pass to doseedo_convert_project / doseedo_import_project. All parts except the last must be the same size (what `split -b` produces). abort:true discards the upload instead.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_convert_projectDAW CONVERTER: a project rebuilt natively in the target: tracks, MIDI, audio clips, tempo and markers arrive editable (Logic/Ableton/Pro Tools/REAPER pairs also automation, buses/s…Reads text others write1 finding
Why it is in this group
- The name "doseedo_convert_project" says "convert": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description is 2,046 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "..., output discarded; the credit is refunded only when the conversion itself fails."
Description, as the server wrote it DAW CONVERTER: a project rebuilt natively in the target: tracks, MIDI, audio clips, tempo and markers arrive editable (Logic/Ableton/Pro Tools/REAPER pairs also automation, buses/sends, plugin state; into FL 3rd-party plugins only). Sources: Logic .logicx, Ableton .als, FL Studio .flp, Pro Tools .ptx, REAPER .rpp, Cubase .cpr, Dorico .dorico/.musicxml, Studio One .song, GarageBand .band (SOURCE only — zip the .band package like a .logicx; a GarageBand 6 project must be re-saved in GarageBand 10), Bitwig = any .dawproject (Bitwig/Studio One/Cubase export it; a native .bwproject is refused — File > Export… > DAWproject in Bitwig). The enum lists the exact pairs. ★ ASYMMETRIC TARGETS (an undocumented native file is never written): TO Cubase, Studio One or Bitwig = ONE .dawproject the app imports, not a .cpr/.song/.bwproject; TO Dorico = MusicXML (.mxl, Dorico's own notation import), not a .dorico. FROM Cubase the .cpr carries tracks, tempo and MIDI parts but not the audio pool (audio tracks arrive empty). FROM Dorico a .dorico carries players and flows but NOT its notes: convert its MusicXML export instead (.musicxml/.mxl accepted under dorico2*). Every result carries a transfer REPORT: `report`, `lossy`, `summary[]` (what changed), `warnings[]` (read before opening) — relay them; silence is never "lossless". Upload first: doseedo_get_project_upload_url + PUT (zip a project FOLDER so its audio travels; a bare project file works too; multipart past ~4 GB). Directions: "<source>2<target>"; "auto2<target>" detects the source; "<daw>2<daw>" rebuilds Logic/Ableton/FL/REAPER/Pro Tools in place (e.g. options.third_party_plugins:"disable"). To EDIT a project use doseedo_import_project; to convert a session the tools built: doseedo_download_session → upload that zip → logic2<target> (not a session_id). Async: job_id → doseedo_wait_task (15 s–2 min; `stage`); `file` is a direct storage link. Cancel: no stop — it completes, the job ends canceled, output discarded; the credit is refunded only when the conversion itself fails.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_cover_songAI COVER / style transfer of a whole song: re-render an uploaded song as a cover, keeping its structure/melody while changing timbre, instruments, or lyrics.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it AI COVER / style transfer of a whole song: re-render an uploaded song as a cover, keeping its structure/melody while changing timbre, instruments, or lyrics. INSTRUMENT SWAP: instruments {"piano": "electric_guitar"} separates the song, transcribes the swapped stem and re-plays THOSE transcribed notes on the target instrument; by default only the swapped stem(s) are regenerated and every other stem passes through as the original separated audio (regen changes that). Because the swap replays a transcription, small note differences from the source are expected — verify from result.cover.instrument_swaps (applied or why not), and offer the user the result/takes to judge rather than promising a note-perfect copy. Target ids: GET https://api.doseedo.com/api/instruments (open). Optionally export a DAW session too. Async: returns a job_id — poll with doseedo_wait_task (several minutes for full songs). Result files are pre-signed links: curl -OJ <url>, no auth header (valid 24 h). 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_cover_stemTIMBRE TRANSFER (an instrument swap) from a recording: hum or whistle a melody, play it on a kazoo, take a guitar line — and get it back played by a cello, a trumpet, a koto (any d…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it TIMBRE TRANSFER (an instrument swap) from a recording: hum or whistle a melody, play it on a kazoo, take a guitar line — and get it back played by a cello, a trumpet, a koto (any doseedo_instruments call). Re-play ONE recorded part — a separated stem, a solo, a region of the user's session — on another instrument, straight from the audio: the recording's FSQ codes carry its structure into a take generated from noise, and the sound is the instrument's (caption + timbre_preset) — the FSQ + timbre combination the cond5 model was trained on (served on its turbo graft). No MIDI by default (midi:true adds the server's own pitch roll of the recording); `fidelity` > 0 also keeps that much of the recording's own latents (closer, but its sound leaks back in). For the exact notes, transcribe and doseedo_render_midi; a whole mix → doseedo_cover_song. result.recipe says what reached the model (fsq, timbre, cns). Async: job_id → doseedo_wait_task (~30–90 s) → takes[{url}] (pre-signed: curl -OJ, no auth header, 24 h). 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_create_sessionCreate a new, empty DAW session in the account (a blank project you can then populate with doseedo_edit_session, or target with doseedo_audio_to_session).Reads text others writeNo findings
Why it is in this group
- The name "doseedo_create_session" says "create": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Create a new, empty DAW session in the account (a blank project you can then populate with doseedo_edit_session, or target with doseedo_audio_to_session). Returns its session_id.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_detect_chordsChord detection on audio (a chord chart on the beat grid): chord_spans[{chord, start, end, start_beat, end_beat, confidence}], chords{"<beat>": "Am7"}, bpm, beats_per_bar, beat_map…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Chord detection on audio (a chord chart on the beat grid): chord_spans[{chord, start, end, start_beat, end_beat, confidence}], chords{"<beat>": "Am7"}, bpm, beats_per_bar, beat_map. Default = the deep ACE detector (GPU-backed, a CPU chroma detector is the automatic fallback); deep:false forces the fast CPU detector. 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. Works best on a harmonic stem (piano/guitar/bass) or a clean mix. Synchronous (~5–30 s). Cancel: not applicable — the result is returned in the submit response; the job is already finished.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_download_sessionSave a session as a native Logic project (.logicx.zip), rebuilt server-side from the session state — no desktop needed.Reads text others write1 finding
Why it is in this group
- The description's first verb is "save": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "doseedo_download_session" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "save": a word for a change.
Description, as the server wrote it Save a session as a native Logic project (.logicx.zip), rebuilt server-side from the session state — no desktop needed. Returns a short-lived NO-AUTH download_url (plain `curl -o ~/Downloads/…`, no header) plus `replay` = what the build put in the file (per track: kind, Quick Sampler sample + sampler {mode, sample_seconds, start/end, plays_beats}, MIDI note count, audio region count; bundled media; deferred ops the offline build could not synthesize) and `warnings` (e.g. a classic-mode sampler whose notes end before its sample; an unknown sample length). `replay.layout {ok, problems}` is read back from the built file (every region on its own track); `replay.master.plugins` is the Stereo Out chain (ch_master); `replay.not_built` counts the ops of tracks the session later deleted (a reused session builds only what it holds now). Verify from replay/warnings, never by unzipping ProjectData. `place_local_files` (when present) is ACTION-REQUIRED after unzipping — for Quick Sampler samples AND audio regions from local paths: a replay track with audio_source:"place_local_files" or a "NOT bundled" warning means that file is not in the zip until you run those cp commands; then tell the user the project is complete.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_edit_lyricsLYRIC EDIT / VOCAL INPAINT: send a sung recording and its words as they should be, and get the recording back with the changed words sung in the SAME singer's voice on the same mel…Reads text others writeNo findings
Why it is in this group
- The name "doseedo_edit_lyrics" says "edit": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it LYRIC EDIT / VOCAL INPAINT: send a sung recording and its words as they should be, and get the recording back with the changed words sung in the SAME singer's voice on the same melody — punched in: every word left alone plays as recorded (bit-exact), only the changed words (with a word of context) are sung again and spliced in. A whole song works too: its vocal is separated, edited and mixed back into the song (vocal_only: true skips that for a vocal on its own). Best with `heard` — the recording's words with their times, as you heard them (Whisper): send EVERY heard line in `lyrics`, the ones to change in their new words, and each line is laid on its own phrase, changed word by word. Without it the server hears the words itself and matches your lines to its phrases. Async: job_id → doseedo_wait_task (~60–180 s) → takes[{url}] as long as the recording (pre-signed: curl -OJ, no auth header, 24 h); output.lyric_edit says what was heard, what was sung again where (splice), and the credits it settled. 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_edit_ops_referenceThe catalog of session edit ops doseedo_edit_session accepts, served in views that each fit one answer (never cut mid-JSON).Reads text others write1 finding
Why it is in this group
- The name "doseedo_edit_ops_reference" says "edit": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "doseedo_edit_ops_reference" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "doseedo_edit_ops_reference" says "edit": a word for a change.
Description, as the server wrote it The catalog of session edit ops doseedo_edit_session accepts, served in views that each fit one answer (never cut mid-JSON). DEFAULT (no args): units, ids, applies, groups, batching/policy, the recipe NAMES and every op as {op, group, applies, summary} — read it ONCE before a build. Then fetch what you need: op:"load_quick_sampler_sample" (or ops:[…]) → those ops in full (args, units, doc; an unknown name gets did_you_mean); section:"recipes" → the full recipes (drum kit from local samples, fix note lengths, one-shots on an audio track, remote sample, submix bus, verify) — copy one instead of discovering op order; section:"ops" → every op in full; "units" / "ids" / "summary" (the get_session field map + workflow + policy + batching) / "all" (fitted, may shorten). Each op says where it lands (applies: live in the open project | next_open | state). Read-only, no key needed.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_fill_gapINPAINT (repair) a part: send ONE recorded part (a stem, a DAW track's audio) with a gap in it — the silence between two clips, a bar to redo, a dropout — and get it back with the …Reads text others writeNo findings
Why it is in this group
- The name "doseedo_fill_gap" says "fill": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it INPAINT (repair) a part: send ONE recorded part (a stem, a DAW track's audio) with a gap in it — the silence between two clips, a bar to redo, a dropout — and get it back with the gap PLAYED: the take before and after the gap is kept bit-exact (spliced back), and the gap is generated against both, so it continues out of what comes before and leads into what follows. What fills it is planned first (the DSP plane's extend planner, which hears the part): the take's own LOOP when it has one — the gap is seeded from its own passes at the matching bar phase, so a groove keeps turning — else a part written in its key and over its chords, performed in the take's own sound. Pass the session's bpm and bar grid (bar_offset_seconds: where a bar line falls in the audio you send); the gap is in seconds of that audio. Send the part with some of the take on each side of the gap (8 bars or more before it is best). Async: job_id → doseedo_wait_task (~40–150 s) → takes[{url}]: WAVs as long as the audio you sent, the gap filled — cut out the gap (or the span you need) to drop it into the DAW. output.plan says what filled it (loop bars, or the writer and the changes). 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_generate_loopA DRUM LOOP from a generator — doseedo_generators lists them (house, deep_house, tech_house, afro_house, jackin_house… the list grows without a release).Reads text others writeNo findings
Why it is in this group
- The name "doseedo_generate_loop" says "generate": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it A DRUM LOOP from a generator — doseedo_generators lists them (house, deep_house, tech_house, afro_house, jackin_house… the list grows without a release). The groove is WRITTEN for the seed (kick, clap, hats, shaker, percussion voices, ghost notes, fills at the phrase ends, 16th swing) and PLAYED through the generator's kit of recorded one-shots (drawn by the seed, the kick tuned to key): the same generator + seed + bars + bpm is the same loop, another seed another groove and another kit. Returns the loop as audio (48 kHz WAV, exactly `bars` long, its tails wrapped round the loop point so it repeats seamlessly), its MIDI (midi_url, GM drums) and, for a short loop, the notes (notes[] — edit them and play them back with doseedo_render_midi {instrument:"electronic", drum_genre:"<the generator's genre>", notes}, or put them on a session track with set_midi_notes). MIDI only, free and instant: doseedo_generators {generator, bars, bpm, seed}. Wrong tool for drums you wrote (doseedo_render_midi) or a described sound (doseedo_generate_sound). Async: job_id → doseedo_wait_task (a few seconds) → files[0] (pre-signed: curl -OJ <url>, no auth header, valid 24 h). 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_generate_musicNOT A COMPOSER: doseedo plays music, it does not write it — YOU write the piece.Reads text others writeNo findings
Why it is in this group
- The name "doseedo_generate_music" says "generate": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it NOT A COMPOSER: doseedo plays music, it does not write it — YOU write the piece. Background music for a video or a brand film, an instrumental, a theme, a song: compose every part yourself as notes ([{pitch, start_beats, duration_beats, velocity}], beats from bar 1 — melody, harmony, bass, in the key and at the tempo you choose), then play them: doseedo_render_score {parts} for several instruments (one stem each, then doseedo_mix) or doseedo_render_midi for one; doseedo_instruments lists the players and their ranges; the steps: doseedo_recipes name="compose-piece" (to picture: "score-a-film"; one part in a session's key: "compose-part"). THIS tool is text to music from a PROMPT alone (optionally lyrics) with NO notes behind it: the instrument model then has nothing to play, and a take is often near-silent, a drone or clicks. Nothing in it is controlled — no key control (a key in the prompt is not honoured), no MIDI input, bpm/time_signature only tag the caption. Use it only when the user explicitly asks for a prompt-only AI sketch, listen before handing a take over, and never deliver one as the music. Async: job_id → doseedo_wait_task (typically 1–3 min) → audio URLs (pre-signed: curl -OJ <url>, no auth header, valid 24 h — see expires_at). 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_generate_soundSOUND 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-…Reads text others writeNo findings
Why it is in this group
- The name "doseedo_generate_sound" says "generate": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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 <url>, no auth header, valid 24 h). 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_generatorsGENERATORS — music you do not have to write.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it GENERATORS — music you do not have to write. BAND generators (has: ["band"] — jazz …; more genres are added without a release) write a WHOLE arranged piece in a genre: every part's notes (drums, bass, piano, a lead), its form and changes, for a seed. With generator + bars | seconds, bpm, key, seed, lead ("none" = rhythm section alone) → parts[] ({name, instrument, timbre_preset, notes}), form, changes and the .mid (midi_base64): free, instant, no audio. To HEAR it: doseedo_render_score {generator: {id, seed, bars, key, lead}, bpm} plays that exact piece — you pass no notes — and doseedo_mix {from_job} mixes it in the genre's own style (mix_style: a dub's spring tank and tape echo). A film cue or a song that calls for a generator's genre should use it rather than be composed. DRUM generators — ready-made kits and grooves: each generator is a KIT (recorded one-shots for a genre: doseedo_render_midi plays your drum notes through it when the part's drum_genre names it), a LOOP (a groove written for a seed: doseedo_generate_loop → the audio + its MIDI), or both (house, deep house, tech house, afro house, jackin' house — the list grows without a release, so read it rather than remember it). No args → every generator: id, what it has, the drum_genre words that reach its kit, its loop's tempo, swing and bars. With generator (+ bars, bpm, seed, swing, fills, percussion) → that generator's loop AS MIDI: notes[] [{pitch, start_beats, duration_beats, velocity}] (GM drums) and the .mid (midi_base64) — the SAME groove doseedo_generate_loop plays for that seed, instant, free, no audio: read a few seeds, pick or edit one, then render it (doseedo_generate_loop with the same seed, or doseedo_render_midi with your edited notes) or put it on a session track (set_midi_notes). Read-only, no key needed.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
doseedo_get_project_upload_urlGet a presigned upload for a DAW PROJECT file (for doseedo_convert_project / doseedo_import_project).Reads private dataReads text others write1 finding
Why it is in this group
- The name "doseedo_get_project_upload_url" says "get": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- private-dataThe description's first sentence says "get" and "file": it reads files.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe name "doseedo_get_project_upload_url" says "get" and "url": it reads web pages, which anyone can write.
Findings
- Warn
The server marks "doseedo_get_project_upload_url" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "doseedo_get_project_upload_url" says "get": a word for reading.
Description, as the server wrote it Get a presigned upload for a DAW PROJECT file (for doseedo_convert_project / doseedo_import_project). Zip a project FOLDER so its audio travels with it — and a .logicx or GarageBand .band, which are folders (macOS packages). SIZE LIMITS: a single PUT takes up to 5 GB; guest and free accounts convert projects up to 2 GB, paid plans up to 12 GB (a larger one is refused as project_too_large with the cap and an upgrade link). Pass size_bytes: past 4 GB (or with multipart:true) you get a MULTIPART upload instead — a part_size, one presigned part_url per part, and the complete step (doseedo_complete_project_upload); each part is retried on its own, so a dropped connection costs one part, not the upload. Single PUT: `curl -sS -X PUT -H "Content-Type: application/zip" --data-binary @project.zip "<upload_url>"`, then pass project_key on. Multipart: `split -b <part_size_bytes> project.zip part.` then for each piece in order `curl -sS -X PUT --data-binary @part.aa "<part_url>" -D - -o /dev/null | grep -i etag` (keep each ETag), then doseedo_complete_project_upload {project_key, upload_id, parts}. Need more part URLs than one answer holds? Call this again with project_key + upload_id + part_numbers.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_get_upload_urlGet 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 fi…Reads private dataReads text others write1 finding
Why it is in this group
- The name "doseedo_get_upload_url" says "get": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- private-dataThe description's first sentence says "get" and "file": it reads files.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe name "doseedo_get_upload_url" says "get" and "url": it reads web pages, which anyone can write.
Findings
- Warn
The server marks "doseedo_get_upload_url" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "doseedo_get_upload_url" says "get": a word for reading.
Description, as the server wrote it 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).
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_identify_soundInstrument recognition + genre classification of audio (a stem, a loop, a whole mix): instrument (e.g.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_import_projectOpen an uploaded DAW project (Logic .logicx.zip, Ableton .als or project zip, FL .flp, REAPER .rpp, Pro Tools .ptx — zip the folder) as an EDITABLE doseedo session: returns a sessi…Reads text others writeNo findings
Why it is in this group
- The name "doseedo_import_project" says "import": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Open an uploaded DAW project (Logic .logicx.zip, Ableton .als or project zip, FL .flp, REAPER .rpp, Pro Tools .ptx — zip the folder) as an EDITABLE doseedo session: returns a session_id the session tools then work on (doseedo_get_session → doseedo_edit_session → doseedo_download_session as a native Logic project, or convert that download to another DAW with doseedo_convert_project). The session gets the project's tempo (+ tempo map), meter, markers, and every track with its name, mixer level/pan, color and MIDI notes. AUDIO IS NOT CARRIED: the import reads the project, not its media — audio tracks arrive named and positioned (audio.placements lists each clip's file and beats) and audio.next says how to supply the files. Plugins and summing buses are reported, not recreated. Upload first with doseedo_get_project_upload_url; this call parses the project (seconds to minutes for a big one) — if it answers status:"running", call it again with the returned task_id until it hands back session_id.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_instrumentsThe 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 a…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
doseedo_mixMIXING 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.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.<stem>.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: <this job_id>} → 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_mix_presetPOLISH A MIX: a mix preset is a model trained on finished, professionally mixed recordings.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_quoteEstimate what a job will cost in credits BEFORE submitting it, and whether the connected account can afford it right now.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_recipesThe named pipelines people actually ask for — stems, session (mix → DAW project), cover, transcribe, generate, render-midi (your notes played by an instrument model), custom-instru…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
doseedo_reframe_videoREFRAME A VIDEO: the same video in another frame, for where it is posted — 9:16 (stories, reels, shorts), 4:5 (a feed post), 1:1 (square) or 16:9 (a landscape master).Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it REFRAME A VIDEO: the same video in another frame, for where it is posted — 9:16 (stories, reels, shorts), 4:5 (a feed post), 1:1 (square) or 16:9 (a landscape master). fit "fit" (default) keeps the whole picture, centred over a blurred fill of itself, so nothing is cut (captions at the top or bottom of a vertical ad stay); "fill" scales to cover the frame and centre-crops the rest (the report says how much of the picture is kept). The sound is kept as it is (a scored film's mix untouched). Up to 1080 px on the short side (never upscaled past the source's), H.264 MP4. A video already in that frame is copied, not re-encoded. Input: video_key (an upload) or video_url (a doseedo_score_to_picture video as returned, or any public https URL). CPU, no credits. Async: job_id → doseedo_wait_task. Cancel: a re-frame still queued never starts and one running stops within seconds; either way its credit is refunded and the job ends as canceled.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_render_midiMIDI to audio, a virtual instrument: plays a part you wrote.Reads text others write1 finding
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description is 2,087 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...PU (its credits are spent), the job ends as canceled and the output is discarded."
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_render_scorePlays 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): e…Reads text others write1 finding
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description is 2,096 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...PU (its credits are spent), the job ends as canceled and the output is discarded."
Description, as the server wrote it 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 {"<part name or index>": {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" (Solo, "choir:trio", "choir:m2" 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_score_to_pictureSCORE TO PICTURE: the last step of scoring a film.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_separate_stemsSTEM 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 voc…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_session_from_stemsBuild 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 P…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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 <url>, 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_split_soundtrackSPLIT 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 ther…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_spot_videoSPOT A FILM: a video in, the music editor's cue sheet out — the first step of scoring to picture.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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 <reel>M<n>), 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_supervise_cuesMUSIC 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, …Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_tempo_mapScoring 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…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
doseedo_train_instrumentMake 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…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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: <the same 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
doseedo_transcribeAUDIO 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 dose…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: false
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
Only reads 6Show 6 read-only tools
doseedo_desktop_statusIs Dø Desktop running on the user's Mac, and can it put edits into their Logic project?Reads text others writeNo findings
Why it is in this group
- The name "doseedo_desktop_status" says "status": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Is Dø Desktop running on the user's Mac, and can it put edits into their Logic project? Reports which sessions it holds, how it applies edits (apply_mode "reopen" = save, back up, close, apply, reopen), whether macOS lets it (logic_control), each session's last apply (reopen_results) and its applied cursor. Use it to know whether an edit will reach the project now or wait for the next session open. When it is NOT connected the result says how the user gets and pairs the app, and what still works without it. Read-only.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_get_sessionRead a DAW session as the arrangement an agent edits against: every track with its wire ids (track_id t_…, mixer strip channel_id ch_…), regions in BOTH beats and seconds with thei…Reads private dataReads text others writeNo findings
Why it is in this group
- The name "doseedo_get_session" says "get": a word for reading.
What it can reach
- private-dataThe description's first sentence says "read" and "note": it reads notes.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read a DAW session as the arrangement an agent edits against: every track with its wire ids (track_id t_…, mixer strip channel_id ch_…), regions in BOTH beats and seconds with their MIDI notes (i, pitch, velocity, start_beats, duration_beats — i is what edit_midi_notes selects by), mixer (volume with dB, pan, mute), plugins with params[{param_id, name, value}] (set_device_param needs param_id) and sampler {mode, sample_seconds, plays_beats, …}, sends/output as ch_b_… ids, buses, tempo_bpm + tempo_map, time_signature + meter_map, key_signature when known, markers (marker_id, beat ABSOLUTE from bar 1), automation lanes, instrument, counts, length — and `sync` with live_edits:true|false + live_edits_reason (will an edit reach Logic now?). Field-by-field map: doseedo_edit_ops_reference {section:"summary"}. BUDGET (never cut mid-JSON): notes come inline when the selected tracks hold ≤200 notes, else regions carry note_count + notes_omitted:true — pass include_notes:true with tracks:[ids] for a track's notes; include_params:false / include_automation:false drop params / points; a result still too big is paginated by track with `truncated` + `next` (the exact args for the rest). Read-only. Pass the ids straight to doseedo_edit_session, or a track_id to doseedo_render_midi {session_id, track_id}.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_list_jobsList the jobs this account submitted (generate / render_midi / cover / stems / transcribe / session / convert / bounce / the analyses), newest first — to find an earlier result, ch…Reads text others writeNo findings
Why it is in this group
- The name "doseedo_list_jobs" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_list_pluginsList the plugins you can insert on a strip with doseedo_edit_session's add_device op.Reads text others writeNo findings
Why it is in this group
- The name "doseedo_list_plugins" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List the plugins you can insert on a strip with doseedo_edit_session's add_device op. Returns the stock Logic catalog (instruments + effects, always available) and — when Dø Desktop is connected — the actual plugins installed on the user's Mac (stock + third-party). Insert any of them BY NAME: add_device {channel_id, device: {name: "…"}}.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_list_sessionsList the connected account's DAW sessions (most recently updated first) — their ids, names, DAW, and update time.Reads text others writeNo findings
Why it is in this group
- The name "doseedo_list_sessions" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List the connected account's DAW sessions (most recently updated first) — their ids, names, DAW, and update time. Pages with limit + offset (the response carries total and next_offset); name_contains filters by name. Use a session id with doseedo_get_session and doseedo_edit_session; clean up old ones with doseedo_delete_sessions.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
doseedo_wait_taskWait 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.Reads text others writeNo findings
Why it is in this group
- The name "doseedo_wait_task" says "wait": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.
Exfil surface
Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.
No private-data, untrusted-input, outbound path in this server alone: no tool is tagged outbound.
- Reads private data4
- Reads files, mail, messages, databases, secrets, calendars or repositories.
- Reads text others write49
- Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
- Can send data out0
- Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.
Remote posture
What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.
Looked at Nov 20, 2026, 18:37 UTC, unchanged since Nov 20, 2026. No credentials were sent and no tool was called. What is looked at.
- Reachable
- yes
- HTTP status of an anonymous initialize
- 200
- tools/list served without credentials
- yes
- Tools that change things, listed without credentials
- 47
- Protocol version
- 2025-06-18
- WWW-Authenticate on 401
- not observed
- resource_metadata in WWW-Authenticate
- not observed
- RFC 9728 protected resource metadata
- https://api.doseedo.com/.well-known/oauth-protected-resource/mcp
- Authorization servers
- https://api.doseedo.com
- Legacy HTTP+SSE transport
- no
- Dynamic client registration
- yes
- Client ID metadata documents
- yes
- HighThe whole server
The endpoint served tools/list without credentials, and the list has 47 tools that change things (3 destructive, 44 write). Whether a call also works without credentials was not tested: tools are never called.
What this check looks forMatched text
https://api.doseedo.com/mcp: tools/list returned 53 tools to an anonymous client, including doseedo_cancel_job (destructive), doseedo_delete_sessions (destructive), doseedo_edit_session (destructive), doseedo_generate_music (write), doseedo_generate_sound (write) and 42 more
Posture changes
- Nov 20, 2026
- Tools that change things, listed without credentials: 46 to 47
- Nov 13, 2026
- Tools that change things, listed without credentials: 40 to 46
- Nov 6, 2026
- Tools that change things, listed without credentials: 39 to 40
- Oct 29, 2026
- Tools that change things, listed without credentials: 31 to 39
Findings
Matches of fixed checks, with the text they matched.
The server marks "doseedo_analyze_song" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":false,"openWorldHint":true}; The name "doseedo_analyze_song" says "analyze": a word for reading.
The server marks "doseedo_analyze_midi" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":false,"openWorldHint":true}; The name "doseedo_analyze_midi" says "analyze": a word for reading.
The server marks "doseedo_get_project_upload_url" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "doseedo_get_project_upload_url" says "get": a word for reading.
The server marks "doseedo_get_upload_url" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "doseedo_get_upload_url" says "get": a word for reading.
The server marks "doseedo_edit_ops_reference" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "doseedo_edit_ops_reference" says "edit": a word for a change.
The server marks "doseedo_download_session" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "save": a word for a change.
Show 3 more findingsShow fewer
The description is 2,087 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...PU (its credits are spent), the job ends as canceled and the output is discarded."
The description is 2,096 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...PU (its credits are spent), the job ends as canceled and the output is discarded."
The description is 2,046 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "..., output discarded; the credit is refunded only when the conversion itself fails."
History
Changes to its tool definitions and to its remote endpoint, newest first.
PostureRemote posture changed. Tools that change things, listed without credentials: 46 -> 47.View diff
- Tools that change things, listed without credentials: 46 to 47
Tools5 added, 14 changed.+5 added~14 changedView diff
- Added:doseedo_edit_lyricsChanges things
- Added:doseedo_generate_loopChanges things
- Added:doseedo_generatorsChanges things
- Added:doseedo_identify_soundChanges things
- Added:doseedo_mix_presetChanges things
- Changed:doseedo_bounce_sessionChanges thingsdescription
- Changed:doseedo_check_taskChanges thingsinputSchema
- Changed:doseedo_download_sessionChanges thingsdescription
- Changed:doseedo_instrumentsChanges thingsdescriptioninputSchema
- Changed:doseedo_list_jobsOnly readsinputSchema
- Changed:doseedo_mixChanges thingsdescriptioninputSchema
- Changed:doseedo_quoteChanges thingsdescriptioninputSchema
- Changed:doseedo_render_midiChanges thingsinputSchema
- Changed:doseedo_render_scoreChanges thingsdescriptioninputSchema
- Changed:doseedo_score_to_pictureChanges thingsinputSchema
- Changed:doseedo_session_from_stemsChanges thingsinputSchema
- Changed:doseedo_split_soundtrackChanges thingsdescription
- Changed:doseedo_supervise_cuesChanges thingsdescriptioninputSchema
- Changed:doseedo_wait_taskOnly readsinputSchema
PostureRemote posture changed. Tools that change things, listed without credentials: 40 -> 46.View diff
- Tools that change things, listed without credentials: 40 to 46
Tools3 added, 23 changed.+3 added~23 changedView diff
- Added:doseedo_reframe_videoChanges things
- Added:doseedo_split_soundtrackChanges things
- Added:doseedo_supervise_cuesChanges things
- Changed:doseedo_analyze_songChanges thingsdescription
- Changed:doseedo_audio_to_sessionChanges thingsinputSchema
- Changed:doseedo_cancel_jobDeletes or cancelsdescription
- Changed:doseedo_check_taskChanges thingsdescriptioninputSchema
- Changed:doseedo_convert_projectChanges thingsinputSchema
- Changed:doseedo_cover_songChanges thingsinputSchema
- Changed:doseedo_cover_stemChanges thingsinputSchema
- Changed:doseedo_edit_sessionDeletes or cancelsannotations
- Changed:doseedo_fill_gapChanges thingsinputSchema
- Changed:doseedo_generate_musicChanges thingsinputSchema
- Changed:doseedo_generate_soundChanges thingsinputSchema
- Changed:doseedo_get_upload_urlChanges thingsdescriptioninputSchema
- Changed:doseedo_list_jobsOnly readsinputSchema
- Changed:doseedo_mixChanges thingsdescriptioninputSchema
- Changed:doseedo_quoteChanges thingsdescriptioninputSchema
- Changed:doseedo_render_midiChanges thingsdescriptioninputSchema
- Changed:doseedo_render_scoreChanges thingsdescriptioninputSchema
- Changed:doseedo_score_to_pictureChanges thingsdescriptioninputSchema
- Changed:doseedo_separate_stemsChanges thingsinputSchema
- Changed:doseedo_session_from_stemsChanges thingsinputSchema
- Changed:doseedo_spot_videoChanges thingsdescriptioninputSchema
- Changed:doseedo_tempo_mapChanges thingsdescriptioninputSchema
- Changed:doseedo_wait_taskOnly readsinputSchema
PostureRemote posture changed. Tools that change things, listed without credentials: 39 -> 40.View diff
- Tools that change things, listed without credentials: 39 to 40
Tools2 added, 10 changed.+2 added~10 changedView diff
- Added:doseedo_score_to_pictureChanges things
- Added:doseedo_spot_videoChanges things
- Changed:doseedo_check_taskChanges thingsdescriptioninputSchema
- Changed:doseedo_cover_stemChanges thingsinputSchema
- Changed:doseedo_get_upload_urlChanges thingsdescriptioninputSchema
- Changed:doseedo_list_jobsOnly readsinputSchema
- Changed:doseedo_mixChanges thingsdescriptioninputSchema
- Changed:doseedo_quoteChanges thingsdescriptioninputSchema
- Changed:doseedo_render_midiChanges thingsdescriptioninputSchema
- Changed:doseedo_render_scoreChanges thingsdescriptioninputSchema
- Changed:doseedo_tempo_mapChanges thingsdescriptioninputSchema
- Changed:doseedo_wait_taskOnly readsinputSchema
PostureRemote posture changed. Tools that change things, listed without credentials: 31 -> 39.View diff
- Tools that change things, listed without credentials: 31 to 39
Tools6 changed.~6 changedView diff
- Changed:doseedo_cover_stemChanges thingsinputSchema
- Changed:doseedo_generate_musicChanges thingstitledescription
- Changed:doseedo_generate_soundChanges thingsdescription
- Changed:doseedo_mixChanges thingsdescriptioninputSchema
- Changed:doseedo_render_midiChanges thingsinputSchema
- Changed:doseedo_render_scoreChanges thingsdescriptioninputSchema
Tools2 added, 21 changed.+2 added~21 changedView diff
- Added:doseedo_fill_gapChanges things
- Added:doseedo_mixChanges things
- Changed:doseedo_analyze_songChanges thingsdescription
- Changed:doseedo_audio_to_sessionChanges thingsdescription
- Changed:doseedo_beat_gridChanges thingstitledescription
- Changed:doseedo_check_taskChanges thingsinputSchema
- Changed:doseedo_convert_projectChanges thingstitledescription
- Changed:doseedo_cover_songChanges thingsdescription
- Changed:doseedo_cover_stemChanges thingsdescription
- Changed:doseedo_detect_chordsChanges thingsdescription
- Changed:doseedo_edit_sessionChanges thingsdescription
- Changed:doseedo_generate_musicChanges thingstitledescription
- Changed:doseedo_generate_soundChanges thingstitledescription
- Changed:doseedo_instrumentsChanges thingstitledescription
- Changed:doseedo_list_jobsOnly readsinputSchema
- Changed:doseedo_quoteChanges thingsdescriptioninputSchema
- Changed:doseedo_render_midiChanges thingstitledescriptioninputSchema
- Changed:doseedo_render_scoreChanges thingsdescription
- Changed:doseedo_separate_stemsChanges thingstitledescription
- Changed:doseedo_session_from_stemsChanges thingsdescriptioninputSchema
- Changed:doseedo_train_instrumentChanges thingsdescription
- Changed:doseedo_transcribeChanges thingstitledescription
- Changed:doseedo_wait_taskOnly readsinputSchema
Tools4 added, 37 changed.+4 added~37 changedView diff
- Added:doseedo_check_takeChanges things
- Added:doseedo_render_scoreChanges things
- Added:doseedo_session_from_stemsChanges things
- Added:doseedo_tempo_mapChanges things
- Changed:doseedo_accountChanges thingstitle
- Changed:doseedo_add_audio_to_sessionChanges thingstitle
- Changed:doseedo_analyze_midiChanges thingstitle
- Changed:doseedo_analyze_songChanges thingstitle
- Changed:doseedo_audio_to_sessionChanges thingstitle
- Changed:doseedo_beat_gridChanges thingstitle
- Changed:doseedo_bounce_sessionChanges thingstitle
- Changed:doseedo_cancel_jobDeletes or cancelstitle
- Changed:doseedo_check_taskChanges thingstitleinputSchema
- Changed:doseedo_complete_project_uploadChanges thingstitle
- Changed:doseedo_convert_projectChanges thingstitle
- Changed:doseedo_cover_songChanges thingstitle
- Changed:doseedo_cover_stemChanges thingstitle
- Changed:doseedo_create_sessionChanges thingstitle
- Changed:doseedo_delete_sessionsDeletes or cancelstitle
- Changed:doseedo_desktop_statusOnly readstitle
- Changed:doseedo_detect_chordsChanges thingstitle
- Changed:doseedo_download_sessionChanges thingstitle
- Changed:doseedo_edit_ops_referenceChanges thingstitle
- Changed:doseedo_edit_sessionChanges thingstitle
- Changed:doseedo_generate_musicChanges thingstitle
- Changed:doseedo_generate_soundChanges thingstitle
- Changed:doseedo_get_project_upload_urlChanges thingstitle
- Changed:doseedo_get_sessionOnly readstitle
- Changed:doseedo_get_upload_urlChanges thingstitle
- Changed:doseedo_import_projectChanges thingstitle
- Changed:doseedo_instrumentsChanges thingstitle
- Changed:doseedo_list_jobsOnly readstitleinputSchema
- Changed:doseedo_list_pluginsOnly readstitle
- Changed:doseedo_list_sessionsOnly readstitle
- Changed:doseedo_quoteChanges thingstitledescriptioninputSchema
- Changed:doseedo_recipesChanges thingstitle
- Changed:doseedo_render_midiChanges thingstitleinputSchema
- Changed:doseedo_separate_stemsChanges thingstitle
- Changed:doseedo_train_instrumentChanges thingstitle
- Changed:doseedo_transcribeChanges thingstitle
- Changed:doseedo_wait_taskOnly readstitleinputSchema
Install
Pinned to version 0.22.1. Values in angle brackets are yours to fill in.
claude mcp add --transport http doseedo https://api.doseedo.com/mcpclaude mcp add --transport http doseedo https://api.doseedo.com/mcpRun in a terminal.
Claude Code permissions
Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.
{
"permissions": {
"allow": [
"mcp__doseedo__doseedo_wait_task",
"mcp__doseedo__doseedo_list_jobs",
"mcp__doseedo__doseedo_list_sessions",
"mcp__doseedo__doseedo_get_session",
"mcp__doseedo__doseedo_desktop_status",
"mcp__doseedo__doseedo_list_plugins"
],
"ask": [
"mcp__doseedo__doseedo_generate_music",
"mcp__doseedo__doseedo_generate_sound",
"mcp__doseedo__doseedo_generate_loop",
"mcp__doseedo__doseedo_cover_stem",
"mcp__doseedo__doseedo_edit_lyrics",
"mcp__doseedo__doseedo_fill_gap",
"mcp__doseedo__doseedo_render_midi",
"mcp__doseedo__doseedo_train_instrument",
"mcp__doseedo__doseedo_render_score",
"mcp__doseedo__doseedo_mix",
"mcp__doseedo__doseedo_mix_preset",
"mcp__doseedo__doseedo_session_from_stems",
"mcp__doseedo__doseedo_spot_video",
"mcp__doseedo__doseedo_score_to_picture",
"mcp__doseedo__doseedo_reframe_video",
"mcp__doseedo__doseedo_cover_song",
"mcp__doseedo__doseedo_separate_stems",
"mcp__doseedo__doseedo_split_soundtrack",
"mcp__doseedo__doseedo_transcribe",
"mcp__doseedo__doseedo_audio_to_session",
"mcp__doseedo__doseedo_convert_project",
"mcp__doseedo__doseedo_analyze_song",
"mcp__doseedo__doseedo_detect_chords",
"mcp__doseedo__doseedo_beat_grid",
"mcp__doseedo__doseedo_identify_sound",
"mcp__doseedo__doseedo_check_take",
"mcp__doseedo__doseedo_analyze_midi",
"mcp__doseedo__doseedo_supervise_cues",
"mcp__doseedo__doseedo_instruments",
"mcp__doseedo__doseedo_generators",
"mcp__doseedo__doseedo_tempo_map",
"mcp__doseedo__doseedo_get_project_upload_url",
"mcp__doseedo__doseedo_complete_project_upload",
"mcp__doseedo__doseedo_import_project",
"mcp__doseedo__doseedo_get_upload_url",
"mcp__doseedo__doseedo_check_task",
"mcp__doseedo__doseedo_account",
"mcp__doseedo__doseedo_quote",
"mcp__doseedo__doseedo_recipes",
"mcp__doseedo__doseedo_edit_ops_reference",
"mcp__doseedo__doseedo_add_audio_to_session",
"mcp__doseedo__doseedo_bounce_session",
"mcp__doseedo__doseedo_download_session",
"mcp__doseedo__doseedo_create_session"
],
"deny": [
"mcp__doseedo__doseedo_cancel_job",
"mcp__doseedo__doseedo_delete_sessions",
"mcp__doseedo__doseedo_edit_session"
]
}
}Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as doseedo. Review it before you use it.
Capability tags behind 49 rules
- mcp__doseedo__doseedo_generate_music untrusted-input
- mcp__doseedo__doseedo_generate_sound untrusted-input
- mcp__doseedo__doseedo_generate_loop untrusted-input
- mcp__doseedo__doseedo_cover_stem untrusted-input
- mcp__doseedo__doseedo_edit_lyrics untrusted-input
- mcp__doseedo__doseedo_fill_gap untrusted-input
- mcp__doseedo__doseedo_render_midi untrusted-input
- mcp__doseedo__doseedo_train_instrument untrusted-input
- mcp__doseedo__doseedo_render_score untrusted-input
- mcp__doseedo__doseedo_mix untrusted-input
- mcp__doseedo__doseedo_mix_preset untrusted-input
- mcp__doseedo__doseedo_session_from_stems untrusted-input
- mcp__doseedo__doseedo_spot_video untrusted-input
- mcp__doseedo__doseedo_score_to_picture untrusted-input
- mcp__doseedo__doseedo_reframe_video untrusted-input
- mcp__doseedo__doseedo_cover_song untrusted-input
- mcp__doseedo__doseedo_separate_stems untrusted-input
- mcp__doseedo__doseedo_split_soundtrack untrusted-input
- mcp__doseedo__doseedo_transcribe untrusted-input
- mcp__doseedo__doseedo_audio_to_session untrusted-input
- mcp__doseedo__doseedo_convert_project untrusted-input
- mcp__doseedo__doseedo_analyze_song untrusted-input
- mcp__doseedo__doseedo_detect_chords untrusted-input
- mcp__doseedo__doseedo_beat_grid untrusted-input
- mcp__doseedo__doseedo_identify_sound untrusted-input
- mcp__doseedo__doseedo_check_take untrusted-input
- mcp__doseedo__doseedo_analyze_midi private-data, untrusted-input
- mcp__doseedo__doseedo_supervise_cues untrusted-input
- mcp__doseedo__doseedo_get_project_upload_url private-data, untrusted-input
- mcp__doseedo__doseedo_complete_project_upload untrusted-input
- mcp__doseedo__doseedo_import_project untrusted-input
- mcp__doseedo__doseedo_get_upload_url private-data, untrusted-input
- mcp__doseedo__doseedo_check_task untrusted-input
- mcp__doseedo__doseedo_wait_task untrusted-input
- mcp__doseedo__doseedo_list_jobs untrusted-input
- mcp__doseedo__doseedo_cancel_job untrusted-input
- mcp__doseedo__doseedo_account untrusted-input
- mcp__doseedo__doseedo_quote untrusted-input
- mcp__doseedo__doseedo_list_sessions untrusted-input
- mcp__doseedo__doseedo_delete_sessions untrusted-input
- mcp__doseedo__doseedo_get_session private-data, untrusted-input
- mcp__doseedo__doseedo_edit_session untrusted-input
- mcp__doseedo__doseedo_edit_ops_reference untrusted-input
- mcp__doseedo__doseedo_desktop_status untrusted-input
- mcp__doseedo__doseedo_add_audio_to_session untrusted-input
- mcp__doseedo__doseedo_bounce_session untrusted-input
- mcp__doseedo__doseedo_download_session untrusted-input
- mcp__doseedo__doseedo_list_plugins untrusted-input
- mcp__doseedo__doseedo_create_session untrusted-input
Pin
Keep the decision: fail CI when the tools change, follow every change, or show a badge.
Pin in CI
Fail a build when the tools you reviewed are not the tools the server serves today.
curl -s "https://radar.anlyon.com/api/v1/servers/com.doseedo/doseedo/verify?hash=6e1a39b2ca0b713bcb8c8cb87918702165e9bcc0a518ec1ce858cd4e7f8e43da" | jq -e '.changed == false'Pinned hash 6e1a39b2ca0b, from Nov 17, 2026, 23:17 UTC.
Watch
Get told when its tools change: a new tool, a new description, a new class.
https://radar.anlyon.com/servers/com.doseedo/doseedo/changes.xmlAn Atom feed. Works in any feed reader or Slack's RSS app.
Badge
[](https://radar.anlyon.com/servers/com.doseedo/doseedo)Source: MCP Registry. Synced Nov 17, 2026, 23:17 UTC.
Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server: questions and answers
Answered from the scan above, not from the publisher's description.
Is the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server safe?
- No scan can promise that. What its definitions show: 53 tools, 47 of which can change, send or delete something, and 9 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.
Can the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server delete data?
- Yes. 3 tools can delete, cancel or revoke something: doseedo_cancel_job, doseedo_delete_sessions and doseedo_edit_session.
Can the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server do things that cannot be undone?
- No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.
What tools does the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server have?
- 53 tools: 3 destructive, 44 write, 6 read. doseedo_cancel_job, doseedo_delete_sessions, doseedo_edit_session, doseedo_generate_music, doseedo_generate_sound, doseedo_generate_loop, doseedo_cover_stem, doseedo_edit_lyrics and 45 more.
Does the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server need sign-in or OAuth?
- Its remote endpoint listed its tools to an anonymous client, without sign-in.
Does the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server send data to outside services?
- None of its tools sends, posts or publishes, or takes a recipient, channel or URL.
Has the Doseedo: Film Scoring, AI Instruments, Sound Effects & Stems MCP server changed its tools?
- Yes, 7 times since Anlyon Radar started tracking it, most recently on Nov 17, 2026. Every change is on this page and in its Atom feed.