Every agent needs a computer. Multiplayer AI may need a team computer. Don't settle.

An agent that can only talk is an assistant. An agent that can work needs the same things a new hire needs on their first day: a machine to work on, somewhere to keep files, access to the tools the job requires, a login that identifies them, memory of what they did yesterday, and a record someone can check.

Call that set of things the agent’s computer. It is not a metaphor. It is the minimum environment for doing real work rather than describing it.

This post is about two kinds of computer an agent can have, why most teams end up with only one of them by accident, and why settling for that costs more than it saves.

What an agent’s computer is made of

Strip the idea down and six parts remain.

• A place to run. Somewhere the agent’s steps execute, with the resources and isolation the work needs.
• Files. A working directory. Drafts, inputs, intermediate results, outputs. Work that exists only inside a conversation is not work anyone else can pick up.
• Tools. The systems the agent may call: email, the ticketing system, the finance platform, a browser, a code repository. Access to tools is what separates acting from suggesting.
• An identity. A name the agent acts under, distinguishable from every person and every other agent, so that actions can be attributed and permissions can be scoped.
• Memory. What the agent knows from earlier steps and earlier tasks, held somewhere durable rather than reconstructed from a transcript each time.
• A log. What the agent did, in what order, with what result. Not a chat history. An operational record.

Most products that call themselves agentic have the first three and improvise the rest. The last three are where governance lives, and they are also the three that decide whether an agent’s computer can be personal, shared, or both.

The personal computer

A personal computer for a human and an agent is a private working environment the two of them share. The person’s files, the person’s tool access, the person’s history, and an agent that works inside those limits.

This is a good thing, and it deserves a defence, because the rest of this post is going to argue for something larger.

A personal computer is fast. There is no coordination overhead. The person sees everything the agent does because there is nowhere else for it to happen. Scope is simple: the agent can reach what the person can reach, on the person’s behalf, and nothing more. Privacy is built in. A half-formed idea, a draft nobody should see yet, a quick exploration that might go nowhere, all of these belong in a private space where the cost of being wrong is zero.

Where it suits. Individual drafting, research, analysis, learning a new area, trying something before committing to it. Anything where the person is the sole owner of the result and nothing consequential happens until they decide it should.

Where it stops. The moment the work matters to anyone else. A teammate cannot see what was asked or assumed. A reviewer cannot see why the output looks the way it does. An approver has nothing to approve against. The agent’s log is private, so the organisation has no record. Work done on a personal computer is real work, and it is invisible, and invisible work cannot be shared, governed, or audited.

The team computer

A team computer is a shared, governed working environment where several people and several agents work on the same tasks at the same time.

It has the same six parts as a personal computer, but each one is shared and controlled rather than private and implicit.

• The place to run is common. Agents execute in one environment the team can see, not in a scattering of private sessions.
• Files belong to the piece of work, not to whoever started it. A teammate can pick up where another left off, and so can another agent.
• Tools are accessed under scoped permissions set by the organisation. An agent can reach the finance system because it has been granted that for this work, not because the person who launched it happens to have access.
• Identity is explicit for every actor. Every agent has a name; every action is attributed; a person and an agent are never confused in the record.
• Memory is shared where the work is shared, and scoped where the context is sensitive, so that what one agent learns on behalf of one person does not leak into work for another.
• The log is one record for the whole piece of work. Who requested, which agent did what, what evidence it produced, who approved the sensitive step, and what came out.

Two things are added that a personal computer does not need. Approval gates, so that sensitive, financial, legal, or external actions pause for a named person before they complete. And live supervision, so that work is visible while it runs and someone can stop it, rather than discovering what happened afterwards.

Where it suits. Operational work that crosses people and systems: procurement, onboarding, claims, incident response, anything with a reviewer and an approver. Work where several people are accountable for different parts and several agents do different parts.

What it costs. Coordination. A team computer asks the organisation to decide who may do what, and to make those decisions explicit. That is work. It is also the same work organisations already do for people, and it is cheaper to do once in a shared environment than to reconstruct after the fact from a dozen private logs.

Don’t settle

Most teams end up with only one of these, and the one they end up with is usually chosen by accident.

Settling for personal computers everywhere is the common default, because it is what arrives first. Each person gets an assistant. Each assistant gets a sandbox. It feels agentic and it feels safe, because every sandbox is isolated. Then the sandboxes multiply, each holding part of the same piece of work, none of them able to see the others. State is duplicated. Approvals happen in chat threads, or not at all. The audit trail is a set of private transcripts nobody owns. The team has many agents and no way to see the work.

Settling for a team computer only is the less common mistake, and it is the one well-governed organisations make. Every action goes through the shared environment. Every draft is visible. Every exploration is logged. The result is that people stop exploring, because the cost of a wrong first attempt is now that everyone saw it. Private thought moves back to tools outside the system, and the system becomes something people route around.

Both are settling. The reason not to is that work does not stay one shape. It starts private and becomes shared. A person drafts a supplier renewal with their agent on their personal computer. Then it moves to the team computer, where a policy-check agent, a reviewer, an approver, and a finance agent join, and the whole thing runs under supervision with one record. The handoff is the design problem, and it is the one both kinds of settling avoid.

The handoff

When work moves from a personal computer to a team computer, three things are usually lost.

Context. The person pastes a summary of what they and their agent worked out. The summary drops the assumptions, the rejected alternatives, and the evidence. The team starts with less than the person had.

Authority. The agent that did the drafting had the person’s scope. The agents in the team computer have their own. Which permissions carry across, and which must be re-granted, is rarely decided, so it is decided by whatever the tooling happens to do.

History. The personal log stops at the handoff and the team log starts there. Nobody can trace the finished work back to the exploration that shaped it.

A product that takes both kinds of computer seriously has to carry all three across the boundary. The context moves as structured work, not as a pasted summary. The authority is re-evaluated under the team’s scope, visibly. The history is one thread from first draft to final approval, with the private portion visible to the person and the shared portion visible to the team.

That is harder than building either computer alone. It is also the part that decides whether the two computers are a system or merely two products.

What to look for

If you are evaluating tools for a team that works with agents, a few questions separate the ones that have thought about this from the ones that have not.

• Can a person work privately with an agent, with files and tools, before anything is shared?
• When the work is shared, do agents run under their own identities with scoped access, or under the launching person’s credentials?
• Do sensitive actions pause for a named approver, and is the pause visible to the team?
• Is there one record per piece of work, covering every person and every agent who touched it?
• When work moves from private to shared, what happens to the context, the permissions, and the history?

A product that answers the last question with “the user copies it over” has settled.

Where we are exploring

At SoftworkerAI we are exploring both. A personal computer where a person and their agent can draft, research, and try things with their own files and tools, and a team computer where several people and agents run work under identity, scope, approvals, supervision, and one record. The part we spend the most time on is the handoff between them, because that is where we think the value is, and where we have seen the most work quietly lost.

We would rather not settle on one, and we suspect teams would rather not either. If you are working through the same question, we would like to hear how you are approaching it.

The takeaway

Every agent needs a computer: a place to run, files, tools, an identity, memory, and a log. A personal computer gives a person and their agent a private place to work and suits everything that is not yet consequential. A team computer gives several people and agents a shared, governed place to run work that is. Multiplayer AI may well need both, and the handoff between them is the design problem worth solving. Don’t settle for one computer because it arrived first.