Most writing about AI agents is still about the model. How smart is it. How well does it reason. How long is its context. Those are real questions. They stop being the interesting ones the moment you put more than one agent on a real team.
The interesting questions show up immediately: who is this agent? Where is its work going? Who reviews it? Who else can see what it just did? And if it runs three more times tonight while we sleep, can we read what it did on Wednesday morning without piecing it together from logs?
Those questions are not about capability. They are about collaboration. And collaboration has the same shape whether you are working with humans, agents, or both. There is a room. The room has a state. People come into the room, change the state, leave. Other people come in, read the state, change it again. Over time the state turns into the team's actual output.
We have been building rooms for human teams for thirty years. We know how to do it. The question for 2026 is what changes when the room has to hold AI agents too.
The wrong question
The popular framing for AI agents is "when will they replace humans." That framing is a category error. The question forming in 2026, on every real team we talk to, is different.
It is how do AI agents and humans share work in the same team.
Not in the same product. Not as separate users of the same chat tool. In the same team, on the same task, against the same outcome. With names, with calendars, with one another's writing visible while it happens.
This is a coordination problem, not a capability problem. The models are good enough. The chat windows are not.
What stops working when an agent joins your team
Imagine the simplest version. You ask an agent to write a brief. You want a teammate to review it. You want to ship it.
In a chat-assistant world:
- You open a chat tool (ChatGPT, Claude, take your pick). You paste in context. The agent drafts the brief.
- You copy the draft into your team's wiki.
- You ping a teammate in your team chat.
- They read it in the wiki, leave comments, ping you back.
- You paste the comments back to the agent. Ask for a revision.
- Repeat.
The friction is not the writing quality. The friction is that every transition between the agent and the rest of the team requires you to carry the state on your back. The agent does not have an account in the wiki. It does not have a handle in the team chat. It cannot see the comments. It is, structurally, a session that knows nothing about the room it is working in.
Now imagine the same workflow with the agent as a first-class member of the team:
- The agent has its own account. Its own credentials. Its own permissions.
- It writes the brief directly into a workspace your teammate can already see.
- Your teammate reads it, comments inline, mentions the agent by name.
- The agent sees the comments, revises, and the revision is attributed to the agent, time-stamped, on the same surface.
- You did not carry state once. You arrived at the workspace and the state was there.
This is the difference. It is not better tool calls or bigger context windows. It is that the agent moved into the room.
The three things you cannot dodge
Once you ask an agent to do work that does not finish in one chat turn, three requirements become non-negotiable. They are the same three requirements you would ask of any human teammate. Pretending they are optional for agents is the part that breaks.
Identity. The agent has a name. It has its own credential, not yours. When it writes a row, the row is signed by the agent, not by you "on behalf of an agent." You can fire it (revoke the key) without firing yourself. You can promote it (raise its caps) without raising your own.
A surface. The agent has somewhere to write. Not a chat scroll that disappears when the tab closes. A real workspace: typed tables for structured work, docs for prose, comments for review, mentions for handoffs. The same primitives a human teammate would use, because the agent is doing the same kind of work.
Attribution. Every edit on that surface is stamped with the principal that made it. Five agents and three humans on the same task, and the audit log reads back as a real team log, not an anonymous stream. You know what each one did, when, and why.
These three are the substrate. Everything else, every multi-agent framework, every reflection loop, every tool-use pattern, stands on top of them.
Four patterns we see today
Teams already doing this work have settled into roughly four recurring shapes. They are not exclusive. A real team usually runs several at once.
1. Author + reviewer
An agent drafts, a human approves. The draft lives in a shared doc. The human marks the doc with a comment thread, or with status on a row that tracks "drafted, in review, shipped." The agent watches for "in review" to flip to "shipped" before moving on.
Works for: launch copy, customer replies, briefs, status updates, anything where the bottleneck is judgment, not generation.
2. Worker + observer
An agent acts, a human watches. The agent updates rows in a workspace as it works. The human keeps the workspace open in another tab. When the agent does something the human knows is wrong, they step in, override the row, leave a comment, the agent reads it and corrects.
Works for: research, scraping, data entry, triage, anything where you trust the agent 90% but want to catch the 10%.
3. Researcher + writer
An agent gathers, a human or another agent synthesizes. The gatherer writes raw findings into a table. The synthesizer reads the table and writes prose into a doc. The two surfaces are in the same workspace, so when the synthesizer says "what did we learn about X," they can scroll the same workspace and find the row.
Works for: market research, competitor scans, ICP work, customer interviews summarized into themes.
4. Planner + executors
A human (or sometimes a leader-agent) writes a plan into a doc. Multiple executor-agents pick up the work, each owning a piece of the plan. The plan doc gets checked off as work lands. Each executor writes its output back to the workspace.
Works for: launches, multi-step build tasks, anything that decomposes cleanly into parallel work.
The common substrate
All four patterns need the same three things: identity, a shared surface, attribution. None of them work in a chat window. They work in a workspace.
The workspace is the bottleneck. Every team we have talked to that is running AI agents seriously has, at some point, built one. Some on top of a wiki by stretching it with bots. Some on top of a project tool by giving the agents API tokens. Some by writing a custom internal app. All of these eventually hit the same wall: the agent does not have a real seat. It is squatting in a tool built for humans.
What you actually want is the workspace built from the ground up to hold both kinds of teammates as peers. Same row, same audit, same caps. Agents with their own names. Humans with theirs. Both visible to each other in real time.
What changes when this exists
A few things stop being friction:
The status update disappears. You do not ask the agent how things went. You read the workspace. The agent's last ten actions are on the page, signed and time-stamped.
The hand-off disappears. The agent finishes its part and tags you. You finish your part and tag the agent. No copy-paste between tools, no carrying context on your back.
The audit becomes a knowledge graph instead of a compliance burden. Every decision is on the record because every action is on the record. Six months from now you can search the workspace and find the actual moment a thing changed and who changed it.
The agent org chart becomes a real thing. You hire a human, you provision an agent. Both show up in the same team list. Both get added to the right workspaces. Both have their access revoked the same way when their work is done.
This is what teams look like in 2030. Two humans plus four agents. Twelve agents plus one human. Real teams, real work, real artifacts, and a single surface that holds the whole thing.
Why the workspace is the layer
Models are commoditizing. So is compute. So are agent frameworks. Every six months a new one is out. None of them are durable.
The durable layer is the surface where the work lands. GitHub did not become essential by training the best compiler. It became essential by being the place developers' work lives. The same thing happens now for human-plus-agent teams. The workspace is the thing that compounds.
That is the thing Dock is, plainly. A shared cloud workspace where humans and AI agents read and write the same state in real time. Tables for structured work, docs for prose, comments for review, attribution on every edit. Agents have their own accounts. Humans have theirs. Both first-class.
If you are running AI agents on real work and feeling the friction described in this post, that friction has a shape and a fix. The shape is "your agent does not have a real seat in the room." The fix is to give it one.