@Claude Costs 3-Person Teams $1,080/yr. Telegram: $100.

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

Anthropic just shipped @Claude inside Slack and every enterprise consultant is calling it the future of AI at work. If you run a three-person team, that launch is a tax, not a tool. Here's the exact math, the pattern behind the product, and the 200-line Telegram clone that gives you the same UX for eight bucks a month.

What @Claude in Slack actually is (and why the loop is the product)

@Claude in Slack is a bot mention. You tag it in a thread, it reads the channel context, and it replies in-thread with memory of what came before. No new tab, no context switch, no copy-pasting from ChatGPT back into your chat tool. That's the whole product.

Anthropic didn't invent a new model here. They shipped a distribution loop: meet users inside the tool they already live in. That insight is genuinely correct — the friction of leaving Slack to ask a model something kills 80% of the value. But the loop itself is not Slack-specific. It's a three-ingredient pattern:

• A chat tool that supports bot mentions and threads
• A webhook that fires when the bot is tagged
• An API call to Claude that carries the thread context back into the reply

Slack has this. Telegram has this. WhatsApp Business has this. Discord has this. Even Gmail has this if you're willing to trigger on reply. The loop is the product, and the loop is portable.

The math nobody covering the launch will show you

A three-person team on Slack Business+ pays around $15/seat. Adding @Claude sits at roughly $30/seat on top. That's $45 per person, $135/month, $1,620/year — just to tag a bot in a thread. Even on the cheaper Pro tier you clear a thousand dollars annually before doing anything else.

Same three people, self-hosted Telegram bot, Claude API:

I've been running the Telegram version for a small ops team for months. Around 200 tag-mentions a day across four group chats. API cost sits at roughly $8/month on Claude Haiku with occasional Sonnet routing. Persistence lives in a SQLite file on a $10 VPS. Threaded replies, memory across days, same feel.

The gap is not 2x. It's ~15x on year-one total cost, and the multiple gets worse the more people you add.

The 200-line clone: Telegram bot + webhook + Claude API

Here's the actual minimum viable @Claude clone. Spin up a bot with BotFather in five minutes, drop this on any $10/mo VPS with a domain pointed at it, and you have the same loop.

# bot.py — minimum viable @Claude clone for Telegram
import os, sqlite3, json
from fastapi import FastAPI, Request
from anthropic import Anthropic
import httpx

TG_TOKEN = os.environ["TG_TOKEN"]
BOT_USERNAME = os.environ["BOT_USERNAME"]  # e.g. "opsbot"
client = Anthropic()
app = FastAPI()

db = sqlite3.connect("history.db", check_same_thread=False)
db.execute("""CREATE TABLE IF NOT EXISTS msgs(
    chat_id INTEGER, thread_id INTEGER, role TEXT,
    content TEXT, ts INTEGER)""")

async def tg_send(chat_id, thread_id, text):
    async with httpx.AsyncClient() as h:
        await h.post(
            f"https://api.telegram.org/bot{TG_TOKEN}/sendMessage",
            json={
                "chat_id": chat_id,
                "message_thread_id": thread_id,
                "text": text,
                "parse_mode": "Markdown",
            },
        )

def load_context(chat_id, thread_id, limit=10):
    rows = db.execute(
        "SELECT role, content FROM msgs WHERE chat_id=? AND thread_id=? "
        "ORDER BY ts DESC LIMIT ?",
        (chat_id, thread_id, limit),
    ).fetchall()
    return [{"role": r, "content": c} for r, c in reversed(rows)]

@app.post("/webhook")
async def webhook(req: Request):
    update = await req.json()
    msg = update.get("message") or {}
    text = msg.get("text", "")
    if f"@{BOT_USERNAME}" not in text:
        return {"ok": True}

    chat_id = msg["chat"]["id"]
    thread_id = msg.get("message_thread_id", 0)
    user_text = text.replace(f"@{BOT_USERNAME}", "").strip()

    history = load_context(chat_id, thread_id)
    history.append({"role": "user", "content": user_text})

    resp = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=800,
        system="You are the team ops bot. Concise. Use thread context.",
        messages=history,
    )
    reply = resp.content[0].text

    ts = msg["date"]
    db.execute("INSERT INTO msgs VALUES(?,?,?,?,?)",
               (chat_id, thread_id, "user", user_text, ts))
    db.execute("INSERT INTO msgs VALUES(?,?,?,?,?)",
               (chat_id, thread_id, "assistant", reply, ts + 1))
    db.commit()

    await tg_send(chat_id, thread_id, reply)
    return {"ok": True}

