Agents working alone is a solved problem now. Drop a well-scoped task on a capable model, give it tools, and it runs. Humans working alone has never been the problem either, we have had thousands of years to figure out how a person sits down and does a piece of work. The thing nobody has built is the part in between, where a human and an agent are working on the same thing at the same time and have to trade it back and forth without dropping it.
I notice this every day because I run about 15 agents to operate my company. They draft content, run outbound, manage research, track tasks. Most of the time they work without me. But the moment a piece of work has to cross from an agent back to me, or from me back to an agent, everything falls apart. The agent finishes a draft and I pick it up and the context it was holding is gone the second the chat ends. I make three edits and hand it back, and now the agent has no idea what changed or why. State lives in a chat window that is about to close. I copy-paste the important bits into the next session and hope I grabbed the right ones. The work survives. The understanding around the work does not.
That moment of handing the work across is where the time goes, and it is almost completely unaddressed. The reason it is unaddressed is that the whole industry is sprinting toward one of two futures, and neither of them is the one we actually live in.
The first future is full autonomy. The agent needs no one. You give it a goal and it goes and you find out how it went later. This is the demo everyone wants to give, because it is clean and it shows well. The second future is full human-in-the-loop. The agent cannot move without a person signing off on each step, so it pings you for approval at every turn and you babysit it through the task. This is what most "safe" deployments actually become, because the autonomy version is too risky to trust on anything that matters.
Real work is neither. I am deep in the loop on a positioning decision and completely out of it on formatting fifty research notes. The same agent, on the same project, in the same afternoon, needs me at one moment and needs me gone the next. The interesting question is not how to get all the way to autonomy or all the way to oversight. It is how the work moves cleanly between those two states, over and over, without anyone losing the thread. The transition between in-the-loop and out-of-the-loop is the actual unit of work, and right now nobody has built for the transition. We have built for the two end states and left the road between them as dirt.
That road sits a layer below the models, and the models are where all the attention is. Making the agent smarter does not fix this. A smarter agent still finishes its work in a context that evaporates when the session ends, still has no durable way to know what I touched after it handed off, still cannot tell me apart from the next agent in line. Those are not intelligence problems. They are coordination problems, and we solved the human version of them already. People coordinate through meetings, through Slack threads, through email, through a shared document everyone can see. Those primitives assume every participant is a person with a memory, a name, and a login. Agents cannot use any of that, not really. They need their own primitives, and the primitives barely exist yet.
Start with shared state. When I hand work to a colleague, we both know roughly where things stand because we share a context that persists. When I hand work to an agent, the state lives inside a conversation that disappears the moment it closes. There is no durable surface where both the human and the agent can read the current truth of the work and write changes that the other side sees immediately. Shared state is the thing that lets me make my three edits and have the agent treat them as the new starting point, instead of reconstructing a guess from a pasted summary. Human-agent collaboration will not function until that state exists as a real object, not a transcript I scroll back through.
Tied to that is persistent context. An agent that forgets everything the moment the chat ends is not a coworker, it is a temp who quits at the end of every shift. What the agent tried, what it learned, what it decided and why, all of it has to outlive the session and be available to whoever picks the work up next, human or agent.
Then identity. Today an agent usually acts as me. It logs in with my credentials, sends from my account, and leaves a trail that says I did everything. That breaks fast when you run more than one. When fifteen agents and one person all act under a single login, you cannot answer the most basic question about any piece of work, which is who did this. AI identity means the agent is a participant in its own right, with its own name on its own actions, not a costume worn over my account. AI authorization is the other half: this agent can do these things and not those, scoped the way a teammate has a role and a permission set. You do not hand a new hire your personal password. You should not hand an agent your whole life either. Without identity and authorization there is no accountability, and without accountability you cannot hand real work to an agent and walk away.
All of that has to live somewhere. An AI workspace is the shared surface where the human and the agents work the same artifact, where state persists past the end of any single chat, where identity and permissions are real, and where a hand-off is a normal supported motion instead of a copy-paste scramble. We have workspaces for humans. We have model APIs for agents. We do not have the place where the two of them sit down at the same table. That missing place is the seam, and closing it is the whole game right now. It is the same infrastructure we built for human teams over thirty years, rebuilt for a world where some of the team is not human. That is the surface I am building toward, because I run into its absence every single day.
Here is what I am sure of. The next phase of this is not won by whoever ships the smartest standalone agent, or the most cautious one. It is won by whoever makes the trade-off between those two go away, so a person and a machine can pass the same piece of work back and forth all day and never drop it. The model race is loud and mostly settled in its direction. The collaboration layer is quiet and wide open, and it is where the real work of the next few years gets done.