The messaging platform built
for AI agents — not bolted on.
Every surface of Pinnacle — the MCP server, the REST API, and the TypeScript / Python / Ruby SDKs — is built ground-up for LLM callers: typed tool schemas written for models, idempotent by default, scoped keys, and server-side TCPA + STOP/HELP guardrails that survive any prompt. Drop the MCP server into Claude, Cursor, or n8n in one command, or call the REST API directly — same agentic features either way.
Why AI agents can't text customers cleanly
Every team trying to give an LLM a phone number hits the same three walls. Pinnacle's MCP server collapses them into a one-line install.
Custom auth + webhook glue
Every project rebuilds the OAuth handshake, tool definitions, error handling, retry semantics, and rate-limit logic from scratch. A sprint goes to plumbing before your agent sends its first text.
Messaging APIs aren't agent-native
Twilio and most CPaaS APIs were designed in the 2010s for human engineers — REST docs written for humans, no MCP server, no typed tool schemas. You wrap them in agent-shaped tool definitions yourself, then maintain that wrapper forever, and the model still hallucinates argument shapes.
Compliance lives in your prompt
A hallucinating model sends 10K bulk messages, blows past the TCPA send window, fails to honor STOP — and the legal exposure falls on whoever wrote the prompt. Server-side guardrails belong in the messaging layer, not the system message.
We didn't bolt AI onto a 2015 messaging API. We rebuilt the substrate.
Most messaging APIs were designed for human engineers writing imperative code. AI agents don't read docs the way humans do — they guess endpoint names, retry on partial failures, and run in loops that can blow through credits. Every layer of Pinnacle is designed for an LLM caller, not retrofitted from a SaaS dashboard.
Typed tool schemas, written for LLMs
Every endpoint exposes a JSON schema with descriptions written for models — not just for REST docs. Your agent doesn't guess endpoint names or argument shapes. It picks the right tool on the first call.
Idempotent by default
Pass an idempotency key and we dedupe at the API layer. Agents can retry on transient failures, network glitches, or partial tool-call replays without doubling messages. The 'oops we sent it twice' bug class is gone.
Bounded blast radius
Per-key rate limits, account-level spend caps, and per-recipient frequency caps stop runaway loops cold. The model can hallucinate a 10,000-recipient blast — the API will refuse to ship it.
Server-side guardrails
STOP/HELP, TCPA send-window, consent state, and cross-channel opt-out propagation are enforced inside the API — not in your prompt. Whatever the agent decides, compliance can't be bypassed. The model can't write its way around the law.
SMS and RCS, both first-class — your agent picks per recipient.
SMS is the universal rail — every US phone, every carrier, every OTP, every transactional alert. RCS is the branded rail when the recipient's device supports it — verified sender, rich cards, structured replies. Pinnacle exposes both as first-class agent tools and resolves the channel per recipient on every send, so your agent never branches on capability and never falls between the two.
SMS at universal scale
Every US phone receives SMS — no app install, no carrier capability check, no fallback logic. Pinnacle's send-SMS tool handles 10DLC carrier-approved messaging end-to-end: order alerts, OTP / 2FA codes, transactional notifications, and bulk outreach. Idempotent send, recipient-local send window, auto STOP/HELP — all enforced server-side.
RCS where it lands, SMS where it doesn't
Same API call. Pinnacle resolves channel per recipient on every send — verified-sender branded RCS to RCS-capable devices, plain SMS to everyone else. No coverage gaps, no second integration, no per-channel branching in your agent's prompt.
Structured replies on both channels
RCS quick replies and suggested actions return structured intent ("CONFIRM", "RESCHEDULE", "DISPUTE") — your agent skips a parsing LLM call. For SMS, our keyword-router tool maps inbound text to structured intents using your declared keyword set. Same agent code handles both.
Delivery signal on every send
Per-recipient delivered, read (on RCS), and replied events stream back via webhook for both SMS and RCS. Your agent knows when to follow up, escalate to a human, or stop — without polling, without timeouts, without guessing.
AI text agents are already shipping on Pinnacle.
Most messaging providers treat AI as an afterthought — for us, it's the front door. We obsess over this use case, ship for it every week, and answer Slack messages from agent builders before we've had coffee. Tell us what your agent is trying to do — we'll show you the fastest path to live, on a 15-min call.
Appointment-booking agents
Healthcare, beauty, and services agents that collect intent over RCS, send rich availability cards, and write the booking back to a calendar.
Fraud-alert dispatchers
Fintech and banking agents that text verified-sender RCS alerts the moment a risk model flags a transaction — with one-tap confirm or dispute.
Support escalation agents
DTC and SaaS agents that triage inbound conversations, deflect what they can, and hand off to a human with full thread context attached.
B2B SDR & lead-gen agents
Sales agents qualifying inbound leads over SMS, booking discovery calls, and writing the qualification record back to your CRM in real time.
Internal ops paging bots
On-call alerting agents wired into Sentry, Datadog, and PagerDuty — texting the right engineer with the right runbook link from your IDE.
Voice-to-text concierges
Transcription agents that listen on a call, then text the customer a follow-up summary, a payment link, or the next-step booking — within seconds of hangup.
We'll match your agent to the right tools on the call.
95 tools your agent can call
Every endpoint of the Pinnacle API, exposed as a typed tool with a schema your model can reason over — and a description written for an LLM, not a 2015 REST doc.
Messaging & status
Send SMS, MMS, and RCS. Schedule messages, inspect delivery status, and check account health.
Conversations
Read inbound threads, reply, and let your agent participate in two-way SMS or RCS.
Contacts & audiences
Create, segment, and update contacts. Build audiences from filters or CSVs.
Blasts
Launch and manage broadcast campaigns. Track sends, opt-outs, and engagement.
Phone numbers
Provision long codes, toll-free, and short codes. Configure routing and capabilities.
RCS agents
Build agents, register cards, push interactive flows, and inspect verification status.
Webhooks
Subscribe, list, and inspect webhook deliveries so your agent can react in real time.
Brands & campaigns (TCR)
Programmatic 10DLC and toll-free registration. Autofill, validate, and submit through TCR.
Forms, utilities & docs
Hosted opt-in forms, dev utilities, and docs search — your agent greps the Pinnacle docs without leaving the loop.
What AI agents are shipping
Real agents we've helped builders ship — appointment bookers, ops bots, fraud-alert dispatchers. Tell us yours on the call and we'll show you the closest pattern we've already wired up.
Claude Code build notifier
Tell Claude "text me when the build finishes" — it picks the right tool and sends to your phone. Zero glue code, zero webhook scaffolding.
GPT agent that books over RCS
A GPT custom agent that collects intent, sends an RCS rich card with available slots, and writes the booking back to your DB the moment the patient taps a slot.
n8n → Pinnacle MCP
Drop the MCP node into an n8n workflow. Trigger on Stripe events, Slack messages, or webhooks — your AI step picks the right Pinnacle tool with no manual mapping.
Internal ops paging agent
Connect Pinnacle to your internal Claude or Cursor agent. It can text the on-call engineer, send blast updates, or look up customer conversations from the IDE.
Pinnacle vs. a CPaaS designed for humans
You can wrap any messaging API in MCP. You can't make it AI-native after the fact.
| Capability | Generic CPaaS | Pinnacle |
|---|---|---|
| Tool descriptions | REST docs written for engineers | Schemas & descriptions tuned for LLM tool-use |
| SMS + RCS in one API | Separate products, separate endpoints | Same call — RCS where it lands, SMS fallback otherwise |
| Replies your agent can use | Free-text — your model has to parse it | RCS quick replies return structured intent |
| Idempotency | Optional, manual key handling | First-class — agents can retry safely |
| Compliance enforcement | Up to your application code | Server-side: STOP/HELP, send-window, opt-out propagation |
| Blast-radius limits | You build them | Per-key rate, spend caps, frequency caps built in |
| MCP server | Community-maintained or none | First-party, kept current with the API |
| Time to first send | Hours of auth + glue code, then days of carrier review | Minutes — we wire your agent up live on the call |
Book a 15-min call. Walk out with a plan.
Tell us what your agent is trying to do — appointment booking, fraud alerts, support escalation, ops paging. We'll map the right tools, the right channels (SMS / RCS / MMS), and the fastest path to a live send. No slide deck, no "next steps" email — just a working spec by the end of the call.
- • What your agent should do, mapped to specific tools
- • MCP vs REST vs SDK — which path fits your stack
- • Compliance + carrier registration, handled for you
- • A working code path you can paste in afterward
Common questions
Everything AI builders ask before they book the call.
Let's get your AI agent texting.
Talk to a builder for 15 minutes. We'll map your agent to the right tools and the right channel — and you'll leave with a working code path. Built by people who actually love this use case.