agents-voice
This MCP server gives AI agents text-to-speech voice output capabilities.
Use
voice_speakto synthesize and play a concise 1–2 sentence spoken summary, optionally overriding provider, model, or voice.Use
voice_play_latestto replay the most recent speech summary stored in the voice inbox.Use
voice_stopto immediately silence any currently playing speech audio.Use
voice_statusto check backend status, active provider, configured keys, and bridge availability.
Provides text-to-speech through ElevenLabs using configurable voices, synthesizing and playing concise spoken summaries to the user.
Provides text-to-speech through Google Gemini 2.5 TTS (e.g. gemini-2.5-flash-preview-tts) with selectable voices, synthesizing and playing spoken summaries to the user.
Provides text-to-speech through OpenAI (e.g. the gpt-4o-mini-tts model), synthesizing and playing concise spoken summaries of an agent's work to the user.
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., "@agents-voiceSpeak: Deployment complete, no errors."
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.
Overview
agents-voice equips AI coding agents (Antigravity, Cursor, Zed, Claude, agents-harness) with a native voice tool (voice_speak). Instead of reading long code diffs or screen-scraping text, the agent formulates a concise, natural spoken summary (1–2 sentences) directly to the developer's ears upon completing tasks.
Highlights
Multi-Provider Support: Out-of-the-box support for Azure Speech (48kHz DragonHD), OpenRouter (
gpt-audioPCM16 streaming,gpt-4o-mini-tts), OpenAI, Google Gemini 2.5 TTS, ElevenLabs, and custom OpenAI-compatible local endpoints (e.g., Kokoro, LocalAI).Zero Heavy Dependencies: Pure Python standard library (
urllib.request,winsound/winmmon Windows, native OS audio players on macOS/Linux). Noffmpeg, nopygame, no C compiler required.Standalone or HUD Synergy: Plays directly through OS audio when standalone. If the Dumbo desktop overlay is running (
127.0.0.1:12480), optionally routes through Dumbo's Veadio HUD for synchronized word-by-word highlighted playback.Local Credentials: Kept securely on the local machine in
~/.agents/voice.jsonwith fallback discovery from environment variables and existing Dumbo settings.
Related MCP server: Chatty MCP
Installation
pip install agents-voiceOr install in editable mode from source:
git clone https://github.com/Lolaplex/agents-voice.git
cd agents-voice
pip install -e .Configuration
Credentials and settings are saved to ~/.agents/voice.json:
Azure Speech (Default)
agents-voice config --provider azure --key "YOUR_AZURE_KEY" --region "swedencentral" --voice "de-DE-Seraphina:DragonHDLatestNeural"OpenRouter (Steerable & GPT Audio Streaming)
agents-voice config --provider openrouter --key "YOUR_OPENROUTER_KEY" --model "openai/gpt-4o-mini-tts" --voice "marin"OpenAI
agents-voice config --provider openai --key "YOUR_OPENAI_KEY" --model "gpt-4o-mini-tts" --voice "marin"Google Gemini
agents-voice config --provider gemini --key "YOUR_GEMINI_KEY" --model "gemini-2.5-flash-preview-tts" --voice "Kore"ElevenLabs
agents-voice config --provider elevenlabs --key "YOUR_ELEVENLABS_KEY" --voice "JBFqnCBsd6RMkjVDRZzb"Custom / Local Endpoint (e.g. Kokoro, LocalAI)
agents-voice config --provider custom --base-url "http://127.0.0.1:8880/v1" --voice "af_heart"MCP Server Setup
Add to your MCP configuration (e.g. ~/.cursor/mcp.json, ~/.agents/mcp.json, or Claude Desktop config):
{
"mcpServers": {
"agents-voice": {
"command": "python",
"args": ["-m", "agents_voice", "serve"]
}
}
}MCP Tools
Tool | Description |
| Synthesizes and plays or buffers a concise 1–2 sentence spoken summary directly to the user. |
| Plays the most recent speech summary stored in the voice inbox. |
| Immediately terminates any currently playing speech audio. |
| Reports backend status, configured providers, active voice, mode, and bridge availability. |
CLI Reference
Command | Description |
| Speaks text directly via the active provider. |
| Speaks text and waits until playback finishes. |
| Plays a quick test speech sample to verify audio output. |
| Plays the latest voice message stored in the mailbox. |
| Runs the background hotkey daemon listening for the global shortcut (e.g. |
| Cuts off any running audio playback immediately. |
| Prints active provider configuration and status JSON. |
| Updates provider, model, voice, speed, region, mode, hotkey, chime, or API keys. |
| Runs the FastMCP server via stdio transport and launches hotkey listener if in inbox mode. |
License
MIT License. See LICENSE for details.
Available Tools
4 toolsvoice_play_latestA
Plays the most recent speech summary stored in the voice inbox.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that playback targets the single most recent summary (a useful determinism cue), but says nothing about whether playback is blocking, whether it interrupts an in-progress voice_speak/playback, or what happens when the inbox is empty. The presence of an output schema absorbs part of the disclosure burden.
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?
A single front-loaded sentence with zero filler; the selector ('most recent') and the source ('voice inbox') arrive immediately in one read.
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?
With no parameters and an output schema covering return values, the description is close to sufficient. What is missing is playback-state context that matters for a voice tool: blocking vs async behavior, interaction with voice_stop or concurrent speech, and empty-inbox behavior.
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 the baseline is 4. There is nothing parameter-level for the description to compensate for, and it correctly implies no inputs are needed.
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: 'plays the most recent speech summary' names exactly what is acted on and what happens. It is distinguishable from voice_speak (generates speech) and voice_stop/voice_status, though the play-vs-speak boundary is left implicit 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?
Usage is implied by the resource it acts on ('stored in the voice inbox'), but there is no explicit statement of when to call this instead of voice_speak or voice_status, and no mention of preconditions such as an empty inbox.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
voice_speakA
Speak a short, natural voice summary (1-2 sentences) directly to the user's ears.
Use this tool at the end of substantive turns to tell the user what was done, without reading code, diffs, or markdown formatting. Keep it concise, natural, and friendly.
Args: message: The concise spoken text (e.g. 'Hab den Bug gefixt und Tests sind grün.'). provider: Optional override ('openrouter', 'openai', 'gemini', 'elevenlabs', 'azure', 'custom'). model: Optional model override (e.g. 'openai/gpt-4o-mini-tts', 'elevenlabs/eleven-v4-turbo'). voice: Optional voice override (e.g. 'marin', 'cedar', 'Kore', 'de-DE-Seraphina:DragonHDLatestNeural').
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | ||
| voice | No | ||
| message | Yes | ||
| provider | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses the core side effect (audio is spoken directly into the user's ears, so the text is heard not returned), but says nothing about auth/config prerequisites, latency/blocking behavior, or what happens if no TTS provider is configured.
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?
Front-loaded with the action and the when-to-use rule, followed by a compact Args block. The Args section partly echoes schema titles but earns its place by adding examples and the provider list.
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?
An output schema exists so return values need not be explained, and the description covers purpose, timing, formatting constraints, and every parameter. The only real gap is failure/configuration behavior for a tool whose whole job is an external side effect.
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 0%, so the description must compensate, and it does: it labels all four parameters and supplies concrete example values for message, provider (full list of accepted providers), model, and voice. It notably enumerates provider names that the schema does not constrain via an enum.
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 ('Speak a short, natural voice summary') plus scoping constraints (1-2 sentences, to the user's ears). An agent immediately understands this produces audio output rather than text, which distinguishes it from the read-only voice_status sibling by name and role.
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?
Explicitly says when to use it ('at the end of substantive turns to tell the user what was done') and gives a clear exclusion ('without reading code, diffs, or markdown formatting'). It does not mention voice_stop or voice_status as alternatives or when to avoid speaking, so the routing picture is incomplete.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
voice_statusA
Checks the status of the voice output system, active provider, configured keys, and bridge.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the disclosure burden. It does reveal the scope of inspection (provider, keys, bridge), which implies a non-mutating check, but it never states that the operation is read-only, side-effect free, or what a failed/unconfigured state looks like.
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?
A single front-loaded sentence with no filler. Every listed item (provider, keys, bridge) is substantive and none is redundant.
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?
An output schema exists, so the description need not enumerate return values, and the tool is simple (0 params, no nesting). What remains missing is a short note on when to reach for it, but for a trivial status endpoint this is close to sufficient.
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 no parameter semantics are needed. The description sensibly spends its words on what the no-arg call reports rather than inventing arguments.
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 ("Checks") and resource ("status of the voice output system") and enumerates what is inspected: active provider, configured keys, and bridge. It is clearly a read/diagnostic tool separable from the mutating siblings voice_speak and voice_stop, though it never names those siblings 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?
No when-to-use guidance is provided. The description does not say to run this before voice_speak to verify configuration, nor does it mention any precondition, failure mode, or alternative. The diagnostic intent is only implied by the word "status."
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
voice_stopA
Immediately stops any currently playing speech audio if the user requests silence.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does disclose the key behavioral trait: the stop is immediate and scoped to 'currently playing' audio, implying a no-op when nothing is playing. It says nothing about whether the operation is interruptible, resumable, or safe to call repeatedly, which leaves real gaps for a zero-annotation tool.
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?
A single front-loaded sentence with the verb and immediacy first and the trigger condition last; no filler or redundant restatement of the title.
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?
Output schema exists, so return values need no explanation, and there are no parameters to document. For a simple stop command the description covers the essentials, missing only edge-case behavior.
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 no parameters, so there is nothing for the description to clarify and no schema gap to compensate for. Baseline for a zero-parameter tool.
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 (stops) and resource (currently playing speech audio) with an immediacy modifier, so the effect is unambiguous. Siblings voice_speak and voice_status make the domain obvious, though the description never explicitly contrasts itself with them.
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?
"if the user requests silence" gives a trigger condition for use, which is more than most zero-param tools offer. It stops short of naming alternatives (e.g., pausing vs stopping) or stating when not to call it.
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.
1 tool update
v0.1.0- Added
voice_play_latest
3 tool updates
v0.0.1- First observed
voice_speak - First observed
voice_status - First observed
voice_stop
TDQS
Scored across 4 tools
The tools are mostly clearly distinct: speak emits new speech, stop halts playback, status reports system state, and play_latest replays the latest stored summary. The only mild ambiguity is between voice_speak and voice_play_latest, since both result in spoken audio, but their descriptions distinguish creation from replay.
All tools use a consistent snake_case voice_verb pattern: voice_play_latest, voice_speak, voice_status, voice_stop. The shared prefix and predictable verb style make the surface easy to scan.
Four tools is well-scoped for a voice-output helper: speak, replay latest, check status, and stop. Each tool has a clear purpose and none feels superfluous.
The set covers the core lifecycle: producing speech, replaying the latest summary, checking provider/status, and stopping playback. Minor gaps like pause/resume or listing voice history are not essential for the apparent agent workflow.
Maintenance
Related MCP Connectors
Audio for your agent: transcribe, speak, translate, summarise, plus sound effects and music.
AI Voice Production Agent: picks from 30+ TTS models, fixes pronunciation, validates every line.
Video summaries, voice message transcription and translation in the same voice, your own voice TTS
Remote text-to-speech MCP server with text_to_speech and list_voices tools. Free plan.
Related MCP Servers
- FlicenseNot gradedqualityBmaintenanceEnables coding agents to speak aloud using text-to-speech functionality. Works with agents running inside devcontainers and provides configurable voice settings for creating chatty AI companions.6-
- AlicenseNot gradedqualityDmaintenanceProvides voice summaries after each AI request in Cursor, Cline, or any MCP-supported editor, allowing users to hear what was done and stay informed without staring at the screen.9MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to speak aloud by generating and playing audio through the system output. Supports multiple TTS providers, playback queue management, and configurable voice profiles.6 npm1MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to narrate internal thoughts, announce tool actions, and speak final responses aloud through local cross-platform text-to-speech. It exposes dedicated audio tools over stdio JSON-RPC for MCP-compatible clients.MIT