On October 29, 2026, speech AI infrastructure leader Deepgram officially announced its acquisition of Daily (Daily.co), the real-time communications infrastructure provider behind Pipecat, the premier open-source voice agent framework. Announced live at the inaugural Deepgram Speak conference in San Francisco by Deepgram CEO Scott Stephenson and Daily co-founder Kwindla Hultman Kramer, the transaction establishes the industry’s first vertically integrated, open alternative to proprietary speech-to-speech APIs like the OpenAI Realtime API and Google Gemini Live.
Pipecat will transition governance to an independent Pipecat Foundation under its existing BSD 2-Clause license, with Kramer joining Deepgram as Head of Open Source. Concurrently, the companies unveiled the Real-Time Context Standard (RCS)—an open binary protocol designed to eliminate context amnesia during live agent model handoffs.
┌────────────────────────────────────────────────────────────────────────────────────────┐
│ THE NEW UNIFIED DEEPGRAM + DAILY + PIPECAT VOICE STACK │
├────────────────────────────────────────────────────────────────────────────────────────┤
│ 1. Edge Ingress & Transport│ Daily Global WebRTC Mesh (28 PoPs) + Native SIP / PSTN │
│ 2. Pipeline Orchestration │ Pipecat Framework (BSD 2-Clause, Pipecat Foundation) │
│ 3. Streaming Speech Layer │ Deepgram Nova-3 (STT) + Deepgram Aura-2 (TTS) │
│ 4. Kernel Audio Bridge │ POSIX Shared Memory (/dev/shm) Zero-Copy Ring Buffers │
│ 5. Session State Protocol │ Real-Time Context Standard (RCS) Protobuf Specification │
│ 6. Cognitive Reasoning │ Pluggable Cascade (Groq Llama 3.3, Claude 3.5, GPT-4o) │
└────────────────────────────────────────────────────────────────────────────────────────┘
The Deal Mechanics & Strategic Overview
While the total acquisition price remains confidential, the strategic parameters of the transaction define a major turning point for real-time AI infrastructure:
| Parameter | Official Announcement Details |
|---|---|
| Acquiring Entity | Deepgram Inc. (Led by CEO & Co-founder Scott Stephenson) |
| Acquired Entity | Daily Inc. (Creators of Daily.co WebRTC network and Pipecat) |
| Announced Date | October 29, 2026 (At Deepgram Speak, San Francisco) |
| Leadership Move | Kwindla Hultman Kramer (Daily Co-Founder/CEO) joins Deepgram as Head of Open Source |
| Team Integration | Daily’s entire 40+ person engineering, WebRTC infrastructure, and dev-rel teams transition to Deepgram |
| Pipecat Governance | Transitioning to an independent Pipecat Foundation with an ecosystem steering committee |
| Pipecat Licensing | BSD 2-Clause (Strictly preserved, completely permissive, zero commercial clawbacks) |
| Daily Products | Daily Prebuilt, Daily Core WebRTC APIs, and Daily Call Object continue normal operations and commercial sales |
| New Open Standard | Real-Time Context Standard (RCS) co-developed with Pipecat for zero-latency multi-agent state transfers |
Why Deepgram Acquired Daily: The Systems Engineering Reality
To understand why this acquisition is an architectural masterstroke, you must inspect the technical friction points of real-time voice pipelines in production.
1. The Multi-Hop Network Latency Tax
In standard cascaded voice agent architectures, audio packets cross the public internet or intra-cloud VPC peering connections multiple times during a single conversational turn:
THE PRE-ACQUISITION MULTI-HOP PIPELINE (HIGH JITTER & SERIALIZATION TAX):
Caller (PSTN / WebRTC)
│ (Audio: Opus 16kHz / G.711u 8kHz)
▼
[ Daily SFU Ingress Node ]
│ WebRTC RTP Decryption & Jitter Buffer (~25ms)
▼
[ Pipecat Worker Process (Python) ]
│ Base64 / Binary Packeting over WebSocket (~35ms hop)
▼
[ Deepgram STT Cloud (Nova-3) ]
│ Conformer-2 Transducer Streaming Inference (~110ms)
▼ (Interim / Final Text Tokens via WebSocket)
[ Pipecat Worker Process ]
│ HTTP POST / Server-Sent Events (~40ms hop)
▼
[ LLM Inference Cloud (Groq / Anthropic) ]
│ TTFT: Time to First Token (~95ms)
▼ (Streaming Text Tokens)
[ Pipecat Worker Process ]
│ WebSocket Request with Streaming Tokens (~30ms hop)
▼
[ Deepgram TTS Cloud (Aura-2) ]
│ Flow-Matching Vocoder Synthesis (~50ms TTFB)
▼ (Streaming PCM Audio Chunks)
[ Pipecat Worker Process ]
│ WebRTC Audio Track Ingestion (~20ms)
▼
[ Daily SFU Egress Node ]
│ WebRTC SRTP Playback to Caller
▼
TOTAL ROUND-TRIP LATENCY (P50): 405ms – 520ms (with 80ms–140ms consumed purely by serialization & network hops)
By owning Daily, Deepgram can fundamentally eliminate these intermediate network hops.
2. The Kernel-Level Zero-Copy Shared Memory Architecture
Deepgram revealed its engineering roadmap: co-locating Deepgram speech inference workers directly inside Daily’s 28 global edge points of presence (PoPs).
Instead of piping audio over TCP WebSockets to an external API endpoint, the Daily SFU receiver writes incoming decrypted PCM audio frames directly into a POSIX shared memory ring buffer (/dev/shm). The Deepgram Nova-3 worker reads directly from the shared memory pointer with zero memory copies and microsecond-level IPC latency:
DEEPGRAM + DAILY ZERO-COPY SHARED MEMORY ARCHITECTURE:
Caller Audio Track
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ DAILY EDGE SFU NODE (C++ / LINUX) │
│ │
│ [ WebRTC Decryption & Packet Loss Concealment ] │
│ │ │
│ ▼ (Raw 16-bit 16kHz PCM Audio Stream) │
│ ┌───────────────────────────────┐ │
│ │ POSIX Shared Memory Buffer │ ◄─── Pointers Mapped in shm_open │
│ │ (/dev/shm/audio_ring) │ │
│ └───────────────────────────────┘ │
│ │ │
│ ▼ (Zero-Copy Pointer Read: ~0.08ms) │
│ [ Deepgram Nova-3 Streaming Worker ] │
│ [ Conformer Transducer Acoustic + CTC Tokenizer ] │
│ │ │
│ ▼ (Interim Tokens Emitted via Local IPC Socket) │
│ [ Local Pipecat Agent Worker (Python Runtime) ] │
│ │ │
│ ▼ (Streaming Prompt Buffer via HTTP/2 Local Proxy) │
│ [ LLM Streaming Engine (Groq Llama 3.3 / Claude 3.5 Haiku) ] │
│ │ │
│ ▼ (Tokens Streamed to Local Shared Memory) │
│ [ Deepgram Aura-2 Streaming Vocoder ] │
│ │ │
│ ▼ (Audio Chunks Injected Directly to Daily SFU) │
│ [ Daily WebRTC Egress Pipeline ] ──> Output RTP Stream to User │
└─────────────────────────────────────────────────────────────────────────────┘
PROJECTED ROUND-TRIP LATENCY (P50): 260ms – 320ms (Comparable to Closed Neural Speech Models)
By removing three socket layers and two TLS handshakes, this unified edge architecture shaves 60ms to 95ms off real-time turn-taking latency.
The Real-Time Context Standard (RCS): Protocol Deep Dive
Context loss during agent handoffs has been the single biggest engineering barrier to scaling multi-tier voice AI agents.
When a caller is transferred from a tier-1 triage agent (e.g., identity verification) to a tier-2 specialist agent (e.g., technical troubleshooting or claims processing), traditional architectures reset the conversation:
- The user’s recent words spoken during the transfer are dropped.
- The downstream LLM must re-read 40 lines of chat history, spiking Time-to-First-Token (TTFT) by 1,200ms.
- Acoustic noise floor calibration and VAD thresholds are lost, causing awkward double-talk or abrupt barge-in sensitivity resets.
The Protobuf Specification of RCS
At Deepgram Speak, Deepgram and Pipecat unveiled the Real-Time Context Standard (RCS). RCS is serialized via Protocol Buffers for sub-millisecond serialization and parsing:
syntax = "proto3";
package rcs.v1;
message RealTimeContextPacket {
// Session Identifiers
string session_id = 1; // UUIDv4 identifying global voice call
uint32 turn_index = 2; // Monotonically increasing turn counter
uint64 timestamp_us = 3; // Microsecond epoch timestamp of handoff
// Acoustic & Audio Context
AudioRingBuffer audio_context = 4;
// Linguistic History
repeated TurnUtterance history = 5;
// Extracted Entities & State
map<string, string> session_metadata = 6;
repeated ToolExecutionResult tool_states = 7;
// Acoustic Calibration Profile
AcousticProfile vad_profile = 8;
}
message AudioRingBuffer {
uint32 sample_rate_hz = 1; // Usually 16000 or 8000
uint32 num_channels = 2; // 1 (Mono)
bytes uncompressed_pcm_data = 3; // Sliding window of preceding 6-10 seconds
uint32 duration_ms = 4;
}
message TurnUtterance {
enum Role {
ROLE_UNSPECIFIED = 0;
ROLE_SYSTEM = 1;
ROLE_USER = 2;
ROLE_AGENT = 3;
ROLE_TOOL = 4;
}
Role role = 1;
string content = 2;
uint64 start_time_us = 3;
uint64 end_time_us = 4;
float confidence_score = 5;
repeated WordTimestamp word_alignments = 6;
}
message WordTimestamp {
string word = 1;
uint32 start_ms = 2;
uint32 end_ms = 3;
float confidence = 4;
}
message ToolExecutionResult {
string tool_name = 1;
string tool_call_id = 2;
string arguments_json = 3;
string result_json = 4;
uint32 execution_duration_ms = 5;
}
message AcousticProfile {
float background_noise_floor_dbfs = 1; // Ambient noise level (e.g. -48.2 dBFS)
float signal_to_noise_ratio_db = 2; // Estimated SNR
float speech_cadence_wpm = 3; // User speaking rate (words per minute)
float recommended_vad_threshold = 4; // Calibrated Silero speech_threshold
uint32 min_silence_duration_ms = 5; // Calibrated pause threshold before EOS
}
How Pipecat Implements RCS in Python
In Pipecat, handing off a call with RCS requires zero manual state plumbing:
# Production RCS Context Handoff in Pipecat
import asyncio
from pipecat.pipeline.pipeline import Pipeline
from pipecat.frames.frames import Frame
from pipecat.services.rcs import RCSContextSerializer, RCSHandoffFrame
from pipecat.services.deepgram import DeepgramSTTService, DeepgramTTSService
from pipecat.services.anthropic import AnthropicLLMService
from pipecat.transports.services.daily import DailyTransport
class TriageAgentPipeline:
def __init__(self, transport: DailyTransport):
self.transport = transport
self.rcs_serializer = RCSContextSerializer(sliding_audio_window_sec=8.0)
async def trigger_handoff_to_specialist(self, destination_agent_id: str):
"""
Serializes acoustic buffer, conversation history, and entity state
into a binary RCS packet and delivers it to the target worker via IPC.
"""
# 1. Capture binary state packet without dropping active audio frames
rcs_packet_bytes = await self.rcs_serializer.export_context_packet(
metadata={
"customer_tier": "enterprise_vip",
"auth_status": "biometric_verified",
"intent": "escalated_refund_processing"
}
)
# 2. Emit RCS handoff frame down the Pipecat pipeline
handoff_frame = RCSHandoffFrame(
target_agent=destination_agent_id,
payload=rcs_packet_bytes
)
await self.transport.send_frame(handoff_frame)
print(f"[RCS] Context transferred ({len(rcs_packet_bytes)} bytes) in 3.8ms")
The Economic Model: Open Stack vs. Monolithic Speech APIs
Why are venture-backed startups and Fortune 500 enterprises rejecting closed speech-to-speech APIs (like the OpenAI Realtime API) in favor of the unified Deepgram + Daily + Pipecat stack?
The answer lies in gross margin economics at scale.
Unit Cost Analysis: 1,000 Hours of Voice AI Calling
| Stack Component | Open Stack (Deepgram + Daily + Pipecat + Groq) | Closed API (OpenAI Realtime API - GPT-4o) | Delta / Savings |
|---|---|---|---|
| Speech-to-Text (STT) | Deepgram Nova-3: $0.0043/min ($0.258/hr) | Bundled into input audio token rate | — |
| LLM Reasoning | Groq Llama 3.3 70B: $0.59/M tokens (~$0.65/hr) | $100.00/M input audio tokens + $200.00/M output | ~94% cheaper |
| Text-to-Speech (TTS) | Deepgram Aura-2: $0.015/1k chars (~$0.90/hr) | Bundled into output audio token rate | — |
| Media Transport | Daily WebRTC Mesh: $0.004/min ($0.240/hr) | WebRTC included in closed price | — |
| Orchestration Runtime | Pipecat (Open Source BSD 2-Clause: $0.00) | Proprietary Runtime: $0.00 | — |
| TOTAL COST PER HOUR | $2.05 / hour | 36.00 / hour | 91.4% Cost Reduction |
| Cost for 10,000 Call Hours | $20,480 | $270,000 | Saves $249,520 / mo |
| Cost for 100,000 Call Hours | $204,800 | $2,700,000 | Saves $2,495,200 / mo |
For an enterprise contact center or sales development agency running 50,000 hours of calls per month:
- Using OpenAI Realtime API: Costs $1.35 Million per month, crushing software gross margins to less than 35%.
- Using Deepgram + Daily + Pipecat: Costs $102,400 per month, preserving a healthy 88%+ software gross margin.
The Pipecat Foundation: Governance and Vendor Neutrality
The acquisition immediately triggered scrutiny from rival speech infrastructure companies. Will Deepgram deprioritize Cartesia, ElevenLabs, or AssemblyAI inside the Pipecat repository?
Scott Stephenson and Kwindla Kramer instituted a formal governance structure to prevent vendor capture:
┌────────────────────────────────────────────────────────────────────────────────────────┐
│ THE PIPECAT FOUNDATION GOVERNANCE │
├────────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ STEERING COMMITTEE │
│ ┌────────────────────────────┬────────────────────────────┐ │
│ │ Deepgram Engineering Lead │ Third-Party Model Partner │ │
│ ├────────────────────────────┼────────────────────────────┤ │
│ │ Independent Open Source AI │ Enterprise Voice Builder │ │
│ │ Infrastructure Delegate │ Production Delegate │ │
│ └────────────────────────────┴────────────────────────────┘ │
│ │ │
│ ▼ │
│ HEAD OF OPEN SOURCE: KWINDLA KRAMER │
│ │ │
│ ┌────────────────┴────────────────┐ │
│ ▼ ▼ │
│ [ Core Framework Engine ] [ Ecosystem Plugins ] │
│ - BSD 2-Clause License - Cartesia, ElevenLabs, Azure │
│ - Frame Transport Pipeline - OpenAI, Anthropic, Groq, Together │
│ - RCS State Specification - Twilio, Telnyx, Daily, LiveKit │
└────────────────────────────────────────────────────────────────────────────────────────┘
- Permissive BSD 2-Clause Licensing: The foundation's charter legally guarantees that Pipecat cannot be relicensed under BSL, SSPL, or proprietary commercial restrictions.
- Multi-Model Commit Rights: Maintainers from third-party speech providers (including Cartesia and ElevenLabs) retain merge rights over their respective service modules under
pipecat.services.*. - Automated CI Regression Testing: The Pipecat GitHub Actions test suite enforces latency and compatibility benchmarks equally across all registered STT and TTS services. Any commit that regresses a third-party service build is automatically blocked.
Production Implementation: A Full Resilient Voice Agent in Pipecat
Below is a complete, production-grade implementation of a voice AI agent built with Pipecat, leveraging Deepgram Nova-3 for STT, Deepgram Aura-2 for TTS, Silero VAD v5 for barge-in, Daily for WebRTC transport, and Anthropic Claude 3.5 Haiku for low-latency reasoning:
import asyncio
import os
import sys
from loguru import logger
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask, PipelineParams
from pipecat.transports.services.daily import DailyTransport, DailyParams
from pipecat.services.deepgram import DeepgramSTTService, DeepgramTTSService
from pipecat.services.anthropic import AnthropicLLMService
from pipecat.audio.vad.silero import SileroVAD
from pipecat.processors.aggregators.llm_response import (
LLMAssistantResponseAggregator,
LLMUserResponseAggregator
)
# Configure structured logging
logger.remove()
logger.add(sys.stderr, level="INFO", format="<green>{time:HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | {message}")
async def main():
room_url = os.getenv("DAILY_ROOM_URL")
room_token = os.getenv("DAILY_TOKEN")
if not room_url:
logger.error("DAILY_ROOM_URL environment variable is missing.")
return
# 1. Initialize Daily WebRTC Edge Transport
transport = DailyTransport(
room_url=room_url,
token=room_token,
bot_name="ToughTongue-Inference-Bot",
params=DailyParams(
audio_in_enabled=True,
audio_out_enabled=True,
camera_in_enabled=False,
camera_out_enabled=False,
vad_enabled=True,
vad_audio_passthrough=True,
vad_analyzer=SileroVAD(
speech_threshold=0.65,
min_speech_duration_ms=250,
min_silence_duration_ms=480
)
)
)
# 2. Initialize Streaming Speech-to-Text (Deepgram Nova-3)
stt = DeepgramSTTService(
api_key=os.getenv("DEEPGRAM_API_KEY"),
model="nova-3",
language="en",
smart_format=True,
interim_results=True,
endpointing=250 # Milliseconds of silence to trigger final transcript
)
# 3. Initialize Streaming LLM (Anthropic Claude 3.5 Haiku)
llm = AnthropicLLMService(
api_key=os.getenv("ANTHROPIC_API_KEY"),
model="claude-3-5-haiku-20241022",
system_prompt=(
"You are an ultra-fast, natural conversational voice assistant. "
"Keep answers concise (under 2 sentences). Avoid markdown, bullets, or complex symbols."
)
)
# 4. Initialize Streaming Text-to-Speech (Deepgram Aura-2)
tts = DeepgramTTSService(
api_key=os.getenv("DEEPGRAM_API_KEY"),
voice="aura-asteria-en",
sample_rate=16000
)
# 5. Assemble Context Aggregators for Conversational State
user_aggregator = LLMUserResponseAggregator()
assistant_aggregator = LLMAssistantResponseAggregator()
# 6. Build the Linear Pipeline
pipeline = Pipeline([
transport.input(), # Ingest WebRTC audio frames
stt, # Stream PCM to Nova-3 -> Emit TextFrames
user_aggregator, # Aggregate user utterances
llm, # Stream tokens from Claude 3.5 Haiku
tts, # Synthesize Aura-2 audio chunks
transport.output(), # Stream audio back to caller
assistant_aggregator # Record agent turn in history
])
task = PipelineTask(
pipeline,
PipelineParams(
allow_interruptions=True,
enable_metrics=True,
report_only_initial_ttfb=False
)
)
# 7. Event Handlers
@transport.event_handler("on_first_participant_joined")
async def on_first_participant_joined(transport, participant):
logger.info(f"Caller connected: {participant['id']}. Sending greeting...")
await task.queue_frames([
tts.say("Hello! I am your AI assistant. How can I help you today?")
])
@transport.event_handler("on_participant_left")
async def on_participant_left(transport, participant, reason):
logger.info(f"Caller {participant['id']} hung up. Terminating pipeline.")
await task.cancel()
# 8. Run the Agent Loop
runner = PipelineRunner()
logger.info("Voice AI Agent initialized. Listening on Daily edge...")
await runner.run(task)
if __name__ == "__main__":
asyncio.run(main())
What This Means for Voice AI Founders & Engineering Leaders
The acquisition of Daily by Deepgram marks the end of the "hobbyist glue code" era in conversational voice AI.
For the past two years, teams building voice agents had to act as systems integrators—cobbling together WebSockets, handling NAT traversal failures, tuning VAD sensitivities in Python, and negotiating billing across four separate providers.
With Deepgram + Daily + Pipecat, developers receive a production-grade, open-source stack that rivals closed speech-to-speech models in latency (sub-350ms), beats them by 10x in inference cost, preserves full code inspectability, and protects long-term company enterprise value through the independent Pipecat Foundation.
Frequently Asked Questions
Did Deepgram acquire Daily or just the Pipecat framework?
Deepgram acquired Daily Inc. entirely, which includes Daily's proprietary global WebRTC edge media network, Daily Prebuilt, commercial video/audio APIs, the engineering team, and the open-source Pipecat framework.
How much did Deepgram pay for Daily?
The purchase price and financial transaction details were kept strictly confidential and not disclosed by either party.
Will Pipecat favor Deepgram models over Cartesia or ElevenLabs?
Pipecat is governed by the independent Pipecat Foundation under a BSD 2-Clause license with an open steering committee. While Deepgram will offer optimized zero-copy hardware bindings, Pipecat's modular frame architecture ensures first-class support for Cartesia, ElevenLabs, OpenAI, Groq, and AssemblyAI.
What is the Real-Time Context Standard (RCS)?
RCS is an open protocol co-developed by Deepgram and Pipecat that standardizes how conversation transcripts, circular audio buffers, active tool states, and calibrated VAD profiles are serialized and handed off between voice agents mid-call with sub-50ms latency.
How does this stack compare to the OpenAI Realtime API?
The Deepgram + Daily + Pipecat stack provides complete code transparency, allows you to swap individual models, cuts costs by 85%–92% (24.00–$36.00/hr), and prevents vendor lock-in while matching closed API latency.