Give your agent communication in one paste.

The most reliable paste: point your agent at the always-current guide and it wires the integration itself. Copy the one-liner below — your coding agent reads /SKILL.md from the gateway and sets everything up, so it never drifts from the API.

Read https://api.trycaspianai.com/SKILL.md in full, then set up Caspian so you can
message me on any channel. Follow that guide exactly — install the SDK, run
`caspian init`, and connect a channel (email, Telegram, Slack, and Discord are
free and instant). You'll need internet access to fetch the guide.

Or skip the install: add the MCP server

If you work in Cursor, Claude Code, or any MCP client, there is nothing to install and no key to copy. Add one URL and the agent gains the tools to send and receive. Ask it to call get_started and it mints its own key.

{
  "mcpServers": {
    "caspian": {
      "url": "https://api.trycaspianai.com/mcp"
    }
  }
}

Then: "Use the caspian MCP server: call get_started, connect email, and show me the address." It can read what arrives with inbox and answer with reply. MCP docs →

# Caspian: communication for your agent

You can reach any human on any channel through Caspian, with one persistent
identity. You never build or maintain messaging infrastructure.

## Set up (once)
pip install caspian-sdk                        # SDK + the `caspian` CLI
caspian init                                   # mint a key, write .env (hosted by default)
# Paid channels (x, whatsapp, imessage) need a one-time `caspian login` + prepaid credit.

## Receive + reply — the whole loop
# Ask the human what the mailbox should be called BEFORE connecting email:
# a bare channels.add("email") mints a random local-part.
import os

from caspian import Caspian, HandlerContext, Message, Thread

cx = Caspian(
    api_key=os.environ["CASPIAN_API_KEY"],       # it does not read .env by itself
    base_url=os.environ.get("CASPIAN_BASE_URL", "https://api.trycaspianai.com"),
)

cx.channels.add("email", username="")  # -> @agents.trycaspianai.com

@cx.on_message({"channel": "email"})
def handle(thread: Thread, msg: Message, ctx: HandlerContext) -> None:
    thread.post(my_agent(msg.text))              # answers in the right thread

cx.run()                                         # hosted: poll the gateway forever

The same handler serves every channel you add — telegram, slack, discord.
`caspian channels add ` is the CLI twin of `channels.add`.

## No install? Use the MCP server
Add https://api.trycaspianai.com/mcp to Cursor or Claude Code and ask the agent
to call get_started. It mints a key, connects a channel, and reads and answers
with the inbox and reply tools — nothing installed, no key to copy.

## What you get
- One identity: an inbox, a handle, a number. The same agent everywhere.
- Free channels instant (email, Telegram, Slack, Discord); paid run on prepaid credit.
- Lifecycle handled: reconnects, retries, rate limits, deliverability, threading.

Full, always-current agent guide is served at your gateway: /SKILL.md (and /llms.txt).

The full, always-current guide is served at your gateway as /SKILL.md and /llms.txt, so the pointer above never drifts from the API. View SKILL.md →

Communication is the next agent primitive.

Reasoning models decide what an agent says. But an agent that cannot reliably reach the people it serves is useless, and reaching them has quietly become a separate, growing engineering problem. This is the case for owning it as a layer.

Your users are not on one platform

People live across channels. They are on WhatsApp walking, Slack working, email for anything formal, iMessage with people they trust. An agent that lives on a single platform is a person who only answers phone calls. It is not that it is worse at its job, it is that it is not present where attention already is.

Cross-platform agents win the attention problem. They meet a user in the channel that fits the moment, keep the thread when the user switches, and stay reachable the way a real colleague is. The agents people actually rely on, like OpenClaw and Hermes, are precisely the ones deployed across dozens of human channels. That reach is also exactly where their engineering time goes.

The maintenance tax is real, and measurable

The two most popular open-source agents in the world each rebuilt this layer from scratch, and the receipts are public.

The pain is not send(). Sending a message is a solved, commoditized call. The pain is lifecycle and identity: session and auth desync, reconnect loops, silent connection failures, per-channel rendering regressions on every version bump, and cross-channel identity bugs. Read the top issues in any deployed agent and this is what fills them.

Zoom out and the duplication is absurd. There are over 36,000 WhatsApp bot repositories, most standing on a handful of fragile bridge libraries where session, ban, and QR-logout lifecycle alone can be nearly 19% of all issues. Every team rebuilds the same wheel, then keeps it spinning forever. And the share of an agent codebase that is communication infrastructure only climbs as you add channels. None of it makes the agent smarter.

Identity is becoming infrastructure

Humans are the same person across every channel. Agents should be too. Today an agent is treated as five disconnected things: a Slack bot here, a WhatsApp number there, an email address somewhere else, none of them the same identity. Channels are transports, not identities, and the moment you accept that, the primitive falls out: one persistent identity, one conversation that follows the person, one place the lifecycle is owned.

The unsolved third problem: fleets and coordination

A company does not run one agent. It runs a fleet, support, sales, recruiting, scheduling, internal assistants, and that number is growing fast. Each agent needs its own identity, credentials, history, permissions, and presence. And as those fleets grow, an open problem appears: how agents coordinate and communicate, with humans and with each other, across channels, with the right identity and context attached. That multi-agent communication layer does not exist yet. It is the natural extension of owning the primitive.

So we are building the layer

AI companies should compete on intelligence, not on rebuilding messaging infrastructure. Caspian is the communication layer for AI agents: integrate once, and your agents get one identity, every channel, and none of the maintenance. You build the agent. We handle how it reaches the world.

See how it works →