Give your AI agent ears: audio loudness & voice analysis over MCP

An LLM can’t hear. Ask a coding agent “is this podcast episode too quiet for Spotify?” and it will guess from the filename, or write you a shell script that shells out to a tool it hopes exists. What it can’t do is measure the audio.

You can fix that with one config block. AudioLab exposes reference-grade audio analysis, integrated loudness (LUFS), true peak (dBTP), voice quality, spectrum, as an MCP server and a REST API, so your agent gets a real tool that returns real numbers. This is how to wire it up.

→ Get a key and copy a config at /connect

Three ways to connect, pick by where your agent runs

Your setup	Use	Auth
Claude Desktop, Cursor, VS Code, or any local MCP client	Local MCP (npx @audiolabtools/mcp-server)	AUDIOLAB_API_KEY env
ChatGPT, or a hosted/remote agent	Remote MCP (https://audiolab.tools/mcp)	Authorization: Bearer <key>
Your own code / a Vercel AI SDK agent	REST (https://audiolab.tools/v1/…) or @audiolabtools/ai-sdk	Authorization: Bearer <key>

All three hit the same analysis engine. Get a key once at /connect; it works everywhere.

What the agent can actually do

Eight tools, grouped by job:

Loudness & mastering

• analyze_loudness, integrated LUFS, LRA, true peak (dBTP), peak/RMS/crest, stereo width
• check_target, measure a file and compare it to a platform target (e.g. “is this −14 LUFS for Spotify?”)
• analyze_timeseries, loudness over time (short-term LUFS curve + waveform), downsampled for an agent’s context window
• get_spectrum, frequency-domain snapshot
• compare_loudness, A/B two files (your master vs a reference)

Voice & speech

• analyze_voice, voice quality QA (sibilance, room echo, clipping, level consistency)
• get_speech_segments, where speech starts and stops

Indexing

• index_signal, a content fingerprint / type classification for a clip

The agent decides which to call. You just ask in plain language: “Check this master against Apple Music,” “Is there clipping in track 3?,” “Compare my mix to reference.wav.”

Quickstart, Claude Desktop in three steps

1. Get a key. Sign in at /connect and copy your API key.
2. Add the server. In Claude Desktop → Settings → Developer → Edit Config, add:

{
  "mcpServers": {
    "audiolab": {
      "command": "npx",
      "args": ["-y", "@audiolabtools/mcp-server"],
      "env": { "AUDIOLAB_API_KEY": "your-key-here" }
    }
  }
}

3. Restart and ask. “How loud is /Users/me/mix.wav, and is it ready for Spotify?” Claude calls check_target and reports back: −13.2 LUFS integrated, −0.8 dBTP, 0.8 LU over the −14 target, turn it down ~1 dB or let Spotify normalize it.

Cursor and VS Code get one-click install deeplinks on /connect; ChatGPT uses the remote URL + Bearer header from the same page.

The part most audio APIs can’t do: local files, no upload

The local MCP server accepts a file path. Point your agent at /Users/me/session/master.wav and it reads the file on your machine and analyzes it, nothing is uploaded. For a producer working through a folder of stems, or a CI job checking rendered output, that’s the difference between “usable” and “please upload each file to a web form.”

For files that aren’t local, a URL, a rendered artifact in a pipeline, the same tools take a URL and fetch it server-side. (Small files stream directly; larger ones use a signed upload. The server picks automatically.)

In your own code (Vercel AI SDK)

If you’re building the agent rather than using a client, the REST endpoints are plain JSON:

POST https://audiolab.tools/v1/mixlab/analyze
Authorization: Bearer <key>
{ "url": "https://example.com/master.wav" }
→ { "integratedLufs": -13.2, "truePeakDbtp": -0.8, "lra": 6.1, ... }

Or drop in @audiolabtools/ai-sdk to register the tools with a Vercel AI SDK agent directly, so generateText/streamText can call them during a run. Either way it’s the same engine and the same key. Full endpoint reference on /api.

Why route audio through an agent at all

Because the boring, repeatable audio checks are exactly what an agent is good at, and exactly what humans skip:

• A publish gate: “reject any render above −1 dBTP or louder than −14 LUFS” as a step in your build.
• Batch QA: hand the agent a folder and ask which episodes drift off target.
• Replace a shell-out: swap ffmpeg -af loudnorm measurement passes for a call that returns clean JSON instead of stderr you have to parse.
• Conversational mastering checks: ask, in the same chat where you’re already working, whether a file is ready, without switching to a DAW.

Privacy & cost

Local-file analysis over the local MCP stays on your machine. URL/remote analysis fetches server-side and is metered per call and per byte against your plan (a free tier exists; Pro and Studio raise the ceilings). No audio is stored after analysis. Keys are hashed at rest.

FAQ

Do I need to write any code to give Claude audio analysis? No. The MCP config block above is all Claude Desktop needs. Code is only for building your own agent.

Can the agent analyze a file on my computer without uploading it? Yes, that’s what the local MCP server’s file-path support is for. On-disk files are read and analyzed locally.

Is this accurate enough to trust? The loudness engine implements ITU-R BS.1770-4 and is verified against the EBU Tech 3341/3342 reference signals (integrated loudness within ±0.1 LU). See Methodology: loudness.

Which model / client works? Any MCP-capable client (Claude Desktop, Cursor, VS Code, ChatGPT with connectors) via MCP, or any framework via REST / the AI SDK package.

What does it cost? There’s a free tier with monthly call and data ceilings; paid tiers raise them. Pricing on /pricing.

Further reading

• /connect: get a key and copy the config for your client.
• /api: REST endpoint reference and the analysis tools.
• Loudness targets per streaming platform (2026): the targets your agent checks against.
• True peak (dBTP), explained: the ceiling a publish gate should enforce.