Start in 10 minutes.

Focus in the transport filters, Turn in the VAD and turn strategies, Pulse through an observer. Your STT, LLM and TTS stay as they are.

# pip install "tenms[pipecat]" "pipecat-ai[daily,deepgram,openai,elevenlabs]"
import os
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask
from pipecat.processors.aggregators.llm_context import LLMContext
from pipecat.processors.aggregators.llm_response_universal import LLMContextAggregatorPair, LLMUserAggregatorParams
from pipecat.services.deepgram.stt import DeepgramSTTService
from pipecat.services.elevenlabs.tts import ElevenLabsTTSService
from pipecat.services.openai.llm import OpenAILLMService
from pipecat.transports.daily.transport import DailyParams, DailyTransport
from tenms.pipecat import TenmsCall

async def run_bot(room_url: str, token: str | None):
    tenms = TenmsCall()   # one per call; license from TENMS_LICENSE, focus_profile="stt"

    transport = DailyTransport(room_url, token, "Tenms Bot", DailyParams(
        audio_in_enabled=True, audio_out_enabled=True,
        audio_in_filter=tenms.focus_filter(),        # Focus: cleaned caller audio
        audio_out_filter=tenms.reference_filter(),   # agent playback -> echo reference
    ))
    stt = DeepgramSTTService(api_key=os.environ["DEEPGRAM_API_KEY"])
    llm = OpenAILLMService(api_key=os.environ["OPENAI_API_KEY"],
                           settings=OpenAILLMService.Settings(model="gpt-4o-mini"))
    tts = ElevenLabsTTSService(api_key=os.environ["ELEVENLABS_API_KEY"],
                               settings=ElevenLabsTTSService.Settings(voice=os.environ["ELEVENLABS_VOICE_ID"],
                                                                     model="eleven_flash_v2_5"))

    context = LLMContext([{"role": "system", "content": "You are a helpful phone agent."}])
    user_agg, assistant_agg = LLMContextAggregatorPair(context, user_params=LLMUserAggregatorParams(
        vad_analyzer=tenms.vad_analyzer(),                   # gated VAD
        user_turn_strategies=tenms.user_turn_strategies(),   # Turn
    ))
    proc = tenms.processor()                                 # after STT, before the user aggregator
    pipeline = Pipeline([transport.input(), stt, proc, user_agg, llm, tts,
                         transport.output(), assistant_agg])
    task = PipelineTask(pipeline, observers=[tenms.observer()])   # agent text -> echo rejection

    @proc.event_handler("on_call_summary")
    async def on_summary(processor, summary):
        print(summary["failure"], summary["quality"])        # also posted to the dashboard

    await PipelineRunner().run(task)

Tenms fills the VAD, turn-detector and noise-cancellation slots of AgentSession; attach() wires the echo reference and the summary.

# pip install "tenms[livekit]" "livekit-agents[deepgram,openai,elevenlabs]"
from livekit import agents
from livekit.agents import AgentSession, room_io
from livekit.plugins import deepgram, elevenlabs, openai
from tenms.livekit import TenmsAgent, TenmsLiveKit

async def entrypoint(ctx: agents.JobContext):
    call = TenmsLiveKit()   # license from TENMS_LICENSE, focus_profile="stt"
    session = AgentSession(
        stt=deepgram.STT(), llm=openai.LLM(model="gpt-4o-mini"), tts=elevenlabs.TTS(),
        vad=call.vad(),
        turn_handling={"turn_detection": call.turn_detector(),
                       "interruption": {"mode": "vad", "min_duration": 0.3}},
    )
    await session.start(
        agent=TenmsAgent(call, instructions="You are a helpful phone agent."),
        room=ctx.room,
        room_options=room_io.RoomOptions(audio_input=room_io.AudioInputOptions(
            noise_cancellation=call.noise_cancellation())),   # Focus
    )
    call.attach(session)   # agent speaking state, echo reference, transcripts, summary

    @call.on_summary
    def _(summary):
        print(summary["failure"], summary["quality"])

if __name__ == "__main__":
    agents.cli.run_app(agents.WorkerOptions(entrypoint_fnc=entrypoint))

Edge speaks the ElevenLabs Agents protocol. Your license must list the agent ids it may reach; the browser only ever sees a session token.

# Backend: holds the license, hands the browser a 5-minute session token.
# pip install tenms fastapi uvicorn
import os
from fastapi import FastAPI, HTTPException
from tenms.control import ControlError, amint_session_token

app = FastAPI()

@app.post("/api/voice-session")
async def voice_session(agent_id: str):
    # authenticate *your* user here before minting
    try:
        token, expires_at = await amint_session_token(os.environ["TENMS_LICENSE"], ttl_secs=300)
    except ControlError as e:   # fatal: bad, revoked or expired license -> don't retry
        raise HTTPException(503 if e.retryable else 403, e.code)
    return {"signed_url": f"wss://edge.tenms.cloud/v1/elevenlabs/stream?agent_id={agent_id}&token={token}",
            "expires_at": expires_at}

One WebSocket per call, from any language: PCM16 in, cleaned audio and JSON events back. tenms.edge.EdgeClient wraps the same protocol.

# Any language works; this is Python with the plain websockets package.
import asyncio, json, websockets

EDGE = "wss://edge.tenms.cloud/v1/stream"

async def call(token, mic_frames, ref_frames, on_audio, on_event):
    async with websockets.connect(EDGE, additional_headers={"Authorization": f"Bearer {token}"}) as ws:
        await ws.send(json.dumps({"type": "start", "sample_rate": 16000,
                                  "call_id": "call-123", "focus_profile": "stt"}))
        ready = json.loads(await ws.recv())   # {"type": "ready", ..., "focus_profile": "stt"}

        async def read():                     # keep reading: Edge drops a client that stops for 10 s
            async for msg in ws:
                if isinstance(msg, bytes):
                    on_audio(msg[1:])         # 0x01 + cleaned caller audio, one 10 ms frame each
                    continue
                ev = json.loads(msg)          # speech_start, turn_end, interruption, quality, error
                if ev["type"] == "summary":
                    return ev["summary"]      # CallSummary, also posted to your dashboard
                on_event(ev)

        reader = asyncio.create_task(read())
        await ws.send(json.dumps({"type": "agent_speaking", "speaking": True}))
        for mic, ref in zip(mic_frames, ref_frames):  # PCM16 LE mono at 16 kHz
            if ref:
                await ws.send(b"\x02" + ref)          # agent playback first, as played
            await ws.send(b"\x01" + mic)              # caller audio
            await asyncio.sleep(len(mic) / 32000)     # real time (2 bytes x 16,000 per second)
        await ws.send(json.dumps({"type": "transcript", "text": "hold on", "is_final": True}))
        await ws.send(json.dumps({"type": "end"}))
        return await reader