Open-source voice infrastructure

Voice agents that speak your caller's language.

Voxie runs the call: listening, turn-taking, interruptions and the voice, in 17 languages. It switches speech-to-text mid-call when the caller's language needs it. Your app only decides what to say.

Get started Star on GitHub

Listens first
Real barge-in
17 languages spoken
Apache 2.0

Hears and speaks through

Deepgram
Sarvam
AssemblyAI
Groq
Kokoro
Twilio
WebRTC
StreamCore

Real-time conversations

Listens first, dips its voice the moment you talk over it, and starts speaking before the whole reply is voiced.

Multilingual by default

A listener per call: a misheard turn is identified by language and moved to the listener that hears it.

Developer first

Four request types over HTTP. Every turn arrives with the language it was heard in. You reply with text.

Resilient by design

Failover at every layer. A provider going down degrades the call; it doesn't end it.

Turn conversations into action

Build voice agents for the real world.

From support lines to payment reminders, Voxie handles the hard parts of a live call, so your agent can focus on getting things done.

See how a call works

Listens firstIf the caller says "Hello?", it answers them instead of talking over them.
Real barge-in"Yeah, okay" doesn't stop it. A real interruption does.
Speaks their languageKokoro and Sarvam voices, one sentence at a time.

How a call works

Voxie runs the call. Your app decides what to say.

01 · Caller
Browser or phone
WebRTC (WHIP) from a browser, Twilio Media Streams for phone calls, or any SIP trunk through sip-server.
02 · Voxie server :8080
Hears and takes turns
Speech detection, turn-taking, barge-in, echo guard, and speech-to-text that adapts to the caller.
03 · Your agent
Decides what to say
Voxie posts each turn to one HTTP endpoint of yours, with its language. You reply with text.
04 · Voice router :8300
Speaks it
Sentence by sentence: Kokoro on the GPU in ~130ms a sentence, Sarvam for Indian languages.

One runtime.
Endless conversations.

Give any app a voice: Voxie brings the call, the listening and the voice; your agent brings the knowledge and the tools.

See the quickstart

Customer support

Answer questions in the caller's language, and hand off to a person when they ask.

Payment reminders

A polite call about a failed payment. Softknock's REX runs its calls on Voxie.

Sales and lead qualification

Call back every lead in minutes, qualify them, and book the meeting.

Scheduling and reminders

Confirm, move or cancel appointments over the phone, in ten Indian languages and more.

Integrate

Three steps to a voice agent.

Voxie is open source. The images are published; the rest is your own app.

Run Voxie

Add your provider keys and start the server and the voice router. You need keys for Deepgram, Groq and Sarvam (AssemblyAI is optional), and an NVIDIA GPU for the voice router.

git clone https://github.com/SomehowLiving/Voxie.git && cd Voxie
cp .env.example .env                        # DEEPGRAM_API_KEY, GROQ_API_KEY, SARVAM_API_KEY
docker compose -f compose.release.yaml up   # server :8080 · voice router :8300 · test page :8400

Point it at your app

One config for every caller. Set your agent's URL and a shared key; Voxie sends it as a bearer token on every request.

[agent]
url = "https://your-app.example.com/voice/agent"
api_key = "…"        # or STREAMCORE_AGENT_API_KEY

[stt]
provider = "adaptive"   # a listener per call

Answer four requests

Voxie posts each event of the call to your endpoint and speaks what you send back.

`type`	When	Reply
`listen`	Before speech-to-text starts	`{ language?, region? }`
`greeting`	The caller stayed silent	`{ text }`
`chat`	The caller finished a turn	`{ text, end_call? }`
`oneshot`	Background work	`{ text: "" }`

// A whole agent: Node 20+, no dependencies.
import { createServer } from "node:http";

createServer(async (req, res) => {
  let body = "";
  for await (const chunk of req) body += chunk;
  const turn = JSON.parse(body);   // { session_id, resource_id, type, text, language }

  let reply = { text: "" };
  if (turn.type === "listen") reply = {};   // or what you know: { language: "hi", region: "IN" }
  if (turn.type === "greeting") reply = { text: "[lang:en] Hi, this is Voxie. How can I help?" };
  if (turn.type === "chat") reply = { text: await think(turn.text, turn.language) };

  res.writeHead(200, { "Content-Type": "application/json" });
  res.end(JSON.stringify(reply));
}).listen(9101);

async function think(text, language = "en") {   // your app goes here
  return `[lang:${language}] You said: ${text}`;
}

Published images

Pull it, don't build it.

Both halves of Voxie are on GitHub's container registry, built for linux/amd64 with the Apache 2.0 licence and StreamCore's notice inside. Pin a version in production.

voxieThe server: hearing, turn-taking, barge-in · about 740 MB
ghcr.io/somehowliving/voxie:845a2f1
voxie-voice-routerThe voice: Kokoro and Sarvam, needs an NVIDIA GPU · about 4.8 GB
ghcr.io/somehowliving/voxie-voice-router:845a2f1

docker pull ghcr.io/somehowliving/voxie:845a2f1
docker pull ghcr.io/somehowliving/voxie-voice-router:845a2f1
VOXIE_TAG=845a2f1 docker compose -f compose.release.yaml up

Reply in the caller's language

Start each sentence with [lang:xx], for example [lang:ta]. Hindi and Marathi share a script, so text alone can't tell them apart. Answer only in languages the router's GET /health lists right now.

Phone calls through Twilio

Set TWILIO_AUTH_TOKEN, then connect the call's audio to Voxie. No SIP trunk and no public IP: a public URL is enough.

<Response><Connect><Stream url="wss://<voxie-host>/twilio/media">
  <Parameter name="resource_id" value="+919812345678"/>
</Stream></Connect></Response>

Stream your replies

Reply as text/event-stream and Voxie voices the first sentence while the rest is on its way. Send {"end_call": true} to hang up once the goodbye has played.

Languages, measured

17 languages spoken.
6 more understood.

Every result comes from real provider APIs, tested with scripted callers on clean and phone-quality audio.

Real voices. Measured results.

More human conversations.
Real numbers.

Measured with real APIs and scripted callers, never guessed.

24 / 24: Languages named correctly
0.4–1s: To catch a misheard turn
~130ms: Per sentence of voice
17: Languages spoken

Honest limits

What we haven't proven yet.

Tested mostly with synthetic voices, clean and at phone quality, plus a real phone call through Twilio to an Indian mobile. A pilot with real callers is next.
A turn that may have been misheard waits 0.4–1s for its language to be identified, usually only the caller's first real turn.
The voice router needs an NVIDIA GPU, and free API tiers run out quickly under multilingual load: plan on paid tiers for Groq and Sarvam.

Hosted and enterprise

Want us to run it for you?

Hosted Voxie, or help taking it to production on your own servers. Tell us what you're building and we'll get back to you.