Multi-Channel Delivery

+15 Mana ✨
OpenClaw Multi-Channel Guide(DOCUMENTATION)OpenClaw Delivery Pipeline(DOCUMENTATION)

Introduction

The same agent response needs to look and feel right on every platform, from Discord's rich markdown to SMS's plain text. Multi-channel delivery is the system that formats, chunks, and delivers responses appropriately for each channel. Understanding how it works lets you create agents that feel native on every platform simultaneously.

Key Concepts

  • Channel-Aware Formatting: Automatic adaptation of response formatting based on the target platform's capabilities
  • Platform-Specific Limitations: Character limits, formatting support, attachment handling, and rate limits that vary across platforms
  • Response Pipeline: The sequence of transformations a response undergoes before delivery (format, chunk, deliver)
  • Unified Agent Logic: The agent generates one response; the delivery layer adapts it for each platform
  • Delivery Confirmation: Tracking whether messages were successfully delivered to the platform

Real World Context

A support agent handles customer queries across WhatsApp, Discord, and a website widget. A customer on WhatsApp asks about pricing. The agent generates a response with a pricing table, code examples for API usage, and links to documentation. The delivery layer converts the markdown table to a text-formatted list for WhatsApp (which does not render tables), preserves the full table for Discord, and renders it as HTML for the website widget. The customer on each platform gets an optimized experience.

Deep Dive

The response pipeline transforms a raw agent response into platform-appropriate messages:

markdown
Response Pipeline:
1. Agent generates raw markdown response
2. Format adapter converts markdown for target platform
3. Chunker splits into messages if needed (WhatsApp 4K, SMS 160)
4. Streaming layer delivers via partial or block mode
5. Delivery confirmation tracks success/failure

Each step in the pipeline is channel-aware. Let us see how the same response looks across three platforms.

Original agent response:

markdown
## Pricing Plans

| Plan    | Price  | Features          |
|---------|--------|-------------------|
| Starter | $9/mo  | 1,000 API calls   |
| Pro     | $49/mo | 50,000 API calls  |
| Team    | $199/mo| Unlimited calls   |

Here is how to check your usage:

` ` `bash
curl -H "Authorization: Bearer $TOKEN" https://api.example.com/usage
` ` `

For more details, see [our docs](https://docs.example.com/pricing).

After the format adapter processes this for each platform:

json
{
  "discord": {
    "content": "## Pricing Plans\n\n| Plan | Price | Features |\n|---|---|---|\n| Starter | $9/mo | 1,000 API calls |\n| Pro | $49/mo | 50,000 API calls |\n| Team | $199/mo | Unlimited calls |\n\nHere is how to check your usage:\n\n```bash\ncurl -H "Authorization: Bearer $TOKEN" https://api.example.com/usage\n```\n\nFor more details, see [our docs](https://docs.example.com/pricing).",
    "format": "markdown"
  },
  "whatsapp": {
    "content": "*Pricing Plans*\n\nStarter: $9/mo - 1,000 API calls\nPro: $49/mo - 50,000 API calls\nTeam: $199/mo - Unlimited calls\n\nCheck your usage:\n```curl -H "Authorization: Bearer $TOKEN" https://api.example.com/usage```\n\nDocs: https://docs.example.com/pricing",
    "format": "whatsapp-markdown"
  },
  "sms": {
    "content": "Pricing: Starter $9/mo (1K calls), Pro $49/mo (50K calls), Team $199/mo (unlimited). Check usage: curl -H 'Auth: Bearer TOKEN' api.example.com/usage. Docs: docs.example.com/pricing",
    "format": "plain-text"
  }
}

Notice the transformations: Discord gets the full markdown table with syntax-highlighted code. WhatsApp gets a formatted list (since it does not render tables) with WhatsApp-style bold using asterisks. SMS gets a compressed plain-text summary that fits within message limits.

The delivery layer also handles platform-specific rate limits:

markdown
Rate limits by platform:
- Discord: 5 messages per 5 seconds per channel
- WhatsApp: 80 messages per second (business API)
- Telegram: 30 messages per second
- Slack: 1 message per second per channel
- SMS: Varies by carrier (typically 1 per second)

OpenClaw respects these limits automatically, queuing messages when necessary and delivering them at the maximum allowed rate.

Common Pitfalls

  • Assuming all platforms render content the same way: A response that looks perfect on Discord may be unreadable on WhatsApp. Always account for platform differences.
  • Ignoring rate limits: Sending messages too quickly triggers platform throttling or temporary bans. Let OpenClaw handle rate limiting automatically.
  • Not testing multi-message responses: When a response is chunked into multiple messages, the order and formatting of chunks must be verified on each platform.

Best Practices

  • Design responses for the lowest-capability platform first: If your agent primarily serves WhatsApp users, structure responses to work well with limited markdown before adding rich formatting for other platforms.
  • Use the response pipeline for consistent delivery: Let OpenClaw's format adapters handle platform differences rather than writing platform-specific logic in your agent instructions.
  • Monitor delivery confirmation: Track failed deliveries to identify platform issues early, such as expired tokens or changed API endpoints.

Summary

  • Multi-channel delivery automatically adapts agent responses for each platform's capabilities and limitations
  • The response pipeline transforms raw markdown through formatting, chunking, streaming, and delivery confirmation
  • The same response renders as full markdown on Discord, adapted markdown on WhatsApp, and plain text on SMS
  • Platform-specific rate limits are handled automatically by the delivery layer
  • Design responses for the lowest-capability platform first, then enhance for richer platforms
✓ Completed