In-app voice action layer
Voqalize adds an action-taking voice agent to any web or mobile product. It reads the screen the user is on, performs the actions you allow, and updates the interface as they speak — while your agent, your data and your business logic stay in your environment.
shows · sees · acts
This is a real session on the servicing desk demo — an advisor working a mortgage case out loud. Every line the agent acts on is a typed action you exposed, not a guess about what's on the screen.
“What's holding up the Patel file?”
case 4471 · escrow, payment history, servicing notes
open_case(4471)
“Escrow is short by $1,240. The rate change posted before the analysis ran.”
draft(escrow_adjustment)
Approve
the server enforces this, not the promptpost(escrow_adjustment)
The agent sees the structured application state your server already authenticated — the case, the cart, the clause on screen. No screenshots, no OCR, no guessing.
You expose a set of typed actions. The agent decides which to call and when; it cannot invent one. Adding a capability is adding a function, not retraining anything.
Irreversible steps are drafted and held for approval. That gate lives in your server, so it holds whether or not the model behaves.
where it's working
Each of these is a live agent, not a mockup — you can talk to every one of them right now. They differ in the workflow they finish, not in how they were built.
financial services
A servicing advisor works a mortgage case by talking. The copilot pulls the file, reconciles the numbers, and finds the blocker that gates a regulated step.
1 · Services
Provider shall perform the services described in each Statement of Work executed by the parties and incorporated herein by reference.
2 · Term & Termination
This Agreement renews for successive twelve (12) month terms unless either party gives ninety (90) days' written notice. Customer may terminate for convenience upon one hundred eighty (180) days' written notice, subject to a wind-down fee equal to twenty-five percent (25%) of the remaining committed contract value.
flagged — 180 days' notice and a 25% wind-down fee, marked while counsel read the clause aloud
legal
Counsel reads a vendor MSA out loud. The copilot stays in the document with them, marking clauses as they go — because the page tells it which clause is on screen.
healthcare
A daily diabetes check-in that starts from a notification. "Curd rice and two rotis" becomes a logged meal with calories — and it knows exactly where the clinical line is.
illustrative example · not affiliated banking
A customer asks their bank a question out loud. The agent opens the how-to, signs them in securely, and reads the actual balance — not a canned answer.
the integration
There is no dashboard to move your prompt into and no agent to reimplement. You expose a WebSocket route the way you already expose webhooks, and you handle one message type in the app you already have. Everything between them is ours to run.
your backend · where the agent already lives
from voqalcloud.sdk import Brain, serve_direct
class DeskBrain(Brain):
async def on_interaction(self, i):
case = your_db.load(i.session.payload["case_id"])
async with i.say() as out:
async for chunk in your_llm.stream(i.transcript, case):
await out.speak(chunk)
i.action("open_case", {"id": case.id})
# we dial this per session — nothing else leaves your network
serve_direct(DeskBrain, host="0.0.0.0", port=8787)your app · where the user already is
import { useVoqalSession } from '@voqalize/client-react'
const session = useVoqalSession({
tenantSlug, agentId, publishableKey,
payload: { caseId }, // context, per session
onServerMessage: (msg) => {
if (msg.type === 'ui_command') dispatch(msg)
},
})
// dispatch is your own reducer — the agent can only
// reach the actions you chose to handle hereOne authenticated WebSocket per session, opened when the call starts and closed when it ends. We carry text in, text out — your code never touches an audio frame, and your prompt never leaves your building.
two ways in
Either way the line sits in the same place: your business rules, your policies and your data stay yours to control. What changes is who writes and runs the prompt.
Your model, your prompt, your tools, your data — running in your backend exactly as they do today. We run the voice: WebRTC, the screen actions you expose, interruption, the approval gate, and the observability to see what the agent actually did.
We design and run the voice experience on our runtime — the prompt, the flow, the screen actions it's allowed to take. You own the business rules, the policies, the data it touches, and the final sign-off before anything ships.
under the hood
Speech isn't something we resell. STT and TTS are open models we host ourselves, so your users' audio reaches us and stops there — no third-party voice vendor in the path.
WebRTC from the browser or app. Echo cancellation, packet loss, reconnects.
Self-hosted STT with turn detection and barge-in, behind a Deepgram-Flux-compatible API.
Text arrives over the session WebSocket. Your model, your prompt, your data, your latency.
Self-hosted TTS behind a Cartesia-compatible API. Voice, language and model swap mid-call.
Streamed back as it generates, interruptible the moment the user starts talking.
Your brain, your data. Everything else on this path is ours to run.
Because we run the models, we can tune the parts that decide whether a conversation feels alive — end-of-turn detection, interruption, time to first audio.
Hindi, Tamil, Telugu, Bengali and 18 more on models we host, alongside English and 40 others. Callers can switch language mid-sentence.
The whole voice plane can deploy inside your infrastructure. Then nothing crosses the wall at all — not the audio, not the transcript.
where it fits
Three categories get confused with this one. The differences aren't features — they're where the agent runs and whether it can touch a screen.
Vapi · Retell · Bland
They optimize the call — latency, turn-taking, the conversation itself. The application-control loop, state that stays in sync, typed UI actions, approvals inside your own software, isn't their product.
It's ours. Voqalize lives inside your web or mobile app, reads the state your server already authenticated, and moves the interface as it speaks.
dashboard-first agent builders
Your prompt, tools and logic move into their console. Every tool call is a round-trip out of your network and back.
Your agent stays where it already runs. Tool calls are local function calls. We connect to it over one authenticated WebSocket per session.
LiveKit · Pipecat
we build on this
Excellent transports. They hand you media and a data channel, and leave the intent → action → UI → verification loop for you to build.
We are built on that same ground. What we ship is the loop on top of it — plus speech we host ourselves.
where this came from
Voqalize is the voice layer underneath Recruit41, our AI interview product. It ran 50,000 production interviews — including 1,143 simultaneous conversations during a single nationwide campus drive — before we ever described it as a platform.
Everything on this page is that stack, unbundled: the WebRTC transport, the speech models, the turn-taking, and the loop that lets a spoken sentence change what's on screen. What we kept for ourselves was the brain. That's why the product is built so you keep yours.
founded by
Partners at HashedIn from 2010 to 2024 — a thousand-person engineering company with a 600-person AI division, acquired by Deloitte. We have spent fifteen years building software for other people's businesses. This is the part we wanted to own.
start here
Not your whole product. The one screen your users dread — the form nobody finishes, the queue your team works all day, the search that takes six clicks. That's where this pays for itself first, and it's small enough to prove in days.
Build it yourself
Create an agent, take the publishable key, add the hook to your app. The SDK, the docs and every demo's source are open — nothing here is gated behind a call.
Do the first one with us
Send us the workflow. We'll scope it, build it against your real UI and hand it back working — you keep the code and the brain. If it isn't obviously better than the clicking, we'll say so.
Still early: the SDK and the wire protocol are moving, and we say so on purpose. What isn't moving is the shape — your brain stays yours, and a person approves anything that can't be undone.