OtoMaker
OfficialDownloads the Stable Audio 3 model files (small sfx/music models and the larger medium music model) from public Hugging Face model repositories into the Hugging Face cache, making them available to the local generation runtime.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@OtoMakergenerate a chill lo-fi loop at 80 bpm and make it seamless for my game"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
OtoMaker for Windows
OtoMaker is a free, local MCP server for Windows. Ask Claude Code, Claude Desktop, Cursor or any other MCP client for background music or a sound effect in plain language. The model (Stable Audio 3) generates it on your PC. The server can then loop it, normalize the loudness and export WAV, OGG or FLAC for a game engine or video editor.
Platform: Windows 10 / 11
Runs on the CPU by default. An NVIDIA GPU with ComfyUI is faster and optional.
Instrumental only. Stable Audio 3 cannot produce intelligible vocals or lyrics.
Installing with an AI assistant (Claude Code and others): ask it to follow INSTALL_FOR_AI.md.
Tools
Tool | What it does |
| Text to BGM, instrument loop/stem or sound effect. 1–4 candidates per call, |
|
|
| Trim, trim silence, mono, resample, loudness (LUFS) or peak normalization, seamless loop, fades, WAV / OGG / FLAC export. Never modifies the input |
| Free the model memory right away |
Generated files are 44.1 kHz 24-bit stereo WAV in outputs\ under the OtoMaker data folder (the OtoMaker folder itself with install.cmd, %LOCALAPPDATA%\OtoMaker with uvx). Each one has a <file>.json sidecar (for example rain.wav.json) with its prompt, seed, settings and the file paths involved. Paths under your user profile are written as %USERPROFILE%. Other paths are written as they are: if the output folder (OTOMAKER_OUTPUT_DIR) or an input file is in a folder outside your profile whose name contains your name, that name ends up in the .json.
Related MCP server: That's one sentence; but the instruction is no more than 2 sentences, so 2 is fine. Let me make it two sentences for clarity.
Requirements
Windows 10 or 11 and an internet connection (for the installation and the model download)
ffmpeg, used for resampling and loudness. For example:
winget install --id Gyan.FFmpeg -e. Ifffmpegis not onPATH, setOTOMAKER_FFMPEGto the full path offfmpeg.exe. The installer tells you when it cannot find it.Optional: an NVIDIA GPU with a running ComfyUI, for the
sa3-comfybackend.
You do not need to install Python, uv or Git first: install.cmd sets them up inside the OtoMaker folder. The Stable Audio 3 runtime and the model files are not included in this package; they are downloaded during the installation.
Folder names with Japanese or other non-ASCII characters (for example under a Japanese user name) are fine. The TFLite runtime cannot open such paths itself, so OtoMaker hands it ASCII forms of them (the 8.3 short name, or a path relative to the runtime folder).
You do not need a Hugging Face account or token. The model repositories are public.
Installation (install.cmd)
Extract the zip (for example to
C:\Tools\OtoMaker). It cannot run from inside the zip.Double-click
install.cmdin the extracted folder. It goes through these steps:uv: uses the uv on
PATH. If there is none, it downloads a pinned version of the official build (astral-sh/uv GitHub Releases), checks its SHA256 and puts it inruntime\uv\.Python 3.12 and the dependencies: runs
uv sync --locked --extra tflite --no-dev, with a uv-managed Python inruntime\python\.The Stable Audio 3 runtime: downloads the archive of the tested commit
77e0398from GitHub, checks its SHA256 and extracts it tostable-audio-3\optimized\tflite.Models: you pick the models (
sfxandmusicare recommended). The file list and the license terms are shown; typeyto agree and download.MCP registration: asks (Y/N each) whether to register
otomakerwith Claude Desktop (%APPDATA%\Claude\claude_desktop_config.json) and Claude Code (claude mcp add --scope user). The Claude Desktop config is backed up as.bak-<date-time>before the change; onlyotomakeris added undermcpServers, everything else stays as it was. If you use OpenAI Codex (%USERPROFILE%\.codex\config.tomlor that folder exists, or thecodexcommand is found;CODEX_HOMEis honored), it also asks whether to add[mcp_servers.otomaker]toconfig.toml, withtool_timeout_sec = 300because a generation takes 30-60 s. The file is backed up the same way, and only that table is added or replaced; other settings and comments stay.
Restart Claude (and Codex). Quit Claude Desktop from its tray icon, then start it again.
The installer does not change PATH or any system setting. uv, Python and the package cache all stay inside the OtoMaker folder (runtime\, .venv\, stable-audio-3\). Only the model files go to the Hugging Face cache (see below). Running install.cmd again sets up only what is missing.
Get models later: double-click
download-models.cmd. Until a model is downloaded, a generation with it stops and names the command to run.Remove the registration: double-click
uninstall.cmd. It removesotomakerfrom Claude Desktop, Claude Code and Codex (Y/N each). It does not delete the folder or the models; delete the places it lists yourself if you no longer need them. Your generated audio (outputs\) is in the folder too.Other clients (Cursor and others): put the full path of
<OtoMaker folder>\.venv\Scripts\otomaker-mcp.exeas"command"in their MCP config.
Manual setup (CPU, sa3-tflite)
The steps without install.cmd. They use uv and Git.
In the OtoMaker folder, get the Stable Audio 3 runtime (Stability-AI/stable-audio-3, MIT). OtoMaker was tested with commit
77e0398. Later commits may change the internals that OtoMaker uses.cd C:\Tools\OtoMaker git clone https://github.com/Stability-AI/stable-audio-3.git cd stable-audio-3 git checkout 77e0398 cd ..The runtime is now at
<OtoMaker folder>\stable-audio-3\optimized\tflite, where OtoMaker looks by default. If you put it somewhere else, setOTOMAKER_SA3_TFLITE_DIRto itsoptimized\tflitefolder.Install the dependencies, including the TFLite extra.
--no-devleaves out the test tools:uv sync --extra tflite --no-devDownload the models you want:
sfx(small sound-effect model) andmusic(small music model), both up to 120 s, ormedium(larger music model, up to 380 s).allgets all three. The text encoder that all models share is added once. The command lists the files and their sizes, shows the license terms and asks you to agree (y).--accept-licensesagrees without asking (only if you have read the terms; without it and without a terminal, nothing is downloaded).--models sfx,musicis the same as listing the names.--dry-runonly lists the files. If the runtime (step 1) is missing, the command also fetches it (the same pinned commit and SHA256 check asinstall.cmd)..venv\Scripts\otomaker-download.exe sfx musicIf you skip this step, a generation stops with the command to run.
OTOMAKER_SA3_AUTO_DOWNLOAD=1lets the runtime download the files on first use instead.Register the server with Claude Code (replace the path with yours):
claude mcp add --scope user otomaker -- "C:\Tools\OtoMaker\.venv\Scripts\otomaker-mcp.exe"If the runtime is not in the default place, add
-e OTOMAKER_SA3_TFLITE_DIR=<path>. Claude Desktop, Cursor and other clients take the same command in their MCP config, as"command"with the path tootomaker-mcp.exe.
otomaker-mcp.exe talks to the client over stdio. With --http PORT it serves streamable HTTP at http://127.0.0.1:PORT/mcp instead (reachable from this PC only), for clients that connect by URL. --preload loads the models at startup, so the first request does not wait for them.
Where the model files go, and disk space. The files are downloaded into the Hugging Face cache (HF_HOME, by default %USERPROFILE%\.cache\huggingface) and made visible in the runtime's models\ folder. With Windows Developer Mode on, this is a symbolic link. Without it, it is a hard link if both folders are on the same drive, and otherwise a full copy, which uses the space twice. To avoid the copy, keep the OtoMaker folder on the same drive as HF_HOME, or set HF_HOME to a folder on that drive. On first use the runtime also writes a weight cache (.xnnwc) next to each DiT and codec model, almost as large as the model itself. Measured on a test PC with hard links: about 1.8 GB for music alone, about 1.0 GB more for each further small model, and about 3.2 GB more for medium. A copy adds the download size once more (1.25 GB for music alone).
Setup (GPU, sa3-comfy)
sa3-comfy sends each request to a ComfyUI that you run yourself, at OTOMAKER_COMFY_HOST (default 127.0.0.1:8188, ComfyUI's own default). This backend supports text-to-audio only (no edit_audio). Set OTOMAKER_BACKEND=sa3-comfy. To fall back to the CPU when ComfyUI is not running, also set OTOMAKER_FALLBACK=sa3-tflite. The result and its metadata record the fallback.
Download the ComfyUI files from Comfy-Org/stable-audio-3. The medium checkpoint is 9.2 GB, each small one 2.3 GB and the text encoder 1.2 GB. The files go into
checkpoints\andtext_encoders\under--comfy-dir:.venv\Scripts\otomaker-download.exe sfx music --comfy --comfy-dir C:\path\to\ComfyUI\modelsIf
--comfy-dirwas ComfyUI's ownmodelsfolder, you are done. For any other folder, opentools\comfy_extra_paths.yamland copy itsotomaker:block into theextra_model_paths.yamlof your ComfyUI (next to itsmain.py; if the file does not exist, copyextra_model_paths.yaml.exampleto that name first). Setbase_pathto your folder and restart ComfyUI.
By default unload_models and the idle unload do not touch ComfyUI's memory, because ComfyUI's /free unloads every model in it, including the models of other tools. Set OTOMAKER_COMFY_FREE=1 to send /free.
Configuration
Variable | Default | Meaning |
|
|
|
| off | Backend for a |
| the OtoMaker folder; | Data folder: the runtime and |
|
| The |
|
|
|
|
|
|
| the upstream pairing |
|
|
|
|
| physical cores, at most 10 | CPU threads for the TFLite runtime. Cores are counted with psutil, which the |
|
| Address of ComfyUI ( |
|
|
|
|
|
|
|
| Where audio files are written |
|
| Free the models after this many idle minutes ( |
|
| Full path to |
|
| Hugging Face cache for the model downloads |
Pass them with claude mcp add ... -e NAME=value, or in the env block of your client's MCP config.
Prompting tips
Write English, one or two sentences, up to about 45 words. Avoid vocal words such as "vocals", "singer" or "lyrics".
Music: genre and adjectives, then lead instruments, supporting layers, drums and mood. Put the tempo in
bpm.Sound effects: fill in
sound_source,sound_action,sound_materialandsound_space. The server adds the prefix the model was trained with.Match the length to the content: impacts 1–3 s, actions 3–6 s, ambience 6–15 s, loops 6–20 s, full tracks 120–300 s.
Timing instructions such as "climax at 15 s" are not followed reliably. Generate first, then use
edit_audiowithinpaintorcontinue.Results vary a lot by seed. Ask for 2–4
variationsand pick the best.
Peak normalization uses a safety ceiling: peak_ceiling_db (default −1) turns down louder peaks and never boosts quieter audio. Use process_audio to normalize loudness. For OGG output, process_audio reports the levels measured on the encoded file.
Development
This section is for developers. Install with the test tools and run the offline tests:
uv sync --extra tflite
uv run --extra tflite pytest -qThe offline tests use a fake backend, so they need neither the runtime nor the weights. The git repository also has scripts\smoke_test.py, a developer check that runs every tool once over stdio against the real model. It is not part of the distributed zip.
src\otomaker\
server.py MCP tools (backend-independent)
prompts.py prompt building and the instructions sent to clients
post.py post-processing and export
download.py otomaker-download (model files)
backends\base.py backend interface
backends\sa3_tflite.py Stable Audio 3 on the CPU (TFLite / LiteRT)
backends\sa3_comfy.py Stable Audio 3 through ComfyUIFAQ
Does it work without an NVIDIA GPU? Yes. The default backend runs on the CPU. Generation is slower than with a GPU and ComfyUI.
Can it make songs with vocals? No. Stable Audio 3 generates instrumental music and sound effects.
Do I need a Hugging Face token? No. The model files are public.
My loop clicks at the seam. Use WAV or OGG for loops. MP3 adds padding at the start and end. Try a longer loop_crossfade_ms, or ask for a cut on a bar line.
License and notices
The full notices are in NOTICE.
This project: MIT. Copyright (c) 2026 kanaworksai-hue (original code), Copyright (c) 2026 OG-3 (Windows additions and changes). Based on kanaworksai-hue/audio-studio-mcp (MIT).
Stable Audio 3 model weights: not included. They are downloaded from Hugging Face and licensed under the Stability AI Community License. If your annual revenue is US$1M or more, commercial use needs an Enterprise License from Stability AI. This Stability AI Model is licensed under the Stability AI Community License, Copyright © Stability AI Ltd. All Rights Reserved. Powered by Stability AI.
T5Gemma text encoder: not included. It is downloaded with the models and subject to the Gemma Terms of Use.
Stable Audio 3 runtime code: Stability-AI/stable-audio-3, MIT, Copyright (c) 2026 Stability AI. Not included. You clone it, and OtoMaker loads it at run time.
Built on: Stable Audio 3 and the Model Context Protocol.
This is an independent project. It is not affiliated with or endorsed by Stability AI, Google or Anthropic.
Available Tools
4 toolsedit_audioB
Edit existing audio with Stable Audio 3: variation (audio-to-audio), inpainting a time range, or continuation/extension. Returns one WAV path per candidate.
Official tip: surrounding context outweighs the prompt — inpaint a large region first and shrink it, and keep prompts plausible for the context.| Name | Required | Description | Default |
|---|---|---|---|
| bpm | No | ||
| cfg | No | ||
| mode | Yes | variation = audio-to-audio remix/style or timbre transfer of the whole clip; inpaint = regenerate only [start,end] and keep the rest; continue = extend the clip to duration_seconds, regenerating from just before the end of its audible content (see overlap_seconds) | |
| seed | No | Base seed for reproducibility; omit or -1 for random. | |
| steps | No | ||
| title | No | Short name; used as the file name and stored in metadata. Auto-named if omitted. | |
| prompt | No | What the result (or the regenerated region) should sound like. May be empty for continue. | |
| strength | No | variation only: init noise level. ~0.4 keeps melody/rhythm (timbre transfer), ~0.6 style transfer, 0.8+ loose. | |
| audio_type | No | Same prefixes as generate_audio. | music |
| variations | No | Number of candidates (different seeds). | |
| end_seconds | No | inpaint only: region end. | |
| input_audio | Yes | Absolute path to an existing audio file (wav/mp3/flac/ogg). | |
| original_idea | No | The user's original request, verbatim and in their language. Stored in metadata only. | |
| start_seconds | No | inpaint only: region start. | |
| negative_prompt | No | Only used when cfg != 1. | |
| overlap_seconds | No | continue only: start regenerating this many seconds before the end of the audible content, so a trailing fade or silence is replaced and the join is smooth. | |
| peak_ceiling_db | No | Safety ceiling in dBFS: a louder peak is turned down to this, quieter audio is untouched. null disables. | |
| duration_seconds | No | Output length. variation/inpaint default = input length; continue = required total length (> input length). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It does disclose the output ('one WAV path per candidate'), which is valuable given there is no output schema, and the mode semantics make clear the input is not destructively modified in place. But it omits side effects (files written to disk, metadata), model-loading cost/latency, and any constraints on the input clip's format or length.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences, front-loaded with purpose and mode enumeration followed by the return contract, then a clearly-labeled tip. Nothing is redundant with the schema. The tip is slightly tangential to selection but earns its place as non-obvious expert guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 18-parameter tool with no output schema and no annotations, the description covers purpose, modes, and return shape, which is the essential core. It still leaves an agent without guidance on typical failure conditions, input-length limits, or the runtime cost of generating up to 4 candidates, so a caller could invoke it correctly but not confidently plan around it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 83%, so most parameters (mode, strength, overlap_seconds, duration_seconds, start/end_seconds, seed, title, prompt) are already documented in the schema, establishing a baseline of 3. The description adds no parameter-level detail beyond the tip's indirect hint that the inpaint region is adjustable; the genuinely undocumented params (bpm, cfg, steps, peak_ceiling_db, original_idea) are not covered here either.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Edit existing audio') and enumerates the three concrete modes (variation, inpaint, continue), which map directly to the mode enum. It also discloses the return shape ('one WAV path per candidate'). It stops short of naming generate_audio/process_audio as the alternatives, so differentiation is implied by 'existing audio' rather than stated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The three modes are named and each is briefly characterized, and the 'Official tip' gives real craft guidance (inpaint a large region then shrink it, keep prompts plausible). However there is no explicit when-to-use-this-versus-alternatives guidance: nothing says when to reach for edit_audio instead of generate_audio or process_audio, nor any prerequisites for the input file.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_audioA
Generate BGM, instrument loops/stems or sound effects from text with Stable Audio 3 (runs locally). Returns one WAV path per candidate.
| Name | Required | Description | Default |
|---|---|---|---|
| bpm | No | Tempo for music/instrument; appended as 'BPM: N.' | |
| cfg | No | Guidance. 1.0 = official default; 3–7 = stricter prompt adherence (≈2× slower). | |
| seed | No | Base seed for reproducibility; omit or -1 for random. | |
| steps | No | Sampling steps; 8 is the official default. | |
| title | No | Short name; used as the file name and stored in metadata. Auto-named if omitted. | |
| prompt | No | English description (see server instructions). Optional for sfx when the sound_* fields are given. | |
| audio_type | No | music = BGM / full instrumental track; instrument = solo instrument, stem or loop; sfx = sound effect, ambience or one-shot; raw = no prefix (prompt used verbatim) | music |
| variations | No | Number of candidates (different seeds) to generate in one call. | |
| sound_space | No | SFX: space and recording (indoor/outdoor, distance, dry/reverberant, mic). | |
| sound_action | No | SFX: how it is triggered and evolves over time (attack, decay, movement). | |
| sound_source | No | SFX: what makes the sound (object, instrument, creature, machine). | |
| original_idea | No | The user's original request, verbatim and in their language. Stored in metadata only. | |
| sound_material | No | SFX: material, texture, timbre. | |
| negative_prompt | No | Qualities to avoid. Only takes effect when cfg != 1. | |
| peak_ceiling_db | No | Safety ceiling in dBFS: a louder peak is turned down to this, quieter audio is untouched. null disables. | |
| duration_seconds | No | Length in seconds. Default: music 60, instrument 12, sfx 5, raw 30. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden, and it does disclose two useful facts beyond the schema: the model runs locally and each candidate yields one WAV path. It omits meaningful traits an agent should anticipate — generation latency/cost, model loading behavior, whether files persist, and failure modes — so coverage is partial rather than thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core capability, then the return value. No filler, no restating the tool name, and every clause adds information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 16-parameter generative tool with no output schema, the description covers purpose and the return shape, and the schema documents all parameters. What is missing is operational context — expected duration/cost of a local generation run and how it relates to unload_models for memory management — which would matter for an agent planning multi-call workflows.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so every one of the 16 parameters is already documented in the schema, including defaults per audio_type and the cfg/negative_prompt interaction. The description adds no syntax or format detail beyond what the schema already provides, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Generate') plus the exact resource classes it produces (BGM, instrument loops/stems, sound effects) and the engine (Stable Audio 3), which cleanly separates it from the sibling edit_audio/process_audio tools that transform existing audio. The second sentence names the output shape (one WAV path per candidate), so an agent knows exactly what comes back.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the verb 'Generate ... from text' suggests this is for creating new audio rather than editing, but the description never says when to pick it over edit_audio or process_audio, nor does it state prerequisites such as model load time (a real concern given the unload_models sibling). The audio_type enum values in the schema effectively route the agent, but that is structured data, not description guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
process_audioA
Post-process and export a clip: trim, trim silence, mono, normalize (peak or LUFS), seamless loop, fades, then write 48 kHz/44.1 kHz WAV, OGG Vorbis or FLAC (+ .json sidecar). The input file is not modified. Steps run in that order. Does not load any model.
| Name | Required | Description | Default |
|---|---|---|---|
| loop | No | Make a seamless loop by crossfading the tail into the head (output gets shorter by loop_crossfade_ms). | |
| mono | No | Downmix to mono (common for positional game SFX). | |
| title | No | Output file name stem. Default: <input>_proc. | |
| format | No | wav = 24-bit PCM; ogg = Ogg Vorbis (Unity/Godot); flac = 24-bit lossless. | wav |
| normalize | No | none = only the safety ceiling; peak = scale so the peak hits peak_ceiling_db; loudness = EBU R128 to target_lufs, two-pass, linear gain when the true-peak limit allows it, otherwise ffmpeg's dynamic mode (reported as loudnorm_mode); the peak ceiling is applied afterwards. | none |
| fade_in_ms | No | ||
| end_seconds | No | Trim: keep until here (default: end). | |
| fade_out_ms | No | ||
| input_audio | Yes | Absolute path to an audio file (any format soundfile/ffmpeg reads). | |
| ogg_quality | No | Vorbis quality 0.1–1.0 (0.6 ≈ 190 kbps stereo). | |
| sample_rate | No | 48000 for video; 44100 keeps the model's native rate (no resampling). | |
| target_lufs | No | loudness mode: -14 streaming/video, -16 game BGM, -23 broadcast. SFX are usually peak-normalized instead. | |
| trim_silence | No | Cut leading/trailing silence (useful for one-shot SFX). | |
| start_seconds | No | Trim: keep from here. | |
| peak_ceiling_db | No | Peak ceiling / target in dBFS. | |
| loop_crossfade_ms | No | Loop crossfade: ~50–200 ms for rhythmic BGM cut on a bar, 500–2000 ms for ambience. | |
| silence_threshold_db | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It discloses key non-obvious behavior: the input is not modified, steps execute in a fixed order, no model is loaded, and a .json sidecar is emitted alongside the exported audio. It still does not describe error/overwrite behavior or return values, but the central behavioral traits are covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tightly packed sentences with the main operation and constraints front-loaded. It avoids repetition and every sentence contributes needed context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 17-parameter tool with high schema coverage, it explains the overall pipeline, non-destructive behavior, output formats, and sidecar. The main remaining omission is that, with no output schema, it does not state the return value or exact output location/overwrite semantics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 82%, so most parameters are already documented in structured form. The description adds useful sequencing context ('Steps run in that order') and summarizes normalize/export choices, but it does not add much per-parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('post-process and export') and resource ('a clip'), and enumerates the transformations and output formats. It distinguishes itself from generation by saying it does not load a model and leaves the input unmodified, though it never names edit_audio or explicitly contrasts with it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when a clip needs post-processing/export and lists supported operations, but it gives no explicit when-to-use/when-not guidance or named alternatives such as edit_audio versus process_audio. It only weakly signals that this is the final processing/export step.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
unload_modelsA
Free the memory held by the loaded models now (they reload on the next call).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full load; it does disclose a genuine behavioral trait — models are unloaded and must be reloaded on the next call, which signals latency cost. It does not say whether this interrupts in-flight work, what happens if nothing is loaded, or what the call returns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, action front-loaded, with the reload consequence in a parenthetical that earns its space by warning about the cost of calling it. No filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, no-output-schema utility tool, the description covers what it does and the main side effect (reload on next call). Minor gaps remain around whether in-flight generation is affected and what the response contains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly avoids inventing options that the empty schema does not support.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb + resource combination ('free the memory held by the loaded models') that an agent can map directly to a resource-management action. It reads as unambiguously distinct from the audio-processing siblings, though it never names them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The word 'now' and the parenthetical about reloading imply this is a memory-pressure action taken between calls, but there is no explicit when-to-use guidance, no exclusion (e.g., mid-generation), and no mention of alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v0.1.1- First observed
edit_audio - First observed
generate_audio - First observed
process_audio - First observed
unload_models
TDQS
Scored across 4 tools
The four tools target clearly distinct stages: text-to-audio generation, model-based editing of existing audio, deterministic post-processing/export, and memory cleanup. Generate vs. edit could superficially overlap, but descriptions explicitly separate text-conditioned creation from audio-to-audio variation, inpainting, and continuation.
All tools follow a consistent snake_case verb_noun pattern: generate_audio, edit_audio, process_audio, unload_models. The only variation is the noun (audio vs. models), which accurately reflects the operation.
Four tools is well-scoped for an audio generation/editing/export server. Each tool maps to a necessary lifecycle stage, and there is no redundant surface area.
The surface covers the core lifecycle: generate audio, edit it, post-process/export it, and unload models. Minor gaps exist around explicit model loading/status or audio metadata inspection, but these are not essential given the returned WAV paths and automatic model reload behavior.
Maintenance
Related MCP Connectors
Generate AI music via the Lacuna Music API from MCP clients like Claude Desktop & Code.
MCP server for Producer/Riffusion AI music generation
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
Remote MCP server for audio stem separation, denoise, reverb, and MIDI export.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables semantic search of local audio samples by describing sounds, MIDI generation, stem separation, and other music production tools from Claude Desktop.2MIT
- AlicenseNot gradedqualityAmaintenanceGives Claude Code, Claude Desktop, Cursor and any other MCP client a local sound studio that turns plain-language requests into background music, instrument loops and sound effects, then re-styles, regenerates or extends them and exports seamless loops, fades and loudness-normalized WAV, OGG or FLAC files. Everything runs on Apple Silicon with no cloud service and no API key.604MIT
- AlicenseNot gradedqualityCmaintenanceThis MCP server enables MCP clients to generate background music, instrument loops, and sound effects from plain-language prompts, then edit them (variation, inpainting, extension) and finish them into seamless loops, fades, loudness-normalized WAV/OGG/FLAC files. All generation runs locally on your own machine without cloud services or API keys, with reproducible prompt/seed metadata saved alongside each output.1MIT
- AlicenseNot gradedqualityAmaintenanceEnables MCP-compatible clients such as Claude Desktop and Cursor to generate images and videos, synthesize speech, clone voices, and design custom voices from descriptive prompts. It supports stdio, REST, and SSE transport modes with configurable API hosts, keys, and local or URL-based resource output.493 npmMIT