AI engineering
Voice and chat agents that answer, understand, act and hand over cleanly. Turn-taking latency is the whole product in voice — an agent that is right but a second late feels broken — so the budget is set before anything is built.
The turn-taking budget is set in the first week and constrains everything after it. In voice an answer that is correct and a second late feels broken, so latency is a requirement rather than a metric.
We design the conversation as flows, including the ones that go wrong: the caller interrupts, the line is bad, the agent has to hand over. Barge-in and handover are part of the design, not a later fix.
Streaming end to end from the first slice — partial transcripts in, first audio out, measured on a real call. A pipeline assembled first and measured afterwards is almost always over budget.
Tested against recorded calls with real accents, cross-talk and background noise, and held to the p95 budget agreed in Discover. Every escalation path is dialled rather than assumed.
Calls are transcribed, scored and sampled by a person every week. The containment rate worth quoting is the one from month three, and it comes out of that loop.
One voice turn end to end, with the latency budget written into the code and barge-in handled at the transport rather than in the prompt.
"""A voice turn, with the latency budget in the code."""
from pipecat.pipeline.pipeline import Pipeline
from pipecat.services.anthropic import AnthropicLLMService
from pipecat.services.deepgram import DeepgramSTTService
from pipecat.services.elevenlabs import ElevenLabsTTSService
# Agreed in Discover, asserted in the call analytics: p95
# mouth-to-ear, measured from end of speech to first audio.
TURN_BUDGET_MS = 800
pipeline = Pipeline(
[
transport.input(),
DeepgramSTTService(api_key=DEEPGRAM_KEY, interim_results=True),
AnthropicLLMService(model="claude-haiku-4-5", context=context),
ElevenLabsTTSService(voice_id=VOICE_ID, optimize_latency=3),
transport.output(),
]
)
@transport.event_handler("on_user_started_speaking")
async def barge_in(_transport, _participant):
"""Stop talking the moment the caller starts."""
await pipeline.interrupt()An inbound voice agent for a freight operator, handling status enquiries and booking amendments outside staffed hours, with a clean handover into the morning queue.
We set a turn-taking budget with you in Discover and hold the build to it, measuring each hop — transcription, retrieval, model, speech synthesis and transport — separately. We publish the measured number to you rather than a vendor's marketing figure.
Yes. We integrate over SIP or WebRTC with your carrier or contact-centre platform, so numbers, routing and escalation to a human queue keep working. An embeddable web widget can run from the same agent definition.
It hands over to a person with the transcript, the caller's identity and what has already been tried, so nobody has to start again. Defining that boundary well is most of what makes a voice agent tolerable.
Consent is captured in the flow before recording, personal data is redacted before anything reaches a model provider, retention is configurable per deployment, and every call leaves an audit trail. Regional pinning where residency requires it.
Relay is our own platform for launching voice and web agents. This service is the engineering around one — the integrations, the data work and the systems it has to talk to. Some clients use Relay, some want it built directly into their own stack.
A first call is 30 minutes and costs nothing. Bring the problem rather than a spec — the useful part is usually working out whether this is the right shape of solution at all.
contact@algologix.coWe reply within 24 hours.