open-claude-tag

🔥 Claude Tag launched June 23, 2026 — Anthropic's always-on AI teammate that lives in Slack, learns your company, and works autonomously. It's closed, paid, locked to Anthropic, and cloud-only. This is the open-source alternative: self-hostable, LLM-agnostic, and channel-native.

Open Claude Tag is a free, self-hostable AI teammate for Slack that works the way Claude Tag does — one shared agent per channel, persistent memory, skill auto-creation, ambient monitoring — without Anthropic's paywall, without cloud lock-in, without the single-vendor constraint.

Most Slack AI bots are personal assistants — one context per user, isolated DMs. Open Claude Tag flips this: one agent per channel, shared by the whole team. Everyone sees the same context, picks up mid-thread, and the agent knows who said what.

Community: Join Reddit & Discord for discussions and support. Follow the creator for updates.

Related projects

Open-source AI design agent — alternative to Lovart AI, Runway Agent, Luma Labs Agent → https://github.com/Anil-matcha/Open-AI-Design-Agent

Open-source multi-modal chatbot and Poe alternative → https://github.com/Anil-matcha/Open-Poe-AI

Open-source AI voice agent for sales calls and customer support → https://github.com/Anil-matcha/AI-Voice-Agent

🤖 Explore 50+ more open-source AI apps →

Why Open Claude Tag

On June 23, 2026, Anthropic released Claude Tag — the first AI that joins Slack as a shared channel teammate rather than a personal DM bot. It went viral. But it stayed closed-source, paid-only, cloud-only, locked to Claude models, and locked to Anthropic's access control model. No self-host, no BYOK for other providers, no custom tool integrations without Anthropic's approval.

Open Claude Tag is the open-source alternative. Same channel-native mental model, none of the lock-in:

• 🏢 Channel-scoped, not user-scoped. One agent per channel, shared by the whole team. All users see the same context, pick up mid-thread.
• 🤖 LLM-agnostic. Use Claude, GPT-4o, Gemini, Groq, or local Ollama. Swap with one env var. Different channels can use different models.
• 💾 Agent-curated memory. After each conversation, the agent decides what's worth keeping in MEMORY.md. No noisy append-only logs.
• 🧠 Skill auto-creation. After complex multi-step tasks, the agent writes a SKILL.md capturing what it learned. Institutional knowledge accumulates automatically.
• 🔔 Ambient monitoring. Configurable heartbeat: the agent proactively surfaces stale threads, approaching deadlines, and forgotten questions.
• 🔌 MCP-native tools. Plug in any MCP server per channel. Admins control exactly what each channel's agent can access.
• 📁 File-based config. Each channel is a directory of Markdown files. Version-controllable, auditable, no UI required.
• 🔒 Self-hostable. Your Slack data stays on your infrastructure. No round-trips to Anthropic's cloud.

Comparison

How it Works

The core inversion

Every other Slack bot keys sessions on user_id. Open Claude Tag keys sessions on (workspace_id, channel_id). That one change is what makes it feel like a teammate rather than a chatbot.

[#engineering channel]

@alice  Can you review the PR for the auth refactor?
@agent  Sure. I pulled the PR — looks good overall, one concern:
        the session expiry logic on line 42 doesn't handle clock skew.
        @bob you mentioned this pattern in the DB migration last week —
        does the same fix apply here?
@bob    Yeah, add a 5s leeway. Same as auth/session.py:L88
@agent  Got it. Adding to MEMORY.md: "session expiry: always add 5s
        leeway for clock skew (pattern from auth/session.py:L88)"

Every user in the channel sees the same thread. The agent knows who said what, follows up with the right person, and decides what's worth remembering.

Agent loop

Slack @mention
       │
       ▼
  Channel Router ──── (workspace_id + channel_id) → AgentSession
       │                  ↑ serialized lock: no parallel writes to context
       ▼
  Context Assembler
  ├── CHANNEL.md       (identity, purpose, tone)
  ├── MEMORY.md        (agent-curated facts, always in context)
  ├── skills/*.md      (auto-created playbooks, loaded on semantic match)
  └── Last 50 messages (with @username attribution)
       │
       ▼
  Agent Loop  (ReAct + tool-use via LiteLLM)
  ├── Tool Registry  ← MCP servers defined in tools.toml
  ├── Built-in tools ← web search, Python runner, channel search
  └── Stream reply → Slack thread
       │
       ├── Memory curation turn  ← agent decides what to write to MEMORY.md
       │   (Letta inner-loop: model gets one extra turn to curate)
       │
       └── Skill evaluator  ← ≥5 tool calls? write SKILL.md
           (Hermes pattern: agent authors its own playbooks)
       │
       ▼
  SQLite + FTS5  (per-workspace DB, channel-isolated, WAL mode)
       │
       ▼
  Ambient Engine  (background — Phase 3)
  ├── Per-channel APScheduler crons
  ├── Heartbeat evaluator: "anything worth surfacing?"
  └── Proactive Slack post if yes, SILENT if no

Memory architecture

Layer 1 — Context window (always loaded)
  CHANNEL.md + MEMORY.md + active SKILL.md files + last 50 messages

Layer 2 — Session store (SQLite + FTS5, per workspace)
  Full message history with user_id, timestamps, thread_ts
  Full-text search: "what did we decide about X last month?"

Layer 3 — Semantic recall (Mem0, Phase 2)
  Embeddings over key decisions and facts
  Namespace = channel_id (fully isolated per channel)

Layer 4 — Skill library (per channel)
  Auto-created after complex tasks (≥5 tool calls)
  Loaded into context when task description matches
  Curated weekly: stale after 30d, archived after 90d

Ambient heartbeat

The heartbeat evaluator runs on a configurable cron per channel. It dumps recent activity to the LLM and asks: "anything worth surfacing?" It only posts if there's genuine value — stale threads, approaching deadlines, forgotten questions, spotted risks. Otherwise: SILENT.

The agent can also create its own monitoring tasks via schedule_task(cron, description) — it decides what's worth checking and when.

Quickstart

Prerequisites

• Python 3.11+
• A Slack app with Socket Mode enabled (create one here)
• An API key for your preferred LLM provider (Anthropic, OpenAI, Gemini, or Groq)

1. Create the Slack app

1. Go to api.slack.com/apps → Create New App → From scratch
2. Settings → Socket Mode: enable it and generate an App-Level Token (xapp-...) with connections:write scope
3. Event Subscriptions: enable and subscribe to app_mention and message.channels
4. OAuth & Permissions → Bot Token Scopes: add app_mentions:read, channels:history, channels:read, chat:write, reactions:write, users:read
5. Install to workspace → copy the Bot Token (xoxb-...)

2. Install and configure

# Clone
git clone https://github.com/Anil-matcha/open-claude-tag
cd open-claude-tag

# Install
pip install -e .

# Configure
cp .env.example .env

Edit .env:

SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...

# Pick one LLM provider:
LLM_MODEL=claude-sonnet-4-6
ANTHROPIC_API_KEY=sk-ant-...

# or: LLM_MODEL=gpt-4o  +  OPENAI_API_KEY=sk-...
# or: LLM_MODEL=gemini/gemini-2.0-flash  +  GEMINI_API_KEY=...
# or: LLM_MODEL=ollama/llama3  (no key needed)

3. Configure your first channel

Get your channel ID: in Slack, right-click channel name → View channel details → scroll to the bottom.