Skip to main content

​
Overview

Cekura is a simulation and production monitoring platform for voice AI agents. The broad idea is to use the same evaluation system across the full lifecycle of a Pipecat agent: simulate conversations before deployment, validate infrastructure continuously in CI, monitor real calls after deployment with metrics, dashboards, and alerts, and turn production issues back into new simulations so you can fix regressions and verify them before shipping again.
With Cekura, you can:
  • Treat simulations and monitoring as one continuous QA workflow
  • Connect to Pipecat through telephony, SIP, or native Pipecat WebRTC flows
  • Run scenario-based tests from the dashboard or API with automated or manual session control
  • Track quality with predefined metrics and custom metrics tailored to your agent’s workflow

​
Simulations

Testing in Cekura is built around scenarios, metrics, and repeatable runs. The main design choice is how you want Cekura to connect to your Pipecat agent:
  • Use telephony or SIP when you want to validate the full voice and network path
  • Use native Pipecat connections when you want faster, more direct WebRTC-based testing
After you choose the connection method, the workflow is straightforward: create or select scenarios, run them from the dashboard or your CI pipeline, and review transcripts, recordings, run status, and metrics in Cekura. Telephony and SIP are useful when you want the full call path in the loop; native Pipecat connections are better when you want faster and more direct WebRTC-based simulation against your Pipecat runtime.

​
Automated Pipecat connection

For Pipecat Cloud agents, configure the following fields in Cekura:
  • Provider: Select Pipecat as the voice integration provider
  • Assistant ID: Optional Pipecat assistant identifier
  • Pipecat Cloud API Key: Used by Cekura to create and manage sessions
  • Pipecat Agent Name: Identifier used for your agent in Pipecat
  • Agent Configuration (JSON): Optional request body sent to Pipecat’s start endpoint
  • Room Properties (JSON): Optional Daily room configuration for the WebRTC session
After setup, you can run scenarios from the dashboard or API and let Cekura handle session creation, lifecycle management, execution, and cleanup automatically. This is the simplest path for repeatable Pipecat Cloud simulations.

Automated Pipecat Testing

Configure Pipecat Cloud credentials once and let Cekura create and manage sessions for each test run.

Manual Pipecat Testing

Provide your own room URL and token when you want explicit control over Pipecat session creation and lifecycle.

​
Manual Pipecat connection

If you want to control the session yourself, Cekura also supports a manual Pipecat connection flow. In this mode, you provide the Pipecat room URL and token for each run, and Cekura joins the session you created instead of provisioning one automatically. This mode is useful when you need custom session orchestration, want to test nonstandard environments, or already manage Pipecat rooms in your own infrastructure.
The automated flow is the best default for Pipecat Cloud. Use the manual flow when you need explicit control over room creation and access tokens.

​
Infrastructure Suite

For infrastructure-focused validation, Cekura provides an Infrastructure Suite with 18+ pre-built scenarios for latency, audio quality, interruption handling, language support, and failure cases such as packet loss and rapid-fire speech. Instead of building these tests from scratch, you can add the suite to your project from the Cekura dashboard and run the scenarios as a group. This makes it a good fit for validating the parts of your stack around the LLM itself, such as transport behavior, turn-taking, silence handling, and voice pipeline stability.

Pre-Built Infra Tests

Add Cekura’s predefined infrastructure scenarios to your project with the appropriate metric mappings already set up.

GitHub Actions CI

Run tagged infrastructure scenarios automatically on pull requests, pushes, or scheduled workflows.
Cekura documents this suite as a good fit for CI/CD. A practical setup is to tag those scenarios as infrastructure-suite and execute them on every pull request: 
name: Cekura Infrastructure Tests

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  infrastructure-tests:
    runs-on: ubuntu-latest
    steps:
      - name: Run Cekura Infrastructure Suite
        uses: cekura-ai/cekura-github-actions@v1.0.0
        with:
          agent_id: ${{ vars.AGENT_ID }}
          tags: "infrastructure-suite"
          api_key: ${{ secrets.CEKURA_API_KEY }}
This gives you a straightforward CI gate for infrastructure regressions before you ship changes to your Pipecat agent.

​
Production observability

Cekura can also monitor production calls after they complete. For Pipecat, the core pattern is simple: send completed calls to Cekura, use metrics and dashboards to track quality, infrastructure health, and workflow performance over time, then turn failed or interesting real calls into new simulations so the same issues are covered in your future test suite.

​
Send calls to Cekura

If you want observability for Pipecat traffic, send recordings and transcripts to Cekura’s observability API: 
POST https://api.cekura.ai/observability/v1/observe/
X-CEKURA-API-KEY: <your-cekura-api-key>
Content-Type: application/json
The observability API accepts transcript_type: "pipecat" along with either an agent ID or assistant_id, plus a voice_recording or voice_recording_url.

​
Example: send a Pipecat production call

import requests

headers = {
    "X-CEKURA-API-KEY": "<your-cekura-api-key>",
    "Content-Type": "application/json",
}

payload = {
    "call_id": "call_123",
    "agent": 2421,
    "transcript_type": "pipecat",
    "voice_recording_url": "https://storage.example.com/recordings/call_123.mp3",
    "transcript_json": [
        {
            "role": "user",
            "content": "I need help with my order",
            "timestamp": "2026-04-03T20:15:01Z",
        },
        {
            "role": "assistant",
            "content": "Sure, let me look that up for you.",
            "timestamp": "2026-04-03T20:15:03Z",
        },
    ],
    "call_ended_reason": "customer-ended-call",
    "timestamp": "2026-04-03T20:15:45Z",
}

response = requests.post(
    "https://api.cekura.ai/observability/v1/observe/",
    headers=headers,
    json=payload,
)

result = response.json()
print(result)
Once calls are ingested, Cekura stores them for review in its observability workflow, where you can inspect call logs, transcripts, recordings, and evaluation output.

​
Metrics and performance insights

Cekura’s metrics system can be used in both simulations and production monitoring. For reference, see the metrics overview, predefined metrics, and custom metrics. Relevant predefined metrics for production monitoring include:
  • Latency with percentile statistics for response-time monitoring
  • Infrastructure Issues to detect failures to respond within a configured timeout
  • Transcription Accuracy for STT quality checks
  • AI Interrupting User and Stop Time After User Interruption for turn-taking quality
  • Gibberish Detection, Average Pitch, and other speech-quality metrics for audio analysis
  • CSAT, Sentiment, and Dropoff Node for agent-performance and user-experience insights
Beyond the predefined set, Cekura also supports custom metrics so you can evaluate whether your agent followed the right workflow, completed key business logic, or handled domain-specific tasks correctly. That is useful for measuring the logical performance of the agent itself, not just infrastructure or audio quality.
For production monitoring, audio recordings improve what Cekura can measure. Several of the speech-quality and turn-taking metrics in their docs require audio, and some require stereo recordings for the most precise results.
For day-to-day operations, Cekura’s observability tooling is designed around dashboards, detailed call logs, and alerting for critical issues and anomalies. In practice, that gives you voice-quality metrics, agent-performance insights, and infrastructure-failure visibility in one monitoring loop.

​
Next steps

Pipecat Integration Guide

Step-by-step setup for running automated Pipecat tests in Cekura.

Testing Overview

Start with Cekura’s broader guide to scenario creation, execution, and testing workflows.

Observability Overview

Learn how Cekura structures production monitoring, observability, and call review workflows.

Metrics Overview

Review predefined metrics and custom metrics for workflow, logic, speech, and infrastructure evaluation.