Anthropic Picked Slack. WhatsApp Has 62x More Users.

By Lazar Milicevic · Published July 11, 2026 · 7 min read

Anthropic just shipped @Claude for Slack and called it "meet you where you work." Slack has 32 million daily users. WhatsApp has 2 billion monthly. If your team argues about invoices in a Telegram group or a WhatsApp thread, that new feature literally cannot reach you — and the pattern behind it isn't proprietary anyway.

The distribution math nobody wants to say out loud

Anthropic shipped the right AI pattern on a surface that covers roughly 1.5% of the world's business messaging. Slack sits around 32M DAU concentrated in US enterprise and mid-market SaaS. WhatsApp is at ~2B monthly actives. Telegram passed 950M. That's a ~62x gap between the surface Anthropic picked and the surface most small teams actually use.

Look at this the way a solo operator has to look at it — where do my team, my suppliers, and my clients already send messages?

The Slack integration is a good product decision for Anthropic. Slack is where the money will sign an MSA. WhatsApp Business API is a maze of Business Solution Providers, 24-hour conversation windows, and template message approvals. Telegram is wide open but has almost no enterprise procurement motion. Slack is the easier ship and the easier revenue.

That's fine. What's not fine is calling it "meet you where you work" when for the ten-person agency in São Paulo, Lagos, Warsaw, or Dubai, work is happening in three group chats on a different app.

The @Claude pattern, decomposed

Strip the branding off and @Claude in Slack is four moving parts: an @-mention listener, a context loader that pulls the last N messages plus referenced docs, a tool-calling loop against a capable model, and a reply back into the same thread. That's the whole feature. None of it is proprietary.

Here's the loop in pseudocode, platform-agnostic:

on message_received(msg):
    if not bot_mentioned(msg):
        return
    thread = fetch_last_n_messages(msg.chat_id, msg.thread_id, n=50)
    attachments = resolve_referenced_docs(thread)
    context = build_context(thread, attachments, user_profile)
    result = agent_loop(
        model="claude-sonnet",
        system=OPS_PROMPT,
        messages=context,
        tools=[gmail, sheets, crm, calendar, invoicing]
    )
    post_reply(msg.chat_id, msg.thread_id, result.output)

That's it. The value isn't in the messenger — it's in the tool-calling loop and the context loader. The messenger is a transport. Whether you're posting to chat.postMessage on Slack or sendMessage on the Telegram Bot API, the interesting work is identical.

What actually varies between platforms

• Auth model: Slack uses OAuth apps + signing secrets. Telegram uses a single bot token. WhatsApp requires a verified Business Account and a BSP relationship.
• Message limits: Slack has generous rate limits per workspace. Telegram allows 30 messages/second to different users. WhatsApp enforces 24-hour customer service windows and pre-approved templates outside that window.
• Context surface: Slack threads have a first-class API. Telegram has reply_to_message chains. WhatsApp has no thread concept — you rebuild it from message IDs.
• File handling: All three support file uploads/downloads, but WhatsApp voice notes require an extra transcription step (Whisper works fine here).

Building the same loop on Telegram in a weekend

For a small team, Telegram is the cheapest, fastest way to run the @Claude pattern in a chat your team already opens 100 times a day. Bot token from @BotFather, a webhook on a $6-8/month VPS, and a couple hundred lines of Python. Unlimited users on the bot. You only pay for the model tokens you actually consume.

Here's a minimal working listener that handles the mention → context → agent → reply loop:

import os
from telegram import Update
from telegram.ext import Application, MessageHandler, filters, ContextTypes
from anthropic import Anthropic

client = Anthropic()
BOT_USERNAME = os.environ["BOT_USERNAME"]
HISTORY = {}  # chat_id -> list[dict], in prod use Redis/Postgres

TOOLS = [
    {"name": "search_gmail", "description": "...", "input_schema": {...}},
    {"name": "update_sheet", "description": "...", "input_schema": {...}},
    {"name": "draft_reply",  "description": "...", "input_schema": {...}},
]

