AgentConnect vs. Claude Tag: comparing the two ways to bring agents into team chat

Since we launched, the question we get more than any other is how AgentConnect differs from Claude Tag. It's a fair question, and worth answering properly.

We started building AgentConnect before Claude Tag was announced. Arriving independently at the same idea — that an agent belongs in the shared conversation where a team actually works, not in a private chat window one person can see — was, if anything, reassuring. Great minds think alike: when a team at Anthropic builds toward the same pattern you're building toward, it's decent evidence the pattern is right.

But agreeing on the pattern isn't the same as building the same product. Underneath that shared starting point, the two differ on questions that matter quite a lot in practice: which agent runs, where it can be triggered from, how many agents work together, and who operates the infrastructure. This post walks through those differences honestly, based on Anthropic's Claude Tag announcement, its current product documentation, and AgentConnect's public documentation, checked on September 22, 2026. Both products are moving fast — Claude Tag is still in beta — so check the primary sources if you're reading this later.

The short version

If your team is already fully on Slack and Claude Enterprise or Team, and you want one well-integrated Claude that learns your channels, Claude Tag is a short path to that. If you want to choose runtimes from different vendors, work across more than Slack, configure repository-wide event triggers or issue assignments, or keep the whole stack in infrastructure you control, that's the problem AgentConnect is built around.

What Claude Tag is

Claude Tag, announced by Anthropic in June 2026, brings Claude into a Slack channel as a standing team member. An admin grants it access to specific channels, tools, data, and codebases; from there, anyone in the channel can tag @Claude and delegate a task while they do something else. A few things define how it works, per Anthropic's own description:

