Claude Tag made it easier to bring agents into team workflows. The next question is what those agents can see, touch, remember, and escalate.
After we all saw Claude Tag, AI work is moving back into the places where teams already work.
That may sound small. It is not.
For a lot of firms, AI still means opening a separate chat window, pasting in context, asking for help, and then copying the result back into Slack, Linear, Notion, email, or wherever the real work lives.
That pattern is useful, but it is clumsy. It makes the human act as the router, memory, reviewer, and translator between the AI tool and the team.
Claude Tag and Open Tag point to a different direction. Instead of pulling work out of the channel and into a private AI chat, you tag an agent inside the thread where the work is happening.
That is why these tools are worth paying attention to. They make the agent feel less like a separate app and more like part of the workflow.
Chat-native agents reduce the copy-paste loop by working where the conversation already lives
What Claude Tag is
Claude Tag is Anthropic's new way to use Claude inside Slack.
It is currently available in beta for Claude Team and Enterprise customers. Anthropic's help documentation says it works in Slack today, with Claude in Slack switching to the Claude Tag experience on 3 August 2026.
The basic idea is simple. In an authorised Slack channel, someone tags @Claude and asks it to do work.
Claude can use the channel context, respond in the same thread, work asynchronously, and use tools or data sources that admins have connected. Anthropic also describes memory, direct messages, an assistant panel, spend controls, permissions, and activity review as part of the product.
So Claude Tag goes beyond a Slack mention. It gives Claude a shared work surface, admin-managed access, and a visible thread where the team can see the request and the result.
For teams that already use Claude, that is a useful step. You do not have to move the whole conversation into a separate assistant window.
Why teams care
The first benefit is less context-pasting.
If a team is already discussing a client issue, a support ticket, a bug, or a research question in Slack, the agent can start from the thread instead of a hand-written summary. That saves time, but it also reduces the risk that someone leaves out the part that mattered.
The second benefit is shared delegation.
When one person uses a private AI chat, the learning stays with that person. When the agent works in a shared channel, the team can see what was asked, how the request was phrased, what came back, and what needed follow-up.
That matters because many firms are still learning how to delegate to AI. Shared examples teach faster than private experiments.
Claude Tag also shows where enterprise AI products are heading. The serious version of "agent in chat" quickly becomes an identity, permission, memory, and audit problem.
Anthropic's own docs make that clear. Admins decide where Claude can work, what tools it can use, how spend is limited, and how activity and memory can be reviewed.
What Open Tag means
Open Tag is messier, and that is part of the story.
Open Tag is better understood as a pattern spreading across several open-source projects
There is not one clean product called Open Tag that owns the whole idea. Instead, several open-source projects and examples have appeared around the same pattern: tag an agent where work is happening, let it read the thread, connect it to tools, and keep the result in the shared conversation.
CopilotKit/OpenTag is one example. It describes itself as an open-source alternative to Claude in Slack, with a self-hosted, bring-your-own-model approach and tool wiring through CopilotKit's bot SDK.
linxidnju/OpenTag takes a gateway angle. It routes Slack threads to different local or hosted agent runtimes, with approvals, audit records, artifacts, and workspace restrictions.
open-tag and getopentag.com go broader. They frame the idea as a self-hosted workspace where humans and AI agents collaborate in channels, threads, direct messages, tasks, files, and local runtimes.
Milvus/Zilliz also published an Open Tag example on MFS, focused on context and memory across code, docs, tickets, chat, databases, and other sources.
The names overlap, but the direction is clear. Taken together, these projects suggest developers want more than one managed agent in one vendor's product. They want the pattern to be open, adaptable, and connected to the runtimes they already use.
What Open Tag gets right
Open Tag answers a real concern: lock-in.
Claude Tag is Anthropic's managed Claude product. That may be exactly what some teams want, especially if they already use Claude Team or Enterprise.
But other teams want model choice, local control, self-hosting, custom tools, and a way to connect agent work to their own runtime. Open Tag-style projects respond to that need.
They also make the agent-in-channel pattern easier to experiment with. A technical team can test the workflow, connect its own tools, and see what happens when agent work moves from private prompts into shared threads.
That said, open source changes the responsibility. It does not remove it.
If you self-host an agent in Slack, someone still has to manage credentials, permissions, deployment, memory, logging, observability, updates, failures, and approvals. The code may be open, but the operating burden is still real.
Managed convenience or open control
Claude Tag and Open Tag are not simple opposites. They answer different questions.
Claude Tag lowers setup burden for eligible customers. Open Tag-style projects give more control but also more responsibility.
That comparison is useful, but it misses the bigger point if you stop there.
The more interesting shift is not "Claude Tag versus Open Tag". It is that both make the same interface obvious: the agent is entering the work channel.
The tag is only the interface
Once you see the pattern, it is tempting to think the main question is which agent to tag.
That is the wrong starting point for serious firm work.
A tag can bring the agent into the conversation. It cannot decide what the agent should be allowed to know, which tools it can use, when a human must approve, or how the firm can reconstruct what happened later.
Those decisions matter more as the work becomes more consequential.
If an agent summarises a long Slack thread, the risk is usually lower. If it drafts client advice, files a support response, changes a project plan, opens a pull request, updates a CRM record, or touches production data, the operating design starts to matter.
This is where many firms will feel the gap. The interface is easy to understand, but the operating layer is still missing.
The tag gets the agent into the workflow. The operating layer makes the work usable, accountable, and defensible.
Five questions before you tag agents into real work
Before a firm relies on agents inside shared work, it should answer five questions.
First, what can the agent see?
Channel access is not a small setting. It defines the agent's context, its memory, and the data it may reason over.
Second, what can the agent touch?
Reading a thread, drafting a response, opening a ticket, editing a document, and making a production change are different levels of risk. Treating them as the same kind of action is how teams lose control.
Third, what must a human approve?
Good approval design does not mean approving every thought. It means putting gates around actions that affect clients, money, production systems, public content, contracts, or strategy.
Fourth, what does the agent remember?
Memory is useful when it saves repeated explanation. It becomes risky when nobody knows what was stored, where it came from, who can inspect it, or how it can be corrected.
Fifth, how can the firm prove what happened?
If agent-assisted work affects a client, a case, a project, or a decision, the firm needs a record. Chat history alone may not be enough.
Where the Agentic OS begins
This is the point where we enter the conversation.
We do not see Claude Tag or Open Tag as gimmicks. They are useful signs that agent work is moving into the places where teams already operate.
But we also do not think the channel is the system.
At Aikin, we use Agentic OS to describe the operating layer around agents: the integrations, data foundations, outcome tracking, governance, and custom software that turn agent experiments into something a firm can run and trust.
That starts before choosing a tool.
We map how the firm actually works. Then we look at where judgement should stay human, where agents can help, what data they need, what tools they can touch, and where approval or escalation belongs.
Slack, Teams, Linear, Notion, GitHub, email, or a client portal can all be part of the surface. None of them replaces the operating design.
The same applies to models. Claude may be right for one workflow, another model may be better for another, and some work may need local or self-hosted infrastructure.
The durable question is not which model is fashionable this month. It is whether the firm has designed the layer that makes agent-assisted work useful, accountable, and defensible.
We are applying the same thinking in our own work, but the lesson is not about our internal setup. The lesson is simpler: once agents can be tagged into real workflows, firms need rules for what happens after the tag.
A practical way to think about it
Claude Tag gives teams a managed path to bring Claude into Slack.
Open Tag shows that developers want the same pattern with more control, more choice, and more room to adapt.
Both are useful.
But if your firm is moving from AI experiments to real workflows, do not start by asking only which agent to install.
Ask what the agent can see, what it can touch, what it remembers, who approves its actions, and how the work can be checked later.
That is where the real operating work begins.
~From Nicholas Oneill and the Aikin team.
Sources
- Anthropic's launch post: https://www.anthropic.com/news/introducing-claude-tag
- Anthropic's help documentation: https://support.claude.com/en/articles/15594475-what-is-claude-tag
- CopilotKit/OpenTag: https://github.com/CopilotKit/OpenTag/
- linxidnju/OpenTag: https://github.com/linxidnju/OpenTag
- open-tag: https://github.com/fancyboi999/open-tag
- getopentag.com: https://getopentag.com/
- Milvus/Zilliz Open Tag example on MFS: https://milvus.io/blog/open-source-claude-tag-mfs.md
- Aikin Agentic OS: https://aikin.io/agentic-os
FAQ
What is Claude Tag?
Claude Tag is Anthropic's Slack-based way for teams to work with Claude by tagging @Claude in authorised channels. It is in beta for Claude Team and Enterprise customers, according to Anthropic's launch post and Anthropic's help documentation.
What is Open Tag?
Open Tag is best understood as a broader open-source reaction to the Claude Tag pattern, not one single settled product. Examples include CopilotKit/OpenTag, linxidnju/OpenTag, open-tag/getopentag.com, and the Milvus/Zilliz Open Tag example on MFS.
What is the difference between Claude Tag and Open Tag?
Claude Tag is Anthropic's managed Claude product for Slack. Open Tag-style projects aim to make the same agent-in-channel pattern more open, self-hostable, or runtime-flexible.
Why is a tagged agent not enough?
A tagged agent gives you an interface. A firm still has to decide what the agent can see, what it can touch, what it remembers, when it escalates, and how the work is logged.
What is an Agentic OS?
An Agentic OS is the operating layer around AI agents. At Aikin, that means the integrations, data foundations, governance, memory, approval flows, outcome tracking, and custom software that make agent-assisted work usable inside a real firm.