Cloudonix Core Concepts: CXML, Sessions, and Building Voice Agents

Key Takeaways

• Cloudonix is a CPaaS built on four primitives: programmable voice (CXML), REST call-control APIs, elastic SIP trunking, and mobile/web SDKs.
• CXML (Cloudonix Markup Language) is an XML call-flow language rooted at <Response>; it resembles Twilio's TwiML but is not a drop-in replacement — some verbs differ.
• The <Converse> verb builds an AI conversation directly in the call flow, with attributes for model (e.g. openai:gpt-4o, anthropic:claude-3-5-haiku-latest), voice, language, and tool calling.
• Cloudonix bills by session, not per minute, with a forever-free tier of 500 sessions/month — predictable cost for infrastructure-style voice usage.
• You can build an agent two ways: declaratively in CXML with <Converse>, or by streaming media to an external pipeline via <Connect><Stream> (Pipecat, Gemini, and others).

Most teams meet Cloudonix through a single integration — a SIP trunk for a voice agent — and never see the rest of the platform. That's a missed opportunity, because the core concepts are small in number and compose cleanly: once you understand CXML, the <Converse> verb, sessions, and the SDKs, you can build a full voice agent without bolting on a separate orchestration framework.

Cloudonix core concepts come down to four building blocks: CXML for declarative call flows, a REST API for controlling live calls, elastic SIP trunking for connecting to the phone network, and mobile/web SDKs for in-app voice. CXML is the center of gravity — a <Response>-rooted XML language whose verbs (<Dial>, <Gather>, <Converse>, <Connect>) describe what happens on a call. Billing is session-based rather than per minute.

CXML: the Call-Flow Language

CXML (Cloudonix Markup Language) is Cloudonix's XML scripting language for voice applications. Every document is rooted at <Response>, and the verbs nested inside instruct the runtime on what to do with the call (Cloudonix CXML docs). When a call arrives, Cloudonix fetches your application URL and executes the CXML you return — top to bottom, verb by verb. It is the same request/response model TwiML uses, which is deliberate.

Cloudonix designed CXML to resemble TwiML so teams familiar with Twilio feel at home, but it is explicit that the two are not identical: some TwiML verbs are unsupported, and CXML defines verbs that TwiML lacks (Cloudonix). Treat your TwiML knowledge as a head start, not a guarantee — verify each verb against the Cloudonix documentation rather than assuming parity. The core verbs you'll reach for most:

• <Dial> — connect the call to another destination; with the <Service> noun, to an AI voice agent provider or your own SIP service.
• <Gather> — collect caller input (speech or DTMF), often wrapping <Converse> for conversational turns.
• <Converse> — run an AI conversation inline (covered below).
• <Connect> — open an audio connection to an external service, including <Stream> for WebSocket media.
• Supporting operations exposed through the platform and Make.com: Say, Play, Record, Reject, Hangup, Conference, and Transfer.

The Converse Verb: an AI Agent in the Call Flow

The <Converse> verb is what makes Cloudonix more than a trunk — it runs an LLM-driven conversation (STT, LLM, TTS) directly inside the call flow, no external agent server required. It accepts attributes including model (for example openai:gpt-4o or anthropic:claude-3-5-haiku-latest), voice (default "woman"), language (default "en-US"), temperature, and sessionTools for actions like hangup, redirect, and dial (Cloudonix Converse docs).

Inside <Converse>, child nouns shape the conversation: <System> sets the system prompt, <User> seeds user context, <Tool> with <Description> defines callable tools, and <Speech /> configures speech output and must be the last child. A minimal agent reads as a single document:

<Response>
  <Converse model="anthropic:claude-3-5-haiku-latest" language="en-US">
    <System>You are a scheduling assistant for a dental clinic. Confirm or
            reschedule appointments. Keep replies under two sentences.</System>
    <Tool name="reschedule">
      <Description>Move an appointment to a new date and time.</Description>
    </Tool>
    <Speech voice="woman"/>
  </Converse>
</Response>

That is a working voice agent: pick a model, write a system prompt, declare your tools, set the voice. For straightforward flows this is the fastest way to ship — but it also couples your agent logic to CXML and Cloudonix's model routing, which is the tradeoff to weigh against the streaming approach below.

Two Ways to Build: Declarative vs Streaming

Cloudonix gives you two architectures for a voice agent, and choosing correctly up front saves a rebuild later. The declarative path is <Converse> — Cloudonix orchestrates STT, LLM, and TTS for you. The streaming path is <Connect><Stream>, which opens a WebSocket media connection to an external pipeline you control, such as Pipecat or Gemini (Cloudonix Connect docs).

Use <Converse> when you want speed and Cloudonix's managed pipeline is enough. Use <Connect><Stream> when you need full control of the pipeline — your own VAD tuning, model routing, evaluation logging, or a multi-agent orchestration layer. Prodinit, a Cloudonix implementation partner, makes this decision on every voice build: managed convenience versus a self-controlled pipeline you can instrument and optimize. For the high-scale, latency-sensitive systems we run, the streaming path usually wins because it lets us own the latency budget end to end.

Sessions, SDKs, and the Open-Source Client

Two more concepts round out the platform. First, sessions: Cloudonix bills by session rather than per minute, which it frames as the right model for infrastructure-style voice usage. The forever-free tier covers 500 sessions per month with 2 concurrent calls; paid plans start at $69/month (Starter) and $119/month (Professional), with a 14-day no-card trial (Cloudonix pricing). The precise definition of a session isn't published, so map it to your call patterns with Cloudonix before modeling cost.

Second, the SDKs. Cloudonix ships Web, Android, and iOS SDKs to embed voice calling directly in an app — useful when the "phone number" is in-app calling rather than the PSTN. It also maintains sipml5-ng, an open-source (BSD-licensed) modernized fork of the SIPml5 HTML5 SIP client that runs entirely in JavaScript over WebRTC, with signalling over WebSockets per RFC 7118 (sipml5-ng on GitHub). Together the SDKs and CXML cover both ends of the spectrum: declarative server-side call flows and embedded client-side calling.