The harness moves up to the org

A year of writing about agents trained a precise vocabulary. An agent is a model plus a harness, and the harness is the half you own: the tools the model may call, the context it sees, the memory that survives a turn, the loop that carries a long job to the end. In almost every example we reached for, that harness lived close to a single person. It was the scaffolding an engineer wired on their own machine, under their own account, for their own work.

On 23 June 2026, Anthropic shipped the release that changes the scale of that word. Claude Tag lets anyone tag @Claude into a Slack channel, where it takes on real work using the organization’s tools and the shared context around it. It reads, at first, like a chat convenience. It is a harness that has climbed a level: out of the individual’s laptop and up to the organization, where it becomes a standing object the whole company shares, with an identity of its own.

The old integration, Claude in Slack, ran the model under your personal permissions in a private one-to-one chat. The new one states its rule in five words. “Access follows the channel, not the user.”

Access follows the channel, not the user

That one line is the whole paradigm shift, and it is worth slowing down on. Earlier, an agent in your tools was a borrowed human. It logged in as you, saw what you saw, and acted with your reach. Convenient, and quietly wrong: the access model and the identity model were a person’s, on loan, with no boundary that belonged to the agent itself.

Claude Tag operates under service-account credentials, set per channel by an admin. The agent is no longer a stand-in for whoever invoked it. It is an entity with its own identity, its own scoped reach, and its own trail. When it opens a pull request, the commit is authored by the Claude app, not by a person it was pretending to be. When an administrator wants to change what it can touch, they change the channel, not a human’s account.

This is governance moving into the interface. The question a security team used to ask after the fact (what could this thing reach, and on whose authority) is now answered by the same configuration that turns the agent on. You do not bolt a boundary onto a borrowed login. You give the agent an identity and scope it.

One Claude the whole room can steer

If the access model changed underneath, the interaction model changed on the surface, and the two are the same move seen from two sides. There is no new application to open. The interface is the channel the team already works in.

You start a task by tagging @Claude with it. Anyone in the channel can steer a running session by replying in its thread, so a second person can redirect work a first person began. When it finishes, the result carries an “Open session in Claude” link to the full tool-call history, so the work is legible after the fact, not a black box that simply returned an answer. The shift is from a private assistant you prompt to a shared colleague you delegate to in the open. The conversation is the agent’s interface.

A session is a sandbox the thread outlives

Underneath each task is an ephemeral cloud sandbox that Anthropic hosts: a real working environment where the agent can read documents, run code, build charts, and open pull requests. The sandbox is created when a conversation starts and discarded when it goes idle. Two threads in the same channel are two separate sessions in two separate sandboxes.

The piece that matters is what survives the discard. The compute is disposable; the thread and its memory are not. When the sandbox is released, the conversation and what the agent learned in it persist, so the next tag resumes against the last one rather than starting cold. Ephemeral where it should be ephemeral, durable where it should be durable.

The harness, drawn as org primitives

Set the pieces side by side and the shape is familiar. We have always said the harness is tools, context, memory, feedback, and orchestration. Claude Tag is those same parts, re-expressed as organizational objects with owners and boundaries. The memory is scoped on purpose: public channels share a store across the workspace, while private channels keep isolated ones: a Claude set up for sales will not pass its memories to one set up for engineering. The harness did not get simpler. It got an org chart.

What we argued, one level up

We made the general case in the harness is the half you own: an agent is a model plus a harness, the model is bought and the harness is built, and the half you build is the only half you own. Claude Tag is that claim lifted from the developer to the organization.

The thing worth naming plainly is that the interface question and the governance question turn out to be one question. How a person reaches the agent, by tagging it into a channel, is the same fact as what the agent is allowed to reach, the access the channel carries. The surface where humans meet the agent and the surface where the organization governs it are the same surface.

The gap widens on its own

Put two businesses on the same frontier model and change one thing: where the harness lives. One keeps an agent per person, each under its own login, its own memory, its own slice of access. The other lifts the harness to the organization. Let them scale, and the curves come apart.

The reason is the context boundary. Real work crosses them without pause: person to person, team to team, one tool to the next. For the per-person setup every boundary is a fresh handoff, because the agent on the far side has never seen the thread, holds none of the memory, and has to be re-permissioned before it can act. Each crossing taxes the next, and the handoffs cap throughput no matter how good the model becomes.

The org-level harness resolves the boundary once. One identity reaches across the channel, one memory survives the handoff, one access surface is already wired, so the agent picks up on the far side in real time. A bottleneck removed once stays removed, and the gains compound. The curve does not step up. It bends.

Where this honestly stands

The discipline of a note is to read the release at its word and mark the edges. Claude Tag is in beta, on Slack only at launch, for Team and Enterprise plans. It replaces the earlier Claude in Slack app, which retires on 3 August 2026. Anthropic places it on Claude Opus 4.8 and reports that its own teams now delegate much of their work to many Claudes in parallel. We read that for direction, as the company’s own figure rather than an independent result.

None of those edges change the shape of the thing. A beta on one surface is still the first general productization of an org-level harness: identity and access and memory and audit and schedule, wired as one object a company configures.

The half you own, now org-shaped

For a lab whose practice is wiring frontier models into operating businesses, this is the shape of the work, named out loud. We do not hand a company a chatbot per desk. We design the org’s agent: the identity it acts under, the tools and data it may touch, the memory it keeps and the walls between teams that memory has to respect, who in the room is allowed to steer it, and what it does on a schedule when no one has asked. That is an org-level harness, and it is the half a business owns.

Claude Tag makes the surface official. It does not make the design decisions for you. What to expose and what to wall off, which team’s memory stays sealed from which, what the agent is trusted to do unattended and what stays behind a person, that is judgment, and it is exactly the embedding work we argued for in the capability overhang.

If there is an agent somewhere in your operation that still acts under one person’s login, that is a design you have already outgrown. Start a conversation about a Discovery Phase.