Sell the conversation, not the message
A ~15-turn agent chat is one billed 24-hour session — not a stream of metered texts. The unit Google doesn't sell, manufactured for you.
Agent-native RCS messaging with automatic SMS fallback — one REST API, built to be driven by agents. We turn the carrier's 24-hour conversation into the runtime your agent lives in, and handle the 8–16-week compliance gauntlet underneath.
Built directly on Google RBM, with carrier-grade SMS fallback — abstracted into one agent-native surface.
Most messaging APIs sell a primitive, or raw reachability. Cadence sells the conversation — with compliance productized beneath it.
A ~15-turn agent chat is one billed 24-hour session — not a stream of metered texts. The unit Google doesn't sell, manufactured for you.
Rich cards, quick-reply chips, verified sender where RCS is reachable. Automatic, seamless SMS fallback where it isn't.
Drop-in tools for any agent framework. Your LLM lives inside the conversation — it doesn't manage messaging infrastructure.
The 8–16-week carrier gauntlet, opt-in vault, and STOP/HELP handling — abstracted into a status bar.
Verified-sender branding, a pre-disclosed fallback identity so a downgrade never reads as smishing, and PHI-safe-minimal templates enforced before anything reaches the wire.
Agent-initiated, opt-in enforced, fallback automatic, engagement measured.
Your agent speaks first over RCS, with opt-in provenance and a PHI-safe template. Reachability and channel are resolved for you.
Consumer replies — chip taps and free text — arrive as typed events. Attach a flow and we answer them for you; register a webhook and we POST them to you.
Undeliverable? We flip to a branded SMS automatically and tell you it happened. Every leg is measured against your SMS baseline.
One POST with a sandbox key opens an agent-initiated conversation. Rich content auto-degrades to text on the SMS leg, and the channel flip arrives as an event rather than as a surprise.
// Attach a `flow` and Cadence answers every reply itself —
// no process of yours has to be running.
await fetch("https://api.cadencercs.com/v1/conversations", {
method: "POST",
headers: {
authorization: `Bearer ${process.env.CADENCE_KEY}`,
"content-type": "application/json",
},
body: JSON.stringify({
to: "+12025550123", agentId, brandId,
useCase: "transactional",
optin: { method: "appointment_booking", capturedAt },
flow: {
id: "confirm", name: "Appointment",
disclaimer: "Msg & data rates may apply. Reply STOP to opt out.",
steps: [{
id: "confirm",
text: "Your 3pm is confirmed. Reschedule?",
suggestions: ["Reschedule", "Cancel appt", "All good"],
smsFallbackText: "Your 3pm is confirmed. Reply 1 reschedule, 2 cancel, 3 all good.",
}],
closing: "Thanks — see you then.",
},
}),
});
One price covers a 24-hour session and every turn inside it. Saying “usage-based” without a number is how a no-sales-call product acquires a sales call, so here it is.
Any number of turns within the 24-hour session. Same price in every market.
The fallback leg, metered the way it is actually billed. No session rate exists for SMS anywhere, so charging per conversation would mean charging you for turns that may never happen.
Simulated delivery, real API. Build and test the whole loop before anything is billable.
An RCS conversation nobody replies to never opens a session, so it includes six messages and then bills 5.5¢ per additional message. SMS is per message from the first one. Carrier pass-through fees are billed separately, at cost. GET /v1/usage returns the same numbers for your own account, itemised.
Preview pricing. These are the rates we charge today and they are what the API bills, but they are provisional until real traffic shows the true turn distribution — we will give notice before changing them for anyone already sending.
Apple turned RCS on. The channel inflected in the same window agents did.
The conversation layer for the agent era — RCS-first, fallback-native, compliance-handled.