Doseedo
Music and audio for AI agents: score a film or video to picture (a cue sheet from the cut, hit points on downbeats, the score laid on the video under the dialogue), play your MIDI and scores on 50+ AI instruments with a stem per part, sound effects, stem separation, audio to MIDI, and Logic Pro or Ableton Live sessions. Hosted, OAuth.
Hosted MCP Server
npx add-mcp 'https://api.doseedo.com/mcp'Installs into Claude Code, Codex, Cursor and more
Documentation
Music and audio tools for your AI agent.
The Doseedo MCP server is a hosted Model Context Protocol endpoint at api.doseedo.com/mcp: 45 tools that give an AI agent music and audio: 50+ AI instruments that play the MIDI it writes, sound effects and foley, stem separation (a vocal remover too), audio to MIDI, mixing, and a DAW. Connect it once, from Claude on your phone or in Claude Code, from ChatGPT, Cursor, Gemini CLI, OpenAI Codex or VS Code, and the agent can read and edit your DAW sessions: move and trim regions, rewrite MIDI, change the mixer, insert plugins, set tempo. With Dø Desktop running on your Mac, those edits go into your Logic Pro project: it saves the project, keeps a backup, closes it, writes the edits and reopens it, in about 10–20 seconds. It also opens and converts projects across ten DAW formats (Logic Pro, Ableton Live, FL Studio, Pro Tools, REAPER, Cubase, Dorico, Studio One, Bitwig and GarageBand), turns a mix into a session, separates stems, transcribes, and generates. No SDK, no local server for the MCP itself.
Session players: a sound palette for agents
An agent can write music as notes; it has no way to make them sound like a player. This is that half. doseedo_instruments is the catalog: 50+ instruments, from orchestral strings, brass and winds to guitars, basses, keys, drums and percussion, and World instruments such as koto, sitar, banjo, shamisen and pedal steel. Each entry carries the exact call that plays it, its range in concert pitch, whether one player can hold chords, its presets (pizz, muted, the four sax registers) and a demo render. The agent writes the part, and doseedo_render_midi performs it: your exact notes at your tempo, one player per part, every part its own stem, by instrument models trained on isolated instrument tracks from real recording sessions. A name it doesn't know is answered with did_you_mean before anything is charged, and notes outside the instrument's range come back flagged with a fix. The catalog answers before you sign in, and so does the price (doseedo_quote: ten credits per 30 seconds of audio).
Bring your own sound. When the catalog doesn't have it, the agent makes it. doseedo_train_instrument turns 30 seconds to 3 minutes of a recording of one instrument (a rare or folk instrument, your own player, a prepared or invented one) into a custom instrument in about one to two minutes, private to your account; every later render_midi with its lora_id plays any notes in that sound. For a one-off, timbre transfer: pass any recording as timbre_audio_url and your notes take on its tone, or hand a recorded line (humming, a whistled tune, a guitar riff) to doseedo_cover_stem and get it back on another instrument. And for everything that isn't a note, doseedo_generate_sound does sound design and foley: impacts, whooshes, door slams, footsteps, UI sounds, ambiences, risers, drum one-shots.
Score a video. doseedo_spot_video watches a film and returns the cue sheet: every cut frame-exact, each shot with a keyframe, where the dialogue is, and cues with SMPTE in and out, hit points and a tempo. doseedo_score_to_picture lays the finished cues back on it at their timecodes, ducks the music under the dialogue, normalises to a delivery loudness and muxes it onto the untouched picture, then reports what it measured. Neither spends credits. A film-only server, listing only what that loop calls, is at api.doseedo.com/mcp/film. Watch a film an agent scored this way, with every call and receipt.
Whole scores, and scoring to picture. doseedo_render_score plays a whole arrangement in one call (parts the agent wrote, a multi-track MIDI file or a MusicXML export, with dynamics and articulations performed) and returns a stem per part, a mix, and a receipt for each part saying whether it played its notes. doseedo_session_from_stems turns that into a Logic Pro or Ableton Live project. doseedo_tempo_map turns hit points or SMPTE timecodes into a tempo map that lands every hit on a downbeat, and every render_midi take comes back measured against the notes (doseedo_check_take measures any take). The whole loop, from the cut to the scored film, is in Score a film with an AI agent.
Install: one URL, every client
Register https://api.doseedo.com/mcp as a remote (Streamable HTTP) MCP server. That is the whole install, in every client; the one-line versions are below, and each name links to the page for that client.
| Client | How the URL is registered |
|---|---|
| Claude Code | claude mcp add --transport http --scope user doseedo https://api.doseedo.com/mcp |
| Claude (phone, web, Desktop) | Settings → Connectors → Add custom connector → paste the URL, sign in once |
| ChatGPT | Plugins → Add custom MCP server → the URL, authentication OAuth |
| Cursor | ~/.cursor/mcp.json → {"mcpServers":{"doseedo":{"url":"…/mcp"}}} |
| Gemini CLI | gemini mcp add --transport http -s user doseedo https://api.doseedo.com/mcp |
| OpenAI Codex | codex mcp add doseedo --url https://api.doseedo.com/mcp |
| VS Code (Copilot agent mode) | .vscode/mcp.json → {"servers":{"doseedo":{"type":"http","url":"…/mcp"}}} |
Every client meets the same server. The first real tool call answers with an OAuth challenge and the client opens a browser to doseedo.com/mcp-authorize; you sign in, approve, and the grant appears under Settings → API keys as MCP · <client>. A client that can send headers can skip the browser with X-API-Key: dsk_live_… instead.
Claude Code, spelled out: one command, OAuth, the first tool call opens a browser to sign in and approve:
claude mcp add --transport http --scope user doseedo https://api.doseedo.com/mcp
Or headless, with an API key from Settings → API keys, for CI, servers, or clients without a browser:
claude mcp add --transport http --scope user doseedo https://api.doseedo.com/mcp \
--header "X-API-Key: dsk_live_..."
The companion skills install with npx skills add doseedo/skills (Claude Code, Cursor, Codex and the other agents that read skills) and teach the agent the recipes before it calls a tool.
The point
You're away from your desk. You open Claude or ChatGPT on your phone, say "in my session, shorten the intro and pull the vocal up 2 dB," and when you're back at your Mac it's already done in Logic: Dø Desktop saved the project, kept a backup, wrote the edit in and reopened it. That's what this connects.
What the agent gets
45 tools in six families: session control (read and edit the sessions in your account); projects (import, convert, build); audio and music (AI instruments, sound effects, generate, separate, transcribe, mix); scoring to picture (spot a video, lay the score on it); analysis (key, tempo, chords, free and instant); and the plumbing of uploads, jobs and cost. The highlights are below; the reference has all 45.
| Tool | What it does |
|---|---|
| doseedo_list_sessions | List the sessions in your account: names, ids, DAW. |
| doseedo_get_session | Read a session as an arrangement: every track with its ids, its regions in beats and seconds, mixer levels (with dB), plugin chain, tempo, markers, plus whether Dø Desktop is connected to it right now. |
| doseedo_edit_session | Apply a list of edits: move/trim a region, rewrite MIDI notes, add or delete a track, set a fader/pan/mute, insert or tweak a plugin, change tempo, add a marker. With Dø Desktop running they go into your Logic project: it saves, backs up, closes and reopens the project, about 10–20 seconds; otherwise they persist and apply next time the session opens. |
| doseedo_bounce_session | Print tracks to audio through their real plugin chains, offline. Dø Desktop renders them in the background without you opening the DAW (stock plugins can't do this). Returns downloadable stems. |
| doseedo_add_audio_to_session | Drop a generated song or a separated stem straight onto a session, ready to place on a track. |
| doseedo_desktop_status | Is Dø Desktop running and connected to your DAW, which sessions it holds, how far it has applied, read-only. |
| doseedo_import_project | Open an uploaded Logic, Ableton, FL Studio, REAPER or Pro Tools project as an editable session, the way into edit_session for a project that already exists. |
| doseedo_download_session | Save the session to your device as a native .logicx, rebuilt server-side, no desktop needed. Returns a short-lived, no-auth link, so the agent drops it straight into your Downloads with a plain curl -o (no key, no header). |
| doseedo_list_plugins | The plugins you can insert by name: the stock Logic catalog always, plus the plugins installed on your Mac when Dø Desktop is connected. |
| doseedo_convert_project | Convert a complete project between ten DAW formats: all 75 directions (Logic Pro, Ableton Live, FL Studio, Pro Tools, REAPER, Cubase, Dorico, Studio One, Bitwig and GarageBand in), rebuilt natively. Tracks, MIDI, audio, tempo and markers arrive editable; the Logic, Ableton, Pro Tools and REAPER pairs also carry automation, buses/sends, stock-plugin settings and third-party plugin state. |
| doseedo_audio_to_session | A full mix in, a native Logic or Ableton session out: separated stems on named tracks, tempo map, optional per-stem MIDI and a chord guide. |
| doseedo_separate_stems | Split a mix into isolated stems (vocals, drums, bass, melodic parts), sample-accurate. Also the vocal remover: the vocals stem is the acapella, the rest is the karaoke backing. |
| doseedo_transcribe | Audio to MIDI: audio in, editable notes out, per-instrument models behind one surface. |
| doseedo_generate_sound | Sound effects and foley from a description: impacts, whooshes, footsteps, UI sounds, ambiences, risers, drum one-shots and loops. |
| doseedo_generate_music / doseedo_cover_song | Generate a song from a text brief (lyrics optional), or re-render an uploaded song with instruments swapped, a genre changed or new lyrics. |
| doseedo_instruments | The instrument catalog, the sound palette: 50+ instruments with the call that plays each, its range, chords or not, presets and a demo render; searchable by a brief or by the pitches a part uses. Answers without a credential. |
| doseedo_render_midi | Your exact notes, played by a modelled instrument at your tempo, up to four takes per call, a timbre preset, a reference recording (timbre transfer) or your own trained instrument, a voice split for chords. The tool for a part that has to fit a session. |
| doseedo_render_score / doseedo_session_from_stems | A whole score in one call: every part on its instrument, a stem each plus a mix, each part checked against its notes; then the stems, the parts as MIDI and the tempo map as a native Logic Pro or Ableton Live project. |
| doseedo_mix | Mixing and mastering: the stems levelled, panned, seated in a shared reverb and mastered to a loudness target, returned as a WAV and as an editable mix. |
| doseedo_train_instrument | A custom instrument from 30 s – 3 min of a recording of it, trained in about one to two minutes and private to your account; render_midi then plays any notes on it. |
| doseedo_cover_stem / doseedo_generate_sound | A recorded line played back by another instrument (timbre transfer from audio); sound design and foley from a description: hits, loops, textures. |
| doseedo_tempo_map / doseedo_check_take | Hit points or SMPTE timecodes into a tempo map that lands each hit on a downbeat (answers without a credential); a take measured against the notes it should play: notes heard, timing, loudness, a verdict. Both cost no credits. |
| doseedo_analyze_song / doseedo_detect_chords / doseedo_beat_grid / doseedo_analyze_midi | Key, tempo map, meter, downbeats, sections, chords of a recording; the beat grid; the harmony of notes you wrote. Synchronous and free, the grid an agent writes against. |
| doseedo_quote / doseedo_recipes | What a job will cost before it runs, and the fourteen named pipelines (stems, session, cover, transcribe, generate, render-midi, score, custom-instrument, timbre-transfer, sound-design, analyze-song, convert, import-edit-export, bounce). Both answer without a credential. |
| doseedo_account | Plan tier and remaining credits, read-only. |
Async jobs (generation, a session build, a bounce) follow one shape: the submit tool returns a job_id, and doseedo_wait_task polls it. Finished artifacts come back as plain https download URLs. The agent fetches them with curl, no auth needed on the download.
How an edit reaches your DAW
This is the part that wasn't possible before. Logic has no automation API: you can't script it. Dø Desktop bridges that gap:
- Claude (or ChatGPT, or any MCP client) calls
doseedo_get_sessionto see the arrangement, thendoseedo_edit_sessionwith the edits; those land in the cloud session and the edit log. - Dø Desktop, running on your Mac, is subscribed to that session. For each batch of edits it saves your Logic project (your unsaved work included), keeps a backup copy in
~/Music/Logic/Dø Desktop Backups/<project>/(the last 20 are kept), closes it, writes the edits into the.logicxand reopens it, about 10–20 seconds. If the project isn't open, the edits are written straight into the file. A notification after each apply offers Undo, which restores the backup. - If the desktop is closed, nothing is lost: the edits are saved and applied the next time that session opens.
doseedo_get_session's sync block tells the agent which case it's in, so it always knows whether the change has reached the project yet.
The one requirement for edits reaching your Logic project is the latest Dø Desktop running on the Mac. The first time, macOS asks to let Dø Desktop control Logic (Accessibility): click Allow in Dø Desktop; until then, edits wait while the project is open. It is not real-time and not a remote control: there is no transport, and the project closes and reopens. Everything else (reading, editing the stored session, bouncing, downloading a project) works with nothing but the connector. Bounces run whenever the desktop next runs, live through Logic if it's open or headless if it isn't.
Which DAWs, and how far
One server, but the DAWs are not in the same position, and the page for each says exactly where the line is:
| DAW | What the agent can do |
|---|---|
| Logic Pro | Everything: read and edit sessions, edits written into the project through Dø Desktop (it saves, closes and reopens it), offline bounce through real plugins, native .logicx download, import, convert, build from a mix. |
| Ableton Live | Build a set from a mix, import an .als as a session and edit it, convert in and out, read it with Live closed. Not driven live. That is AbletonOSC territory. |
| FL Studio | Import an .flp as a session, convert in and out, read it with FL closed. Session building reaches FL by one conversion hop. |
| Pro Tools | Import a .ptx, convert to and from nine other formats, read it with Pro Tools closed. Realtime control stays with Avid's own Scripting SDK. |
| REAPER | Import an .rpp, convert in and out, and use REAPER's plain-text format as the intermediate for restructuring any other DAW's project. ReaScript keeps realtime control. |
| Studio One | Read a .song directly and convert it to six other DAWs; projects come into Studio One (and Fender Studio Pro) as a .dawproject. Not driven live: Studio One has no public scripting API. |
| Cubase | Read a .cpr 's tracks, tempo and MIDI parts and convert them out; projects come in as a .dawproject Cubase 14 and Nuendo open. Live control stays with the MIDI Remote API. |
| Bitwig Studio | Convert a Bitwig .dawproject export to seven formats and write .dawproject files Bitwig opens. The Controller API keeps realtime control. |
| GarageBand | Read a .band, export its MIDI, convert it to seven formats. Source only, and nothing drives GarageBand live: it has no API. |
| Dorico | Conversion both ways through MusicXML, as part of the 75 directions. |
Auth and metering: nothing new to learn
OAuth access tokens are ordinary dsk_ API keys; approving a client just mints one scoped to it. Every call is metered exactly like using the site: same quotas, same credits, and failed jobs refund. Revoke any client from Settings → API keys, where OAuth grants appear as MCP · <client name>. There is no separate MCP pricing and no separate account.
Design, briefly
Stateless Streamable HTTP: plain JSON-RPC over POST, no session ids, no server-initiated streams, so it works from short-lived processes and CI. Long jobs follow one async shape everywhere: submit returns a task_id, doseedo_wait_task polls server-side and tells the agent to call again if the job is still running. The endpoint lives on the same edge as the API, and the full HTTP surface behind the tools is documented in the docs.
FAQ
What is the Doseedo MCP server?
A hosted Model Context Protocol endpoint at api.doseedo.com/mcp. Any MCP client (the Claude phone and web apps, Claude Desktop, Claude Code, ChatGPT, Cursor, Gemini CLI, OpenAI Codex, VS Code) connects with one URL and gets music and audio tools: 50+ AI instruments that play the MIDI it writes, sound effects and foley, stem separation, audio to MIDI, mixing. It can also read and edit the DAW sessions in your account, convert projects across ten DAW formats and build sessions from audio. 45 tools. The MCP itself runs nothing on your machine.
Does it work with ChatGPT, Cursor, Gemini CLI or Codex?
Yes. It is a remote Streamable HTTP server with OAuth, which is what those clients expect: ChatGPT adds it as a custom MCP server (OAuth; it has no header field), Cursor and VS Code take one mcp.json entry with the URL, Gemini CLI uses gemini mcp add --transport http, Codex uses codex mcp add --url. The first real tool call opens the sign-in; headless clients send an X-API-Key header instead.
Can Claude or ChatGPT actually edit my Logic project while it's open?
Yes, with the latest Dø Desktop running on your Mac. An edit Claude or ChatGPT makes through the connector (move a region, rewrite MIDI, change a fader, insert a plugin) goes into your Logic project: Dø Desktop saves the project (your unsaved work included), keeps a backup, closes it, writes the edits and reopens it, about 10–20 seconds per batch, and the notification offers Undo. It is not real-time: the project closes and reopens. If the desktop is closed the edits persist and apply the next time the session opens; the agent can see which case it's in. This is real session editing, not the old convert-and-reimport workaround.
Can I use it from my phone?
Yes. Add https://api.doseedo.com/mcp as a custom connector in the Claude iOS/Android app (or on claude.ai), or as a custom MCP server in ChatGPT, sign in once, and you can drive your sessions from anywhere. As long as Dø Desktop is running on your Mac, the edits go into the Logic project there; otherwise they're queued and applied at next open.
Can it bounce my tracks through third-party plugins without opening the DAW?
Yes, doseedo_bounce_session queues an offline print, and Dø Desktop renders each track through its real plugin chain in the background: live via Logic if it's open, headless if it isn't. Stock DAWs can't do a headless bounce through your installed plugins; this can. The result is downloadable stem files.
Which DAWs does it support?
Putting edits into your Logic project and bounce target Logic Pro today (the Dø Desktop bridge). Reading, building and converting cover Logic Pro (.logicx), Ableton Live (.als), FL Studio (.flp), Pro Tools (.ptx) and REAPER (.rpp), plus Cubase (.cpr), Dorico (MusicXML), Studio One (.song), Bitwig (.dawproject) and GarageBand (.band, in), with conversion in all 75 directions.
How is it authenticated and billed?
OAuth (approve once) or a dsk_ API key from Settings → API keys. Calls are metered exactly like using the site: same quotas, same credits, revocable per key.
The Doseedo MCP server · one URL, every client
By DAW
- Logic Pro edits written into your project
- Ableton Live build, read, convert.als
- FL Studio read, convert.flp
- Pro Tools move.ptx between DAWs
- REAPER read, edit, convert.rpp
- Studio One read.song, write.dawproject
- Cubase read.cpr, write.dawproject
- Bitwig Studio.dawproject both ways
- GarageBand read.band, export MIDI
By AI client
- Any AI agent what works today
- Claude & Claude Code phone, desktop, terminal
- ChatGPT as a custom MCP server
- Cursor mcp.json, one entry
- Gemini CLI gemini mcp add
- OpenAI Codex codex mcp add
- VS Code Copilot mcp.json, type http
By capability
- All 45 tools the reference
- Convert projects ten DAW formats, 75 directions
- Separate stems vocals, drums, bass, more
- Audio to MIDI transcription, chords, key
- Generate music songs, parts, covers
- Render MIDI your notes, 50+ AI instruments
- Custom instruments trained from a recording
- Sound effects hits, loops, textures
- Score a film cut in, scored video out
- A film, scored Big Buck Bunny, every call
- Film scoring tools compared sourced, honest
- Bounce offline through real plugins
- Swap a drum pack audio stays local
Read next
- Control your DAW with an AI agent: what works today
- Logic Pro MCP server: letting Claude edit your session
- Ableton Live MCP server: what an agent can actually do
- Bounce stems without opening your DAW
- Swap a project onto a new drum pack
- FL Studio MCP server: what an agent can do with.flp
- Pro Tools MCP server: moving.ptx between DAWs
- REAPER MCP server:.rpp as the text intermediate
- Studio One MCP server:.song in,.dawproject out
- Cubase MCP server: what a.cpr carries
- Bitwig MCP server: DAWproject both ways
- GarageBand MCP server: the.band as a source
- Control your DAW with ChatGPT
- Control your DAW from Cursor
- MIDI to realistic instrument audio, for AI agents
- Score a film with an AI agent
- Big Buck Bunny, scored by an AI agent
- AI film scoring tools compared
- A custom AI instrument, trained from a recording
- Sound effects and foley from an AI agent