async def on_message(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
    msg = update.message
    chat_id = msg.chat_id
    HISTORY.setdefault(chat_id, []).append(
        {"role": "user", "content": f"{msg.from_user.first_name}: {msg.text}"}
    )
    HISTORY[chat_id] = HISTORY[chat_id][-50:]

    if f"@{BOT_USERNAME}" not in (msg.text or ""):
        return

    await ctx.bot.send_chat_action(chat_id, "typing")

    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2048,
        system="You are an ops assistant for a small agency. "
               "Read the thread, use tools, reply concisely.",
        tools=TOOLS,
        messages=HISTORY[chat_id],
    )

    # agent loop: handle tool_use blocks, feed results back, until stop_reason=="end_turn"
    final_text = run_tool_loop(response)

    await msg.reply_text(final_text, reply_to_message_id=msg.message_id)
    HISTORY[chat_id].append({"role": "assistant", "content": final_text})


app = Application.builder().token(os.environ["TG_TOKEN"]).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, on_message))
app.run_polling()

Real numbers from a client deployment I've been running for eight months:

• VPS: $6/mo (2 vCPU, 2 GB RAM, DigitalOcean)
• Model spend: $18–$42/mo for a 6-person agency, ~200 mentions/mo, mixed Sonnet + Haiku for cheap routing
• Deploy time: ~4 hours to a working bot, ~1 week to a bot the team actually trusts with Gmail and the CRM
• Per-seat cost: $0. The bot doesn't charge per user because Telegram doesn't.

Compare that to @Claude on Slack at $30/seat/month on the Team plan. A 6-person team = $180/mo = $2,160/yr for the feature. On Telegram the same 6-person team runs at roughly $50–$70/mo all-in, most of which is model tokens they'd pay anyway.

WhatsApp is doable but has real tax

If your customers live on WhatsApp — and in most of Latin America, Southern Europe, MENA, and Southeast Asia they do — you can run the same pattern through the WhatsApp Business Cloud API or a BSP like 360dialog or Twilio. It's harder for three reasons that matter to a small operator:

• 24-hour customer service window. You can freely reply within 24 hours of a user's last message. Outside that, you need a pre-approved template message.
• Template approval. Marketing and utility templates go through review. This is not "ship on Friday" territory.
• Per-conversation pricing. Meta charges per 24-hour conversation window, tiered by category (utility, marketing, authentication, service). Rates vary by country and change over time — check Meta's current WhatsApp Business Platform pricing before you model this.

For internal team ops — the group where your ops manager, your VA, and your bookkeeper argue about invoices — most small teams skip the WhatsApp tax and run it on Telegram or Signal. For customer-facing flows on WhatsApp (order status, appointment reminders, quote intake), the BSP route is worth it, but budget a real week of setup plus template approval time.

When to pick which surface

• Internal ops bot, team of 3–20: Telegram. Cheapest, fastest, no per-seat cost.
• Customer support/intake at scale: WhatsApp via BSP. Your customers already open it.
• Regulated or privacy-sensitive: Signal or self-hosted Matrix.
• You're already a Slack shop and have budget: @Claude in Slack is genuinely good. Use it.

What the Slack-only ship misses

Slack won a headline. WhatsApp and Telegram are where 2.9 billion people run their day. The teams that will benefit most from an at-mention ops bot over the next twelve months are not the ones migrating to Slack to use @Claude. They're the teams whose bot already lives in the chat the business actually runs on — because context, trust, and adoption compound in the tool people already open 100 times a day.

There's also a subtler point. When your ops bot lives inside the group chat where the business is being run in real time, it inherits a context that no dashboard-based AI ever gets: the informal decisions, the "actually let's push that invoice to next week," the "the client called and said X." A bot that watches that thread and can act on it is worth more than one that has to be briefed from scratch every session. That's the moat, and it's platform-agnostic.

Where bizflowai.io fits

At bizflowai.io we build exactly this pattern for small teams: an at-mention ops bot inside the messenger you already use (Telegram, WhatsApp via BSP where needed, Slack if that's your stack), wired into Gmail, sheets, your CRM, and your invoicing system. Same @-mention, context, autonomous work, reply loop Anthropic demoed — but on the surface your team actually lives in, priced as a flat build + hosting rather than a per-seat tax.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.