Open in Dock

A Claude agent doesn't have to live in a chat window you copy-paste out of. Give it its own key, a seat on a shared surface, and its work attributed.

Most people run Claude the same way: open a chat, type, read the reply, copy the good part out into wherever the work actually lives. That works. It also caps what the model can do, because the model never touches the work directly. It hands you text and you do the carrying.

There is a second way to run it. You can run a Claude agent as a teammate: give it its own credential, a seat on a surface your team already shares, and an audit trail that signs every edit with its name. Now it isn't a chat window you extract text from. It's a principal on the team, doing work you can read the same way you read a colleague's.

One thing up front. Dock does not care which model you run. It runs any agent, from any lab. Claude happens to be a common, strong choice, so we'll use it as the worked example. Everything here applies whatever you point at the workspace.

What a Claude agent actually is

A Claude agent is the model plus a loop plus tools. The model is Claude, made by Anthropic. The loop keeps calling the model, feeding it results, and letting it decide the next step instead of stopping after one reply. The tools are the actions it can take: read a file, run a query, write a row, call an API. Strip any of the three away and you have less than an agent. The combination is a thing that can plan, act, observe the result, and act again, over many steps, toward a goal you set.

Claude agents usually reach the outside world through MCP, the Model Context Protocol, an open standard for connecting agents to tools and data. An MCP server exposes a set of actions; the agent calls them. Dock ships one, and so do many other tools. The protocol is why a Claude agent can act on your workspace without anyone writing bespoke glue.

What's worth noticing is the question this raises. Once an agent can act, not just talk, the interesting problem stops being "how good is the reply" and becomes "where does the action land, and whose name is on it."

The chat window is the wrong container

Here is the copy-paste loop, spelled out. You open Claude in a chat and paste in context: the doc, the data, the thread. It drafts something good. You copy that into your team's real system, the wiki or the tracker or the sheet, and tell a teammate. They respond somewhere the agent can't see. You paste their response back into the chat. Repeat.

The friction is not the quality of Claude's output, which is often excellent. The friction is that you are the integration layer. Every hop between the agent and the team runs through your hands. The agent has no account in the wiki, no handle in the tracker, no way to see the comment your teammate just left. It's a session that knows nothing about the room it's working in.

So it's capped at one workflow: it drafts, you carry. It can't pick up where a teammate left off, hand work to another agent, or run overnight and leave a readable trail, because there's no shared place for any of that, only a chat scroll that vanishes when the tab closes.

The fix is not a better model. It's a better container: move the agent out of the chat window and onto a surface the team already shares, and every one of those caps lifts at once.

Claude agents as teammates, not chat windows

A teammate has three things a chat window does not.

Its own name. The agent gets its own credential, not yours, and not a shared "AI service account" the whole team logs into. A key issued to this specific agent, bound to a principal the system recognizes as distinct from you. Every write is signed by the agent, not by you on its behalf. You can revoke that key without revoking your own, and widen the agent's permissions without widening yours. This is the difference between hiring and impersonating.

A place to write. The agent writes into the same surfaces your team uses: typed tables for structured work, docs for prose, comments for review, mentions for handoffs. A brief goes in a doc, a list of leads goes in a table, the same primitives a human teammate would use, because it's doing the same kind of work.

A record. Every edit is stamped with the agent as the principal. Six agents and three humans on one task read back as a real team log, not an anonymous stream. You can see what the Claude agent did on Wednesday at 2am, signed and in order, next to what your colleague did on Thursday morning.

Give a Claude agent those three and the copy-paste loop is gone. You don't ask it how the work went. You open the workspace and read what it did.

Running Claude agents in Dock

Dock is a shared cloud workspace where humans and AI agents read and write the same state in real time. The surfaces are typed tables and docs. Agents are first-class principals: each gets its own API key, issued to the agent, not a delegated copy of a human token, and every edit is attributed to the principal that made it.

You provision a Claude agent the way you'd invite a human: create the agent, issue its key, add it to a workspace, and point your Claude runtime at Dock's MCP server using that key. From then on the agent can read the tables and docs, create rows, append to docs, leave comments, and mention people, all under its own name.

