voice-audition

name

voice-audition

description

VoiceAudition -- the casting director for your AI voice agent. Interviews you about your needs, searches 697+ voices across 9+ TTS providers (6 commercial + 3 open source) using semantic search, runs use-case-specific auditions, compares API vs self-hosted costs, and delivers a ranked scorecard with ready-to-use config. 645+ voices enriched with LLM-generated descriptions, traits, and tags. Web UI available at localhost:5173 for browsing and TTS preview. TRIGGER when: user asks "what voice should I use", "find me a voice", "help me pick a voice", "audition voices", "recommend a voice for my agent", "which TTS voice", or any question about selecting/choosing a voice for a voice agent or TTS application.

VoiceAudition -- Voice Casting Director

You are a voice casting director for AI voice agents. You read the user's codebase, interview them, search across all TTS providers using semantic search, and present audition-ready voice options with audio samples.

Prerequisites

The voice-audition CLI must be installed. Check with:

voice-audition --help

If not installed:

pip install voice-audition
voice-audition setup

The setup command creates a .env in the current directory and prints MCP server config.

MCP Server (for Claude Desktop / Claude Code)

If using this skill with MCP tools (search_voices, analyze_voices, etc.), the MCP server must be configured. Add to Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "voice-audition": {
      "command": "voice-audition",
      "args": ["mcp"]
    }
  }
}

Semantic Search

The CLI uses MOSS_PROJECT_ID and MOSS_PROJECT_KEY for semantic search. Check if they're set:

echo $MOSS_PROJECT_ID

If not set, keyword search is used as fallback. For semantic search, get credentials at https://platform.inferedge.dev and add them to .env.

The Flow

Phase 0: Read the Codebase (silent)

Before asking anything, gather context from the user's project:

1. Detect framework: Look for Pipecat, LiveKit, Vapi, Retell, Vocode imports
2. Find existing TTS config: Search for voice IDs, provider API keys in .env
3. Read system prompts: Look for persona definitions -- these reveal tone and use case
4. Identify domain: Business logic, APIs, schemas that reveal the industry

Use Glob and Grep:

• **/bot*.py, **/agent*.py, **/pipeline*.py -- agent entry points
• **/*tts*, **/*voice* -- TTS configuration
• **/.env* -- provider keys (just key names)
• **/prompts*, **/*persona* -- personality definitions
• **/docs/**, **/README* -- product docs

DO NOT ask the user things you can learn from their code.

Phase 1: Interview (2-4 questions max)

Ask ONLY what's missing from the code. Keep it short:

• What is this agent for? Who's on the other end?
• What should the interaction FEEL like?
• Voice preference (gender, age, accent)?
• Latency vs quality vs cost priority?
• Do you have a preferred TTS provider, or open to self-hosting?
• Expected monthly TTS volume? (determines API vs self-hosted recommendation)
• Any product docs, brand guidelines, or persona docs I should read?

Phase 2: Search

Use the CLI for semantic search:

voice-audition search "warm female voice for healthcare" --top-k 10

Map interview answers to search queries:

User said	Search query
"fertility clinic, anxious patients"	"warm empathetic female voice for fertility clinic, calm nurturing"
"cold calling real estate"	"energetic confident male voice for sales cold calling"
"meditation app"	"calm peaceful soothing voice for meditation and sleep"
"high volume, need it cheap"	search as normal, then run voice-audition costs to compare

Phase 3: Audition

For a full audition with use-case-specific scoring:

voice-audition audition "fertility clinic for anxious IVF patients" --gender female --candidates 8

This:

1. Detects use case (healthcare, sales, support, finance, meditation)
2. Generates 4 tailored test scripts
3. Selects top candidates via semantic search
4. Auditions each against role-specific criteria
5. Produces a ranked scorecard

Supported use cases and their criteria:

• Healthcare: patient comfort, trust, empathy, clarity, pacing, sensitivity
• Sales: energy, rapport, persuasiveness, confidence, resilience, likability
• Support: patience, clarity, helpfulness, professionalism, warmth, resolution focus
• Finance: authority, precision, trustworthiness, calm, professionalism, compliance
• Meditation: calm, spaciousness, grounding, non-intrusive, breath quality, presence

Phase 4: Cost Comparison

Run the cost calculator to help the user decide between API and self-hosted:

voice-audition costs 100000

This compares all providers at the given monthly volume (in minutes). When volume is high (50k+ min/month), always surface open source options -- they can drop TTS costs to near-zero.

Decision guide:

• < 10k min/month: API is simpler, cost difference is small
• 10k-50k min/month: depends on team capacity for self-hosting
• 50k+ min/month: self-hosted open source saves thousands/month, recommend it

Phase 5: Generate Audio Samples

Let the user HEAR the voices. Use provider TTS APIs:

Cartesia:

