Over the past few months, we've noticed a growing number of Voice AI teams choosing to build and own their entire stack.

Not just using an open-source orchestration framework like LiveKit or Pipecat.

Owning every layer.

Their own orchestration. Their own routing logic. Their own tool calling. Their choice of Speech-to-Text, LLMs, Text-to-Speech providers, memory, and infrastructure.

For many teams, it makes perfect sense. They want complete control over performance, latency, cost, reliability, and how their agents behave in production.

But there's one problem that almost every custom stack team eventually runs into.

Observability.

The ability to answer one simple question when a customer says: "That call didn't go well." What actually happened?

The hidden cost of a custom Voice AI stack

Building the agent is usually the fun part. Building the infrastructure to understand why it succeeds or fails isn't.

When something goes wrong, a transcript isn't enough.

You need to know what the customer said, how long transcription took, what the LLM decided, which tools were called, what the agent actually spoke, where latency appeared, and where the conversation started to fall apart.

The problem is that this information lives across every component in your stack.

• Your STT provider.

• Your orchestration layer.

• Your LLM.

• Your tools.

• Your TTS provider.

To understand a single phone call, you first have to stitch all of those events together into one complete timeline.

Historically, that's also what integrating a custom Voice AI stack with Tuner looked like. It worked. But it was a mini engineering project.

You had to capture events across your application, assemble a structured call trace yourself, then send it to Tuner through our API.

We've seen teams spend days, and sometimes weeks, building that plumbing before they could start using Tuner.

And that's the frustrating part. None of that work makes your voice agent smarter. It simply helps you understand the one you've already built.

Introducing Custom Integration SDK

Today we're launching Custom Integration SDK. We've supported frameworks like LiveKit and Pipecat for a long time, and integrating those with Tuner is already straightforward.

Custom Integration brings that same experience to teams building their own orchestration layer.

Instead of manually collecting events and constructing call traces yourself, you simply instrument the parts of your application you already have.

Our SDKs capture the events, build the complete call timeline, and send everything to Tuner automatically.

The result?

What previously took days (or even weeks) now takes a few lines of code.

From weeks of integration to minutes

Before Custom Integration, connecting a custom stack meant building the plumbing yourself.

Now it looks like this:

session = TunerSession(config=TunerConfig.from_env(), call_id=call_id)

stt = TunerDeepgramObserver(connection=dg_connection)
graph = TunerLangGraphObserver(your_graph)
tts = TunerCartesiaObserver()

session.attach(stt)
session.attach(graph)
session.attach(tts)

# Your existing voice agent logic runs unchanged.

await session.flush()

session = TunerSession(config=TunerConfig.from_env(), call_id=call_id)

stt = TunerDeepgramObserver(connection=dg_connection)
graph = TunerLangGraphObserver(your_graph)
tts = TunerCartesiaObserver()

session.attach(stt)
session.attach(graph)
session.attach(tts)

# Your existing voice agent logic runs unchanged.

await session.flush()

session = TunerSession(config=TunerConfig.from_env(), call_id=call_id)

stt = TunerDeepgramObserver(connection=dg_connection)
graph = TunerLangGraphObserver(your_graph)
tts = TunerCartesiaObserver()

session.attach(stt)
session.attach(graph)
session.attach(tts)

# Your existing voice agent logic runs unchanged.

await session.flush()

That's it.

Install only the SDKs you need, attach them to your existing application, and Tuner takes care of assembling the complete call trace.

Today we support SDKs for:

Speech-to-Text

Supports Deepgram and Speechmatics. Hooks into each provider's own events. Captures transcripts, timings, latency, and speech events automatically, without touching your audio stream.

Text-to-Speech

Supports Cartesia. Records what the agent actually said, including accurate interruption handling when callers barge in.

LLM Orchestration

Supports LangGraph and LangChain. Capture every node transition, LLM call, and tool invocation with a single callback.

More providers coming soon

We're already working on support for AssemblyAI and ElevenLabs, and we'll continue expanding the SDK as the Voice AI ecosystem grows.

Once connected, you get the full Tuner platform

Connecting your stack is the only step you take. From the moment your calls arrive in Tuner, every conversation is automatically analyzed using the same platform that's already powering teams running thousands of production calls. Nothing else to set up.

You can:

• Monitor every production call in one place

• Run Evals on every conversation

• Track Call Outcomes and Intents

• Detect hallucinations, latency issues, interruptions, and failed tool calls

• Trigger real-time alerts when something goes wrong

• Test your agents with call simulations before deploying changes

• Measure improvements over time

Instead of spending engineering time building observability infrastructure, your team can spend that time improving the agent itself.

Build your custom stack, get observability in minutes

We're seeing more and more teams choosing to own their Voice AI infrastructure. The best Voice AI products are increasingly built from carefully chosen components, not all-in-one platforms. But owning your stack shouldn't mean rebuilding everything around it.

Observability is a problem every production Voice AI team eventually has to solve. Now, you don't have to build that part yourself.

Get started

If you're building with Python, install only the SDKs you need:

pip install tuner-core 
  "tuner-stt-observer[deepgram]" 
  "tuner-tts-observer[cartesia]"

pip install tuner-core 
  "tuner-stt-observer[deepgram]" 
  "tuner-tts-observer[cartesia]"

pip install tuner-core 
  "tuner-stt-observer[deepgram]" 
  "tuner-tts-observer[cartesia]"

If your stack isn't Python, or you've built your own infrastructure in another language, you can integrate directly using the Create Call API and get the same experience inside Tuner.

Read the docs, connect your stack, and start understanding what your Voice AI agents are really doing.

Build the agent. We'll help you understand it.