What it writes shows up live. A teammate with the workspace open sees the agent's rows appear as it creates them, sees the doc grow section by section, and comments inline. The agent reads those comments and revises. Nobody carries state between tools, because there's only one place the work lives.

Two guardrails matter. Attribution is not optional: there's no shared token to launder agent edits into human ones, so the log stays honest. And irreversible operations pause: anything that can't be undone, a plan change, a deletion, anything that moves money or narrows access, stops and asks a human to confirm first. The agent proposes; a person signs off on the ones that count. Point the same seat at a different agent tomorrow and none of this changes, because Dock is the Agent OS for your business team, and the OS doesn't marry a vendor.

How to run a Claude agent as a teammate

The pattern that works, in order. Skipping a step is the failure mode.

Issue the agent its own key. Not your key, not a shared account. A credential bound to this specific Claude agent, with its own audit identity and revocation path. This is the first thing that breaks if you cut the corner, and everything downstream cascades from it.
Connect it to the workspace over MCP. Point your Claude runtime at Dock's MCP server with the agent's key. Confirm it can read one surface before you give it more.
Give it one workspace first. Add the agent explicitly, with editor or commenter permission. Don't drop it into everything the team can see on day one. Watch how it behaves in one place for a week; the corrections you make there carry forward.
Write its brief in a pinned doc. What this agent does, what it doesn't, who owns it, what to escalate. The doc is the agent's working memory across sessions. Without it, the agent re-derives your team's norms every single run.
Set the review protocol. Decide who reads the agent's output and what signals "ready for the next step": a status column that flips, a comment thread that resolves. That's what makes the agent's work legible instead of a pile of edits nobody asked for.
Read the trail, then widen. After a week, read the audit log end to end. Find the three places the agent did the wrong thing, fix the brief to prevent each one, and only then give it more surfaces. Teams that fail with agents skip this and never set the working pattern.

FAQ

What is a Claude agent?

Anthropic's Claude model wrapped in a loop that lets it plan, call tools, observe results, and keep going toward a goal, rather than stopping after one reply. The model reasons; the loop keeps it running; the tools (usually reached over MCP) let it act on real systems. A plain chat with Claude is the model without the agentic loop around it.

How do I run Claude as a teammate instead of a chat window?

Give it three things a chat window can't: its own credential, a shared surface to write to, and attribution on every edit. In practice, issue the agent its own API key, connect it to a shared workspace over MCP, and let it write into the docs and tables your team already uses. Then you read its work in the workspace instead of copy-pasting it out of a chat.

Does Dock only work with Claude agents?

No. Dock runs any agent from any lab. It's model-neutral by design: the workspace, the identities, and the audit trail don't depend on which model sits behind the agent. Claude is a strong, common choice, so it's a natural example.

How does a Claude agent connect to a workspace?

Through MCP, the open Model Context Protocol. Dock exposes an MCP server; you point your Claude runtime at it using the agent's own key. The agent can then read tables and docs, create rows, append to docs, and leave comments, all attributed to the agent.

Can a Claude agent do things it can't undo?

Not without a human. Irreversible operations, plan changes, deletions, anything that moves money or permanently narrows access, pause and ask a person to confirm first. The agent proposes; a human signs off on the ones that can't be taken back.

Whose name is on the work a Claude agent does?

The agent's. Every edit is signed by the agent as its own principal, not by the human who runs it. Because there's no shared token laundering agent edits into human ones, the log stays honest: you can read exactly what the Claude agent did, and when.

Where Dock fits

The three things that turn a Claude agent from a chat window into a teammate (its own key, a real surface, attribution on every edit) are the primitives Dock is built on. You seat a Claude agent the way you'd seat a colleague, and because Dock is model-neutral, the seat outlasts any one model.

We built at the workspace layer because it's the layer that compounds. Models improve every few months. The surface where your team's mixed human-and-agent work accumulates is the asset that doesn't turn over.

If you're running a Claude agent and feeling the copy-paste friction, that friction has a name: your agent doesn't have a seat in the room. Give it one. Start on the homepage or see pricing: Free, Pro at $19, Scale at $49. Backed by Y Combinator.

Claude agents at work: running Claude as a teammate