Wire it up with two commands:

# Point Telegram at your webhook
curl -X POST "https://api.telegram.org/bot$TG_TOKEN/setWebhook" \
  -d "url=https://yourdomain.com/webhook"

# Run behind Caddy or nginx with TLS
uvicorn bot:app --host 0.0.0.0 --port 8080

That's the entire loop. Threaded memory via message_thread_id, last 10 turns loaded per thread, Claude Haiku for the cheap tier. Swap in Sonnet on a /deep prefix if you want tiered routing. Total: ~120 lines including error handling and a /reset command I stripped for brevity.

What you're not getting vs. @Claude

• No SSO / SCIM / SOC2-scoped access controls
• No enterprise audit log export
• No "connected apps" like Google Drive picker or Salesforce (you'd wire those yourself)
• No procurement paperwork someone else already signed off on

If none of those matter to you, you just saved $1,400 a year.

When Slack + @Claude is actually worth $30/seat

I'm not anti-Slack. There are three real cases where the managed integration earns the price:

1. You're already on Enterprise Grid with 50+ seats. Switching costs are real, IT already blesses Slack, and $30/seat is a line item, not a decision.
2. You have compliance requirements — SOC 2 Type II, HIPAA BAAs, retention policies, DLP, audit trails. Anthropic's managed integration handles most of this out of the box. Rolling your own means owning that surface, and for regulated teams the cost of "own it yourself" dwarfs $1,620/yr fast. Anthropic publishes their trust and compliance posture — worth reviewing before you decide.
3. Your team genuinely won't adopt a new tool. Every conversation already lives in Slack. Getting people to check Telegram or Discord is a change-management problem, and change management is expensive.

Outside those three cases — solopreneur, founding team, agency under ten people, anyone who hasn't fully committed to Slack — you're paying Enterprise Grid pricing for a pattern that costs almost nothing to replicate.

The pattern is portable — pick your surface

The tag-a-bot loop works on any surface with mentions + threads + webhooks. Rough tradeoffs I've hit shipping this for clients:

• Telegram — fastest to ship, free bot API, native threads via topics, no per-seat cost. Best for internal ops teams and technical founders. Weak point: no SSO.
• Discord — same pattern, better voice/role controls, good for community-facing bots. Slightly heavier webhook contract.
• WhatsApp Business Cloud API — best for client-facing bots (invoice reminders, appointment confirmations). Meta charges per conversation, so math changes if volume is high.
• Slack (free tier) — you can build the same bot yourself with a Slack app, pay $0 for @Claude seats, and just pay API. Loses the "official" integration but keeps the surface.
• Gmail reply-to-trigger — underrated. Reply-to a bot address, webhook parses the thread, Claude answers, response threads back into Gmail. Best for teams already living in email.

The choice isn't Slack vs. not-Slack. It's which surface does your team already live in, and can you tolerate 200 lines of Python.

Cost math on API usage (real numbers from 200 tags/day)

People overestimate the API bill because they price against Sonnet on every call. Here's what 200 tag-mentions/day actually costs on Claude Haiku 4.5 with ~2K tokens input (context + last 10 turns) and ~400 tokens output average:

• Input: 200 × 2,000 = 400K tokens/day → 12M/month
• Output: 200 × 400 = 80K tokens/day → 2.4M/month
• Haiku pricing (as of writing — check the current rate): input roughly $1/M, output roughly $5/M
• Monthly: ~$12 input + $12 output = **$24/mo worst case**, and I see ~$8 in practice because most tags are short lookups that don't need the full 10-turn context.

Route the 5% of hard questions to Sonnet with a /deep prefix and you still stay under $30/mo. Compared to $1,080/yr for @Claude at $30/seat × 3 seats, the API bill is a rounding error.

Why bizflowai.io helps with this

Building the tag-a-bot loop is one weekend. Keeping it reliable — retries when Telegram's webhook flakes, thread pruning so context doesn't blow past 200K tokens, per-user rate limiting, routing between Haiku and Sonnet by intent, hooking it into your CRM or invoicing so @bot who owes us money returns real data — that's the actual work. At bizflowai.io I ship these bot loops for small teams end-to-end: pick the surface (Telegram, WhatsApp, Slack free tier, Gmail), wire it to your existing tools, and hand you a system that costs closer to $100/yr than $1,620.

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.