• It's multiplayer. There's one Claude per channel, shared by everyone in it — not a private session per person. Anyone can see what it's doing and pick up where the last person left off.
• It learns over time. Claude builds context from the channels it's in, and can pull in context from other channels and data sources it's been granted access to (it doesn't report from private channels).
• It takes initiative. With "ambient" mode on, Claude proactively surfaces relevant updates and follows up on threads that have gone quiet, without being asked.
• It works asynchronously. You hand it a task and move on; it can also schedule and pursue work autonomously over hours or days.

Access is scoped per admin-defined "Claude identity" — a model set up for sales work doesn't share memory or data access with one set up for engineering. Admins set organization- and channel-level spend limits and can audit everything Claude has done and who asked for it.

Claude Tag replaces the previous Claude in Slack app and is in beta for Claude Enterprise and Team customers, starting on Slack with Anthropic's stated intent to expand to more places over time. Its model choices include Opus and Sonnet, subject to Anthropic's available models and organization policy. Users can switch models within a thread or set a channel default, where permitted. Claude Tag can also subscribe to an individual GitHub pull request and respond to comments, failed checks, or merges on that PR.

What AgentConnect is

AgentConnect is an open-source platform (Apache 2.0) for the same underlying job — letting a team delegate work to agents in the conversations and tools they already use — built around three choices that Claude Tag, being a single-vendor Slack feature, doesn't need to make: which agent, which channel, and who hosts it.

• Any ACP-compatible agent. Configure agents to run Claude Code, Codex, Grok Build, DeepSeek, Pi, or any other agent that speaks the Agent Client Protocol. Choose the runtime and model per agent across supported providers.
• More than one place to work. Connect agents to Slack, Telegram, Discord, and Lark/Feishu, and trigger them directly from GitHub, GitLab, and Gitea pull requests and issues, or from a Linear issue assignment — in addition to webhooks and schedules.
• Specialized agents that collaborate. Give each agent its own role, runtime, model, workspace, memory, tools, and skills, and let agents call one another as part of a shared workflow. For example, a support agent can ask a payments specialist to inspect an incident, then use the findings to respond in the shared conversation.
• Boundaries that separate access from visibility. Decide who can use an agent, who can see its sessions, and which repositories, tools, and other agents it can reach — synced with your existing GitHub and Slack roles rather than managed as a separate system.
• Self-hosted or hosted. Run the whole stack — including agent execution and workspaces — in infrastructure you operate using Docker Compose or Kubernetes, or use AgentConnect Cloud's console while still pointing it at daemons you run.

We build AgentConnect, so take the framing with that in mind — but every claim above is drawn directly from the public documentation linked throughout, not from how we'd like it to be read.

Where the two overlap

Both products are built around the same basic shift: an agent that lives in a shared conversation rather than a private chat window, that teammates can see and pick up after each other on, and that an admin can scope down to specific tools and data. Both let an agent work asynchronously and report back where the team is already looking. If your team hasn't tried this pattern yet, either product will feel like a meaningfully different way of working than a personal chatbot tab.

Where they differ

Model and runtime choice. Claude Tag lets teams choose among supported Claude models, including Opus and Sonnet, within their organization's policy. AgentConnect lets you choose both the runtime and model per agent across providers, and run different runtimes side by side. This matters if you already have a runtime preference, want to compare providers on the same workflow, or don't want a single vendor's roadmap to be your team's roadmap.

Where agents can be triggered from. Claude Tag's user-facing interface is Slack. Its PR subscriptions wake on activity on an individual GitHub pull request, but do not provide repository-wide triggers such as every newly opened PR. AgentConnect connects the same agent roster to Slack, Telegram, Discord, and Lark, and — separately — starts agents from configured GitHub, GitLab, and Gitea pull request and issue events, and from Linear issue assignment. The difference is the available entry points and event scope for starting work.

How agents collaborate. Claude Tag shares one Claude within each channel, and administrators can configure separate identities with scoped memory and tools for different uses. AgentConnect lets teams bring several specialized agents into the same conversation or configure agent-to-agent calls across separately configured runtimes, tools, and permissions. That flexibility adds configuration and coordination; teams whose work fits a shared Claude in each channel may prefer the simpler setup.

Access control shape. Claude Tag scopes a Claude "identity" to a set of channels and tools, with organization- and channel-level spend limits and an audit log. AgentConnect separates who can use an agent from who can see its sessions, and separately scopes which repositories, tools, and other agents each agent can reach — synced with roles your team already manages in GitHub and Slack, rather than a parallel permission system.

Deployment and openness. Claude Tag is a hosted feature of Claude Enterprise and Team — there's no self-hosted option, and the source isn't open. AgentConnect is Apache-2.0 licensed; agent execution and workspaces stay in the environment you operate whether you self-host the full stack or use AgentConnect Cloud's console.

Where Claude Tag has the edge

If your team is already standardized on Slack and Claude Enterprise or Team, Claude Tag is close to zero setup — no infrastructure to run, no daemon to install, and it's the most tightly integrated route to Anthropic's own models and ambient behavior tuned specifically for them. For a team that has no interest in running infrastructure, wants one well-supported agent rather than a roster to configure, and works entirely inside Slack, that's a legitimate and simpler answer.

Where AgentConnect has the edge

AgentConnect is built for teams that don't want to make Claude Tag's implicit choices for them: teams that want to compare or mix agents and models, that work across more than Slack, that trigger agents from pull requests, issues, or Linear tickets as often as from chat, that need agents on different runtimes to call one another with distinct tools and permissions, or that need to keep agent execution inside infrastructure they control for compliance or data-residency reasons. None of that requires giving up the core pattern — an agent working in a shared, visible conversation — that made Claude Tag worth building in the first place.

Getting started

Both are worth trying against your team's actual workflows rather than deciding from a comparison alone. AgentConnect is open source and self-hostable today, with a hosted Cloud console if you'd rather not run the daemon yourself.

• GitHub → https://github.com/agentconnect-md/agentconnect — if you find this useful, a star helps others find it too.
• Website → https://agentconnect.md
• Documentation → https://docs.agentconnect.md