We Built a Slack AI Teammate Before Claude Tag

This is part of our Claude Tag field guide for agencies. Start with the overview: Claude Tag: A Builder’s Guide for Agencies.

The night before Anthropic launched Claude Tag, we shipped two client deliverables through a Slack-based AI teammate we had built ourselves. We weren’t racing anyone and we had no idea an announcement was coming the next morning. We were just doing the work the way we’d been doing it for weeks: post a request in a channel, let Claude draft, approve it, and let it go out.

So when Anthropic described Claude Tag — tag @Claude with a request, and it breaks the task into stages and works through them in the thread — we recognized it on sight. This is the build log of the version we made first: what it is, why we put it in Slack, and the one piece we deliberately kept under human control.

Why we were building an AI teammate in Slack at all

We didn’t set out to build an “AI tool.” We set out to close the gap between a decision and the thing the decision produces. A lead comes in and someone says “we should send the follow-up sequence today.” A week ends and someone says “the client update needs to go out.” The decision is made in seconds; the production used to take an hour. That hour is where work stalls.

Slack was the obvious surface because that is where the deciding already happens. We didn’t want a separate dashboard nobody opens, or a chatbot in another tab that creates a second copy of the conversation. We wanted the request and the result to live in the same thread, where anyone on the team can see both. Putting the AI where the work already is turned out to be most of the design.

The loop, stage by stage

The whole system is one loop with four moves:

1. Request. Someone posts a plain-language ask in a channel — “draft the new-lead follow-up sequence,” “write this week’s update post.” No special syntax, no form.

2. Draft. The teammate picks it up, breaks it into stages, and produces the actual deliverable in the thread — not a summary of what it would do, the thing itself.

3. Claim and approve. A human takes the draft, reads it, edits if needed, and signs off. Nothing moves on the AI’s say-so alone.

4. Ship. On approval, the deliverable goes to its real destination — the CRM, the CMS, the inbox — and the thread records that it happened.

The night we ran it end to end, twice, the part that struck us wasn’t the drafting. It was how natural the “claim and approve” step felt. Delegating to the teammate looked exactly like delegating to a person: ask in the channel, get a draft back, give it a yes.

The runner that holds no keys

The piece we’re proudest of is invisible in the thread. The process that reads the queue and carries out approved work does not carry standing credentials. The keys to the CRM, the publishing platform, the email system — none of them live inside the bot. They sit in the platform’s secret store and are handed to the action at the moment it runs, scoped to that job.

This sounds like plumbing, but for an agency it is the difference between safe and reckless. The component most exposed to the outside world — the thing listening to a chat channel — is the component holding the least. If that surface were ever compromised, there is no client’s API key sitting in it to steal. We built it that way before it was convenient, because client trust is the entire business.

What surprised us

• A request is a better unit than a conversation. “Draft the launch email and three follow-ups” is how people actually delegate. Framing the work as a request instead of a chat changed how the team used it — less hand-holding, more handing-off.

• Visible beats private. Because the work happened in a shared channel, anyone could see what was asked and what came back. Private AI sessions create shadow work nobody can review. Doing it in the open made it auditable by default.

• The approval step wasn’t a bottleneck. It was the product. We expected the human sign-off to feel like friction. Instead it was the thing that let us trust the output enough to send it to a client at all.

What Claude Tag changes for us

Anthropic just productized the surface we’d been hand-building: a Slack-native teammate, multiplayer per channel, with an ambient mode and cross-channel learning, running on Opus 4.8. For our internal team, that’s a gift — we can adopt it and retire some of our own scaffolding.

For client delivery, the hard and valuable part is still ours to own: keeping each client’s context walled off from every other, and keeping a human on the ship button. Those two things are exactly what Claude Tag’s best features work against by default — which is the whole subject of the next piece: Claude Tag for Agencies: The Multi-Client Isolation Trap. For the full picture, go back to the pillar: Claude Tag: A Builder’s Guide for Agencies.