Operator is an infrastructure platform that provides the core building blocks for scalable, production-ready AI agents. We provide the infrastructure and tools needed to build, deploy, and manage production-grade conversational AI agents. You focus on your agent’s business logic—we handle the connective tissue that lets agents access external systems, talk to users, and operate in real time.

​
What Operator provides

Operator abstracts away the challenging infrastructure problems of conversational AI:
  • Multi-channel conversation handling: Deploy the same agent across phone calls, SMS, web chat, and email without rebuilding for each channel
  • Real-time voice orchestration: Sub-500ms response times with sophisticated interruption handling and turn-taking managed by specialized models
  • Scalable agent runtime: Elastic worker pools that absorb traffic spikes across inbound and outbound flows
  • Production-grade tooling: Built-in evals, versioning, partial rollouts, and rich analytics for continuous improvement.

​
Core architecture

​
Conversational agents

A conversational agent is a language model with instructions and tools, wrapped in infrastructure purpose-built for real-time and asynchronous conversations with users. Each conversation runs in its own dedicated process, maintaining state across the full interaction—whether it’s a one-hour phone call or a multi-day async email thread. Conversational agents maintain memory across conversations—from simple summaries of recent interactions to full searchable conversation history. This enables use cases like customer service agents that remember previous issues or appointment scheduling that builds on past preferences. Learn more about agent fundamentals

​
Prompting and behavior control

Operator supports multiple prompting strategies that scale with complexity:
  • Fixed prompts: Static instructions for simple, single-goal conversations—like confirmations or data collection—with support for dynamic templating based on context or state.
  • Intent-routing prompts: Structured prompts for multi-path scenarios where the agent dynamically selects from many possible workflows, such as customer support triage.
  • Workflow prompts: Strict, state-driven flows designed for interactions that require a specific sequence of actions.
For intent-routing and workflow scenarios, we handle dynamic context management under the hood—keeping the active context small and focused to improve instruction-following and reduce latency.

​
Tools

Tools extend your agent’s capabilities beyond simple conversations, enabling actions like scheduling appointments, looking up customer information, or escalating to human agents. In a conversation, imagine the first party is you, the builder of the agent, conversing with the second party, the conversational agent itself. A third party is an external system controlled neither by you nor the conversational agent.
  • First-party custom API integrations: Bring your own APIs or MCP servers to connect to your internal databases, services, and business systems with full authentication and state management support.
  • Second-party platform tools: Built-in conversation capabilities like call transfers, DTMF tone handling, sending SMS during calls, and voicemail detection.
  • Third-party integrations: One-click connections to common business tools including Google Calendar, Salesforce, Zendesk, Notion, and other CRM systems.
For simple use cases, platform tools and pre-built integrations are typically sufficient. Complex business scenarios, however, will require custom API integrations to access internal customer data, case management systems, or specialized business logic.

​
Channels

We use the program-once-use-everywhere approach, so the same agent runs across multiple communication channels without modification: Voice CallsTwilio, WebRTC Real-time ChatChat Widget Async MessagesSMS, Email
  • Phone: Phone calls with optimized latency and interruption handling
  • WebRTC: In-app or browser-based voice calls
  • Realtime chat: Websocket-based real-time chat
  • Async chat: HTTP-based async chat
  • SMS (coming soon): Async text-based conversations
  • Email (coming soon): Async email threads
Channel-specific capabilities (like sending links via SMS during a phone call) are available through platform tools when relevant. We also support custom channels, so you can build your own.

​
Integration and customization

​
API-first architecture

Almost everything available in the dashboard is also accessible through HTTP APIs, enabling:
  • Programmatic agent creation and configuration
  • Real-time conversation event streaming
  • Custom dashboard and workflow integrations
  • Automated prompt updates and deployment
If there’s a feature you need that isn’t available in the API, let us know and we’ll build it.

​
Event system

We expose real-time events for building custom interfaces and integrations:
  • Conversation transcripts and state changes
  • Tool calls and external API interactions
  • Custom events pushed from your internal systems
  • Agent state transitions and workflow progression

​
AgentOps

​
Deployment and versioning

  • Versioning: Every agent configuration is tracked and versioned, with full rollback support.
  • Gradual rollouts: Release updates to a controlled slice of traffic to validate changes safely.
  • A/B testing: Run side-by-side experiments and compare versions with built-in metric tracking.

​
Evaluation and QA

Operator includes built-in systems for measuring and improving agent performance:
  • Simulated conversations: Use LLM-driven scenario testing to validate agent behavior across a range of conversation patterns, before deploying to real users.
  • Automated evaluations: LLM-based judges review transcripts and conversation traces against configurable criteria to score quality, accuracy, and coverage.
  • Conversation analytics: Surface trends, outliers, and failure patterns across conversations to guide prompt iteration and agent improvement.

​
Getting started

Our platform is built for iterative development—start simple and add complexity as you better understand your use case:
  1. Begin with basic prompting for straightforward conversations
  2. Add integrations when you need external data and actions
  3. Implement evaluation to measure and improve performance
  4. Scale with advanced features like intent-routing and custom APIs
Most teams can deploy a functional agent in hours, then iterate based on real conversation data and feedback. Jump into the quickstart guide to build your first agent, or explore the API reference for programmatic integration.