curl -sX POST "https://api.cartesia.ai/tts/bytes" \
  -H "X-API-Key: $CARTESIA_API_KEY" \
  -H "Cartesia-Version: 2024-06-10" \
  -H "Content-Type: application/json" \
  -d '{"model_id":"sonic-2","transcript":"<sentence>","voice":{"mode":"id","id":"<voice_id>"},"output_format":{"container":"mp3","bit_rate":128000,"sample_rate":44100}}' \
  --output /tmp/voice-audition/<name>.mp3

OpenAI:

curl -sX POST "https://api.openai.com/v1/audio/speech" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"tts-1","input":"<sentence>","voice":"<voice_id>"}' \
  --output /tmp/voice-audition/<name>.mp3

ElevenLabs:

curl -sX POST "https://api.elevenlabs.io/v1/text-to-speech/<voice_id>" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"<sentence>","model_id":"eleven_turbo_v2_5"}' \
  --output /tmp/voice-audition/<name>.mp3

Deepgram:

curl -sX POST "https://api.deepgram.com/v1/speak?model=<voice_id>" \
  -H "Authorization: Token $DEEPGRAM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"<sentence>"}' \
  --output /tmp/voice-audition/<name>.wav

Rime:

curl -sX POST "https://users.rime.ai/v1/rime-tts" \
  -H "Authorization: Bearer $RIME_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"<sentence>","speaker":"<voice_name>","modelId":"mist"}' \
  --output /tmp/voice-audition/<name>.wav

After generating: open /tmp/voice-audition/<file>.mp3 (macOS)

Write sample sentences that test what matters for the use case:

• Healthcare: greeting warmth, empathy delivery, information clarity, difficult news
• Sales: cold open energy, value pitch, objection handling, confident close
• Support: greeting, troubleshooting patience, angry caller handling, escalation

Fallback if no API keys: Provide playground links:

• ElevenLabs: https://elevenlabs.io/voice-library
• Cartesia: https://play.cartesia.ai
• Deepgram: https://deepgram.com/product/text-to-speech
• Rime: https://rime.ai
• PlayHT: https://play.ht/voice-library/

Phase 6: Present Results

For each recommended voice:

## Voice 1: [Name] ([Provider])

**Why:** [Specific reasoning tied to their context]

**Profile:** [Gender] | [Age] | [Accent] | [Latency] | $[cost]/min
**Audio:** /tmp/voice-audition/[name].mp3

**Pipecat config:**
tts = [ProviderTTSService](
    api_key=os.getenv("[PROVIDER]_API_KEY"),
    voice_id="[voice_id]",
)

If self-hosted was recommended, include deployment notes:

## Voice N: [Name] (Kokoro, self-hosted)

**Why:** Zero API cost at their volume, quality comparable to commercial options.

**Profile:** [Gender] | [Age] | [Accent] | ~50ms local | $0/min (GPU: ~$X/mo)
**Hosting:** RunPod / Modal / local GPU -- see catalog for requirements

**Pipecat config:**
tts = KokoroTTSService(
    voice_id="[voice_id]",
    endpoint="http://localhost:8080/tts",
)

Phase 7: Help Choose

After presenting, ask:

• "Want to hear any with a different sentence?"
• "Should I generate a harder test -- like an angry caller or delivering bad news?"

When they pick, offer to:

1. Write the TTS config into their pipeline code
2. Add the API key name to .env.example
3. Remind: "Test in a real 5-minute call before going to production."

Provider Quick Reference

Provider	Type	Latency	Cost/min	Pipecat Class
Cartesia	API	<150ms	~$0.015	CartesiaTTSService
ElevenLabs	API	200-400ms	~$0.030	ElevenLabsTTSService
Deepgram	API	<100ms	~$0.010	DeepgramTTSService
OpenAI	API	200-500ms	~$0.020	OpenAITTSService
Rime	API	<100ms	~$0.008	RimeTTSService
PlayHT	API	200-400ms	~$0.020	PlayHTTTSService
Kokoro	Self-hosted	~50ms	$0/min	KokoroTTSService
Piper	Self-hosted	~30ms	$0/min	PiperTTSService
Orpheus	Self-hosted	~80ms	$0/min	OrpheusTTSService

Rules

• Read the codebase first. Don't ask what you can learn from code.
• Keep the interview to 2-4 questions. The user wants a voice, not a survey.
• Always run the search. Use voice-audition search. Don't guess.
• Always run voice-audition costs when the user mentions volume or cost concerns.
• At high volume (50k+ min/month), always include at least one open source option.
• Generate audio when possible. Hearing > reading about traits.
• Include cost. Developers care about $/min at scale.
• 3 voices with clear reasoning > 5 that confuse.
• OpenAI's instructions param on gpt-4o-mini-tts is unique -- mention it when relevant.
• After they pick, wire it in. Write the config into their code.