RCS Campaign Ops
Launch better RCS journeys with zero guesswork.
RCSX gives developers and marketing teams a production-like iPhone emulator, event console, and payload validator in one focused workflow. Prototype faster, test deeper, and ship with confidence.
- Schema validation
- Real-time callbacks
- High-fidelity iPhone preview
No whitelisting needed.
Built for Every RCS Team
One platform for campaign strategy, payload implementation, and enterprise-grade validation workflows.
Prototype high-converting campaigns
Preview rich cards, media, and conversation journeys before launch. Iterate messaging fast without production waits.
Validate payloads and callbacks
Use JSON validation, simulator rendering, and event visibility in one loop to catch issues before release.
De-risk rollout with test coverage
Standardize QA across teams, reduce campaign errors, and launch high-volume programs with more confidence.
From Payload to Event Signal
RCSX compresses the build-and-verify loop into three deterministic steps so teams can move from idea to validated campaign without waiting on carrier cycles.
1
Compose
Draft or paste your RCS payload and validate schema instantly.
2
Render
Preview the exact conversation in a high-fidelity iPhone simulation.
3
Observe
Capture engagement and callback signals in real time for QA and optimization.
Simple Usage-Based Plans
Start free, then scale by message throughput and team size. No lock-in, no hidden setup tier.
Most teams start with Pro and upgrade when throughput grows.
Free
$0
1 seat
10 msgs/day
100 msgs/month
Pro
$10 /month
1 seat
100 msgs/day
1,000 msgs/month
Team
$30 /month
5 seats
1,000 msgs/day
10,000 msgs/month
Enterprise
$200 /month
Unlimited seats
10,000 msgs/day
100,000 msgs/month
Common Questions
Answers to the key decisions teams make before adopting RCS testing infrastructure.
What is RCSX?
An RCS emulator for developers and campaign teams to test business messaging flows before production.
How does the iPhone emulator help?
It provides a realistic mobile rendering surface so teams can validate conversation quality and interaction behavior before launch.
Can I test cards and carousels?
Yes. Rich cards, carousel layouts, media payloads, and interactions are supported.
Is API automation supported?
Yes. Your backend and QA scripts can trigger sends and validate flows programmatically.
Can teams collaborate on QA?
Yes. Product, marketing, and engineering can review the same flows and verify behavior before a campaign goes live.
How are authentication and API keys handled?
Dashboard sessions use JWT authentication, and message APIs use scoped keys with an rcs_* prefix for secure operations.
Can I test user interactions?
Yes. Suggested actions, quick replies, and click flows can be exercised end to end with callback visibility.
Is there a free tier?
Yes. You can start at no cost and upgrade as throughput and collaboration needs grow.
Ready to test your next campaign with confidence?
Set up in minutes, validate rendering, and ship with fewer surprises.
From the RCS X Blog
Release notes, architecture decisions, and feature deep-dives from the team shipping RCS testing infrastructure.
The Agent Communication Crisis: Why Your AI Agent is Stuck in a Terminal
The AI agent revolution is here, but there's one problem: your agents can't communicate with users outside a terminal. Here's why RCS is the solution.
The Agent Communication Crisis: Why Your AI Agent is Stuck in a Terminal
And how to break free.
The Dream vs. The Reality
You're a developer in 2026. You've built an incredible AI agent—maybe it's a customer service bot, a sales qualifier, a mental health companion, or a personal assistant that manages your life.
It works beautifully. You fire up your terminal, type a prompt, and watch your agent reason, respond, and execute tasks with impressive intelligence.
But then you try to actually use it.
You realize: your agent lives in a terminal. Your users live on their phones.
And there's no bridge between them.
The Developer Experience Gap
Here's what building an AI agent looks like today:
You prompt it in a terminal — ChatGPT, Claude, Gemini, doesn't matter. It's you, typing, watching a black screen with green text.
You test it with dummy inputs — Manually typing "what's the weather" or "help me book a flight" over and over.
You deploy it to production — Your agent now "exists" in the world.
And then... nothing. — How does a real user actually talk to it? Through what interface? A web chat widget? A phone call? A mobile app you also have to build?
The uncomfortable truth: we've built incredible AI reasoning engines, but we haven't solved how they talk to the people who need them.
The Terminal Prison
Think about what we're asking users to do:
- "Go to this website" — Instead of receiving a message where they already are
- "Download this app" — Instead of being reached where they already spend time
- "Log in on a separate portal" — Instead of a seamless experience
Meanwhile, your AI agent is sitting in a server somewhere, capable of rich, intelligent, contextual conversations—but outputting JSON to a log file.
This is the Agent Communication Crisis: the disconnect between what AI agents can do and how they can reach people.
Why SMS Isn't the Answer
You might say: "Just use SMS."
And developers are trying. But SMS has fundamental limitations:
| SMS | What Agents Need |
|---|---|
| 160 character limit | Rich, multi-media content |
| No images/video | Cards, carousels, buttons |
| No interactive actions | Quick replies, CTAs |
| No authentication | Brand verification |
| No encryption | Security for sensitive conversations |
SMS was designed for human-to-human text messages. It's not built for agent-to-user communication at scale.
Enter RCS: The Missing Layer
Rich Communication Services (RCS) is what happens when you take the intelligence of a modern messaging app and add business capabilities:
- Rich cards — Images, videos, carousels
- Interactive buttons — Quick replies, CTAs, forms
- Brand verification — Users know it's really you
- End-to-end encryption — Security built in
- Native to the phone — No app download required
RCS is what SMS should have been in 2026.
But here's the real opportunity for AI agent developers:
RCS is the missing communication layer between your agent and your users.
Your agent doesn't need to build a website, a mobile app, or a web chat widget. It just needs to send an RCS message—and your user receives a rich, interactive experience directly on their phone.
The ROI of RCS-Based Agent Communication
Why should developers care? Let's look at the numbers:
1. Reach Without Friction
- Problem: Web chat has 3-5% conversion. Apps have <10% download rates.
- RCS Solution: 90%+ message delivery rates. No downloads. Users already have it.
2. Engagement That Converts
- Problem: Average web chat session is 2 minutes.
- RCS Solution: RCS messages see 4-5x higher engagement than email, 2x vs. SMS.
3. Development Speed
- Problem: Building a custom chat interface takes weeks.
- RCS Solution: Send a message. Done. The UI is already on the user's phone.
4. Trust & Security
- Problem: Users don't trust anonymous chat widgets.
- RCS Solution: Brand verified profiles. E2EE encryption. This is real business messaging.
5. Cost at Scale
- Problem: Web chat infrastructure scales with concurrent users.
- RCS Solution: Carrier-based delivery. Pay per message. Scales infinitely.
The Realization
Here's the shift in thinking:
Before: "I need to build an interface for my AI agent."
After: "My AI agent communicates via RCS. The interface already exists on every phone."
Your agent isn't a website. It isn't an app. It's a communication service. And RCS is the protocol that connects intelligent agents to real people—where they already are.
The Next Problem: Testing
Now here's the catch.
If RCS is the answer, how do you develop and test your agent's RCS communication?
- You can't just "preview" how a message renders across devices
- You can't test different carrier implementations
- You can't debug conversation flows before deployment
- You can't scale-test without real carrier accounts
This is where the market gap emerges: we need RCS emulators for AI agent development.
Because right now, developers are building agents that will communicate via RCS—but they have no way to test, preview, or validate those communications before going live.
The Opportunity
We're at an inflection point:
- AI agents are exploding — Every company is building them
- Mobile is the battleground — Users live on their phones
- RCS is the protocol — Built for business messaging at scale
- Testing infrastructure is missing — No way to develop confidently
The developers who solve the RCS testing problem will own the agent communication layer.
The question isn't whether AI agents need better communication. The question is: who's going to build the tools that make it possible?
The AI Agent Debugging Crisis No One Talks About
Conversational AI Agents need to communicate via multiple channels. RCS is one of the fastest-growing channels — consumers trust it for branding, encryption, security, and rich capabilities. But here's what happens when your AI agent sends a broken RCS card to 50,000 customers.
The AI Agent Debugging Crisis No One Talks About
Conversational AI Agents need to communicate via multiple channels. RCS is one of the fastest-growing channels — consumers trust it for branding, encryption, security, and rich capabilities like carousels, suggested replies, and rich cards.
Last week, Sinch announced Agentic Conversations — "a new set of capabilities designed to operationalize AI agents across global communication channels, enabling enterprises to deploy intelligent agents across messaging, voice, and email at scale."
Infobip launched MCP servers that let AI agents send messages across multiple channels, including RCS. As they describe it: "These servers act as remote connectors, allowing your AI agents to send messages across multiple channels, manage customer data, and run authentication flows, all in a controlled, production-grade environment."
The big players are all-in on AI agents messaging customers via RCS.
But here's the disconnect: When your AI agent sends a broken RCS card to 50,000 customers, you won't know until the complaints roll in.
The Problem
- AI agents iterate FAST — hundreds of message variants per day
- Traditional RCS testing takes 8-16 weeks for carrier approval
- There's no preview environment, no staging, no simulator
- Device fragmentation means the perfect AI-generated message renders as a broken card on Samsung, fine on Pixel, and won't show at all on some carriers
A developer in the r/AI_Agents community put it simply: "Debugging is brutal. Works in testing, then agent takes completely random paths in production."
The Real Cost
Every broken RCS message from an AI agent damages brand trust. And unlike email (where you can test send), or ads (where you can preview), RCS has no pre-flight check.
What an Independent Testing Platform Solves
Rather than waiting 8-16 weeks for carrier approval, brands need a way to validate their AI agent messaging before deployment:
- Instant device-by-device preview across Samsung, Pixel, iPhone
- Flow simulation for multi-turn AI conversations
- A/B testing for AI-generated message variants
- Scale testing to validate agent performance under load
An independent validation and emulation platform — one that works without operator approvals — lets teams catch issues early, iterate fast, and deploy with confidence.
The AI agent revolution in messaging is here. But without proper testing tools, brands are flying blind.
The platform is ready. Is your campaign ready?
The Multi-Region RCS Testing Challenge: Why Global Brands Need a New Approach
RCS is going global. Airtel-Google in India, Apple E2EE RCS in beta, 50B → 200B messages by 2029. But here's what keeps multi-region brand managers up at night: testing doesn't scale globally.
The Multi-Region RCS Testing Challenge: Why Global Brands Need a New Approach
RCS is having a moment. Airtel-Google in India, Apple E2EE RCS now in beta (iOS 26.4), Juniper predicting 50B → 200B messages by 2029. The platforms are ready.
But here's what keeps multi-region brand managers up at night: testing doesn't scale globally.
The State of Global RCS in 2026
The numbers are compelling. RCS adoption is accelerating across markets:
- India: Airtel-Google partnership bringing carrier-backed RCS to 300M+ users
- US: Apple E2EE RCS in beta means iPhone users finally get secure cross-platform messaging
- Europe: Carrier consolidation with Samsung and Google Messages dominating
- Global: Juniper Research predicts 50 billion → 200 billion RCS messages by 2029
2026 is the year global brands stop asking "if RCS" and start asking "how globally."
The Hidden Multi-Region Testing Problem
Launch in the US, UK, and India simultaneously? You're dealing with:
- Different carrier requirements per region — Each carrier has its own approval process, timeline, and technical requirements
- Device penetration varies wildly — Samsung dominates in Asia, Pixel in US, iPhone in UK
- Zero visibility into how your carousel renders across these combinations
- 8-16 weeks of carrier approval before you even know something's wrong
The Routee 2026 report calls out "device differences cause errors" as a top pitfall. For global brands, it's worse — you can't even test device differences ACROSS REGIONS before you're locked into your campaign design.
The Device × Carrier × Region Matrix
Here's the math no one wants to do:
5 devices × 3 carriers × 3 regions = 45 combinations to validate
Same RCS code renders differently based on:
- OS version (Android 14 vs 15)
- Device manufacturer (Samsung vs Pixel vs Nothing)
- Carrier RCS implementation (Jibe vs carrier-managed)
- Regional feature flags
Most brands test zero combinations pre-approval.
A Real Example
We heard from one brand that spent 14 weeks getting carrier approval, only to discover their carousel broke on Samsung devices in their key Asian market. By then, it was too late. They were locked into their campaign design with no way to fix it without resubmitting — and waiting another 8-16 weeks.
The Real Question
The real question isn't "how do we get approved faster" — it's "how do we validate our campaign works across 45+ device × carrier × region combinations BEFORE we submit?"
That's the gap the industry needs to solve.
What Needs to Change
Global brands need:
- Instant device preview across any manufacturer
- Carrier environment simulation for major global carriers
- Regional rendering validation
- Batch testing across combinations
Test in minutes what currently takes 8-16 weeks to discover.
The platforms are ready. The global adoption is happening.
Is your testing strategy ready for multi-region RCS?
#RCS #GlobalMarketing #MarTech #MessagingStrategy #EnterpriseMessaging
AI Agents Can Now Send RCS (But Can't Test It)
Last month, Infobip launched an MCP server that lets AI agents send RCS messages. Here's what's weird: Those AI agents have no way to test what they're sending.
AI Agents Can Now Send RCS (But Can't Test It)
Last month, Infobip launched an MCP server that lets AI agents send RCS messages. Big news, right?
Here's what's weird: Those AI agents have no way to test what they're sending.
Unlike human marketers who can wait 8-16 weeks for carrier approval, AI agents are supposed to iterate fast. They're built to test, learn, and optimize. But with RCS, they hit a wall.
🤖 The AI agent writes a message
📱 It gets sent through the MCP integration
⚠️ But there's no preview, no device testing, no validation
📬 The end user receives something the agent has never seen
This is the paradox of AI agent messaging: We trust AI to write personalized messages at scale, but we have zero visibility into how those messages actually render.
The Challenge Isn't AI Capability. It's RCS Infrastructure.
AI agents need:
- Device-by-device preview (Samsung, Pixel, iPhone all render differently)
- Flow validation before submission
- Instant feedback on rich card rendering
- A/B testing capability without carrier wait times
Sound familiar? It's the same problem brands face—but multiplied. AI agents generate hundreds of campaign variants. Testing each one manually is impossible.
The platforms (Infobip, Klaviyo, Sinch) help you DESIGN campaigns. But nobody built the testing layer.
That's where we see the gap—and the opportunity.
What AI Agents Actually Need
Traditional brands might run 1-3 campaign versions. AI agents? They generate hundreds of personalized variants. And device fragmentation means the same RCS renders differently on Samsung, Pixel, and iPhone.
The multiplication problem: each variant × each device = exponential testing needs
AI agents need:
- Instant device-by-device preview (not 8 weeks)
- Rich card validation (buttons, carousels, media rendering)
- Flow testing (button clicks, user journeys)
- A/B testing without carrier submission
- Real-time rendering feedback
The Platform Gap
What existing platforms provide: Klaviyo, Infobip, TrueDialog, Sinch help DESIGN campaigns.
What's missing: testing, validation, preview capabilities.
Why platform vendors haven't solved this: They focus on differentiation rather than infrastructure.
The opportunity for testing-first solutions? Huge.
RCS X: The AI Agent Testing Layer
RCS X enables instant device preview for AI agents:
- Flow validation before MCP submission
- Batch testing hundreds of variants
- Integration with AI agent workflows
Whether you're building customer service bots, sales assistants, or AI negotiators—test before you deploy. Because in AI agent messaging, what you don't know will hurt you.
What do you think: Is AI agent messaging ready for production, or is the testing gap a dealbreaker?
#RCS #AIMarketing #AgenticAI #MarketingTech #RCSX
Why Your AI Agent Can't Test RCS Messages (And What to Build Instead)
You built an incredible AI agent. Customer service bot? Check. Sales assistant? Check. RCS integration? Well... 'You can deploy today. But testing? That's in 8 weeks.'
Why Your AI Agent Can't Test RCS Messages (And What to Build Instead)
You built an incredible AI agent.
Customer service bot? Check.
Sales assistant? Check.
RCS integration? Well...
"You can deploy today. But testing? That's in 8 weeks."
That's the reality for AI agent developers trying to add RCS to their bots. Unlike email, SMS, or WhatsApp — RCS has no test environment, no staging, no preview.
Your agent passes every test in dev. Then production hits a wall:
- Carrier approval takes 8-16 weeks
- Device rendering is a mystery until launch
- One wrong message format = blocked
The AI Agent Messaging Revolution
The AI agent space is exploding right now.
MCP (Model Context Protocol) is becoming the standard for AI agents to take actions, send messages, and close deals. OpenAI, Anthropic, and Google DeepMind have all adopted MCP. Every major AI provider is enabling agents to interact with external systems.
And RCS? It's the richest messaging channel available. Images, carousels, buttons, suggested actions — all native. Higher engagement than SMS, more features than WhatsApp.
The perfect pairing: AI agents + RCS.
The perfect problem: No way to test it.
The 8-Week Wall
Here's what happens when you try to add RCS to your AI agent:
- You submit your application for RCS Business Messaging
- Legal reviews your documents (2-4 weeks)
- Your brand gets vetted (2-4 weeks)
- Carrier review begins (4-8 weeks)
- You wait
Total timeline: 8-16 weeks. Sometimes longer.
During this time, you can't:
- Preview how your messages render on different devices
- Test conversation flows with rich cards
- Validate that your AI agent's outputs are formatted correctly
- Catch errors before they block your entire campaign
Compare this to WhatsApp: You can sign up for the API, test your bot, and go live in days. RCS? You wait nearly 3 months to find out if your messages even work.
The Device Fragmentation Problem
Even after approval, there's another problem no one talks about:
Same message, different render.
Your AI agent outputs a perfect rich card. But on a Samsung Galaxy, the carousel doesn't scroll. On a Pixel, the buttons are cut off. On iPhone, RCS isn't even enabled by default.
For human designers, this is a nightmare. For AI agents generating content at scale? It's a disaster.
One broken message template = your entire campaign gets blocked by carriers.
And you won't know until production.
What Developers Are Doing Wrong
Here's what most AI agent developers are doing instead of dealing with RCS:
❌ Defaulting to WhatsApp — Easier to integrate, but fewer features, lower engagement
❌ Skipping RCS entirely — Leaving money on the table (35x more likely to be read than email)
❌ Crossing fingers and hoping — Building blind, waiting for approval, then fixing problems in production
The cost? Less interactive messages. Lower conversion rates. Frustrated users.
What You Should Be Doing
Here's the better approach:
✅ Test in a simulator first — Preview your messages without carrier approval
✅ Preview across devices instantly — See how your AI agent's outputs render on Samsung, Pixel, iPhone
✅ Validate conversation flows — Test your entire message sequence before submission
✅ Iterate quickly — Make changes, preview, iterate — no waiting
This is what RCS X provides: a staging environment for RCS messaging.
Your AI agent is ready. Your RCS strategy should be too.
The Future is Simulation
Every messaging channel needs a simulator. That's true for email (test sends), ads (previews), landing pages (staging), and now RCS.
As AI agents become more sophisticated — handling customer service, sales conversations, even negotiations — the need for proper testing only grows.
MCP is enabling AI agents to take actions. RCS is the richest messaging channel. The missing piece? A way to test it all before deployment.
That's what we're building.
Your AI agent is ready. Your RCS strategy should be too.
The Hidden Cost of RCS Approvals: What You're Doing While You Wait
You're on a tight timeline. You have a campaign to launch. What you don't know: approvals can take 8-16 weeks. Here's how to stop waiting and start building.
The Hidden Cost of RCS Approvals: What You're Doing While You Wait
Here's the scenario:
You're a marketing lead. Your boss wants an RCS campaign live in 4 weeks for the product launch. "How hard can it be?" they ask.
What you don't know: getting approved for RCS takes 8-16 weeks.
You submit your application. Legal reviews your documents. Your logo gets vetted. Your use cases go through carrier review.
And then you wait.
While you wait, what are you supposed to do? Nothing?
The Reality of RCS Timelines
The RCS approval process exists for good reasons:
- Legal vetting — Ensuring you're a legitimate business
- Brand verification — Confirming your logo and identity
- Use case review — Making sure your messages comply with carrier policies
- Carrier integration — Getting your brand set up on Google, Samsung, and carrier networks
This process takes 8-16 weeks. Sometimes longer.
During this time, most brands do exactly what you'd expect: nothing. They wait for approval before doing any real work on their campaign.
And that's the hidden cost of RCS.
What You Could Be Doing Instead
While you're waiting for approval, here's what you could be working on:
1. Campaign Design
- Building out your message flows
- Designing rich cards, carousels, and suggested actions
- Writing copy for each touchpoint
- Setting up automation rules
2. RCS Agent Development
- Training your AI agent to handle customer queries
- Setting up fallback logic for when RCS isn't available
- Building handover protocols to human agents
- Testing different conversation flows
3. AI Integration
- Connecting RCS to your CRM
- Setting up personalization engines
- Building analytics dashboards
- Training models on expected conversation patterns
4. Testing & Optimization
- A/B testing different message formats
- Optimizing for conversion
- Finding the right timing and frequency
- Building fallback sequences
The problem: You can't do any of this until you're approved.
The Parallel Execution Gap
This is what we call the Parallel Execution Gap — the time between submitting your application and receiving approval where you're essentially blocked.
Most marketing teams experience this as:
- Wasted time — 8-16 weeks of waiting
- Rushed launches — Approval comes late, so campaigns go live without proper testing
- Missed opportunities — Could have been iterating on campaigns during the wait period
- Team frustration — Everyone ready to go, but stuck waiting
The approval process is necessary. But the waiting doesn't have to be unproductive.
How to Work While You Wait
Forward-thinking brands are adopting a new approach: build while you wait.
Instead of waiting until you're approved to start working on your campaign, they use RCS X to:
- Build campaigns in simulation — Design and test your full RCS experience without needing carrier approval
- Develop your RCS Agent — Train and refine your AI agent handling real conversations
- Integrate with your stack — Connect RCS to your CRM, analytics, and automation tools
- Validate across devices — Test how your messages render on different devices and carriers
- Iterate on copy and design — Optimize based on testing, not assumptions
When approval finally comes, your campaign is ready to go.
No rushing. No cutting corners. No launching untested.
The Timeline Difference
Traditional approach:
Week 0: Submit application
Weeks 1-8: Wait for approval
Week 9: Start building campaign
Week 11: Launch (rushed, untested)
Parallel execution approach:
Week 0: Submit application + Start building in RCS X
Weeks 1-8: Build campaign, test RCS Agent, integrate AI
Week 9: Approval comes in → Campaign ready
Week 9: Launch (tested, optimized, scaled)
Same approval timeline. Completely different outcome.
The Real Value of RCS X
RCS X isn't just a testing tool. It's a parallel execution platform that lets you:
- Separate approval from preparation — Get your campaign ready before you get approved
- Validate before you launch — Test across devices, carriers, and scenarios
- Build confidence — Know your campaign works before going live
- Scale faster — When approval comes, you're already at scale
The 8-16 week approval wait is a fact of RCS life. But the hidden cost of that wait is a choice.
You can spend those weeks doing nothing.
Or you can spend them building something.
Don't Let Approvals Define Your Timeline
Your campaign timeline shouldn't be dictated by carrier approval processes.
Use the waiting time productively. Build your campaign in parallel. Test your RCS Agent. Integrate your AI. Optimize your flows.
When approval comes — and it will — you'll be ready to scale immediately.
That's the power of working while you wait.
Ready to stop waiting and start building?
Hello World - Welcome to RCS X
A quick introduction to RCS X and how it helps teams test messaging journeys faster.
Hello World - Welcome to RCS X
RCS X exists to remove the friction in testing RCS campaigns.
Instead of waiting for production-side verification loops, teams can iterate on rendering, payload structure, and callback behavior in one place.
Why we built this
- Campaign teams needed a faster QA cycle.
- Developers needed deterministic payload validation.
- Product teams needed confidence before launch.
With RCS X, those needs converge into one workflow.
What to expect from this blog
We will share:
- Release notes for new features.
- Deep-dives on payload patterns and architecture.
- Practical guidance for improving message quality and reliability.
Thanks for reading. This is the first post of many.
No posts matched your search yet.