Work that comes to you
Enterprise AI is a counter: you walk up and ask. The next workspace brings the work to your desk, and the hard part moves from the chat box to who gets which agent, when.
Published: ·8 min read
Most enterprise AI today is a counter. You walk up, you ask, you wait. The better ones have several windows (a dropdown of agents, the way ChatGPT has a dropdown of models), and an "Auto" option that picks the window for you. But you still have to walk up.
I've spent the last few weeks working out what a firm-wide AI workspace should look like, and the conclusion I keep landing on is that the counter is the wrong shape. The next generation of these tools won't wait to be asked. It will bring the work to you, and the chat box becomes one way in among several.
The problem with a counter is that it makes the employee the scheduler. To get anything out of it, you have to notice the problem, know which agent covers it, phrase the question, then read and check the answer. Only the last step, the decision, is actually your job. Everything before it is you doing the routing a computer should have done.
Take a duplicate customer record. In the counter model, someone has to think "I wonder if any duplicates came in overnight" and go and ask. Nobody does, of course, so it gets found later by whoever trips over it. In the delivery model, an agent checks every night, finds the pair, puts the evidence together and leaves one item in your inbox: these two records look like the same person, merge or keep them separate? Your morning starts with a decision instead of a search.
The big platforms are already moving this way, even if their marketing still says "chat". Microsoft 365 Copilot has an agent store where agents are centrally approved and assigned to particular groups. Gemini Enterprise has an agent gallery with administrator-provisioned access. Glean now runs agents off schedules and changes in other systems, not just off someone typing. Put those together and the shape is clear: one workspace for the employee, many independently owned agents behind it, governed discovery, and work that can start from either side.
So what does the employee actually see? Three doors into the same work. Ask is the counter, kept because sometimes you do have a question. Inbox is where agent-initiated work lands: approvals, finished reports, alerts that need a person. My Work is everything you've delegated that's still running, scheduled or done, because a task you hand an agent at 4pm shouldn't die when you close the browser.
The distinction people blur most is between a notification, an inbox and a mailbox. A notification tells you something happened ("your report is ready") and is gone once you've seen it. An inbox is a persistent place for things that need you, so an approval doesn't get buried under twenty chat messages. A mailbox, in the agent sense, is addressable messaging between agents, so a risk agent can leave a request for a research agent that's busy or offline. Most firms need the first two now. The third becomes useful when agents need to talk to each other across hours, not seconds, and until then agent-to-agent calls (A2A) do the job.
The second thing that changes is what arrives. A counter hands you paragraphs. Delivery hands you something you can act on: a table of the two records, the evidence, and two buttons. This is where the frontend world is heading too. OpenAI's Intelligent UI, launched this month, has the model compose responses from a library of native components instead of writing text. Open projects like A2UI, OpenUI and Vercel's json-render do the same thing for your own app, AG-UI streams an agent's progress and state into the page, and MCP Apps lets a tool ship a whole interactive app when a card isn't enough.
The part that matters for a bank or any regulated firm is the split of responsibilities. The agent chooses the layout. The frontend owns which components exist and how they behave. And the Merge button calls a normal backend API that checks whether you're allowed to merge, exactly as it would if a human had built that screen by hand. The model never gets to run the action itself. So the frontend stops being a fixed set of screens and turns into a rendering platform with rules, and applications start exposing capabilities and data rather than pages.
Here's where it stops being a UI project. Delivery means agents act on people who didn't ask for anything, so the hard engineering moves behind the workspace, into what I'd call the control plane: which agents exist, who owns them, who may use them and who has them switched on today. And the single most useful idea I found is that releasing an agent is three separate decisions, not one. Publishing asks whether Agent B is an approved, working service. Permission asks whether this person is allowed to use it. Rollout asks whether it's switched on for them right now.
Keep those apart and a release becomes a dial instead of a cliff. A pilot group, spread across teams rather than one corner of the firm, can see Agent B and pick it by hand. Once it behaves, Auto is allowed to route the pilot's questions to it. Then the group widens, half and then everyone permitted. Proactive work, where the agent starts things itself, comes last, because that's the point at which it can affect people who never asked it anything.
The trap is treating the rollout switch as a security control. It isn't one. If the interface shows Agent B to someone by mistake, the backend still has to refuse them, and the same check has to run whether a person picked the agent or Auto did. The same goes for gates between stages. You only widen a cohort when the agent's evaluations still pass, and that's a step plenty of teams skip: LangChain's survey in June found 89% of teams had agent observability but only 52% ran offline evaluations. Watching an agent and testing it are different jobs.
The same three-way split stretches further than you'd expect. In a multi-strategy fund, every portfolio manager's pod wants its research walled off from the next pod, but nobody wants a separate AI platform per pod. So the workspace stays central and the pod becomes part of permission: which pod you're working in is worked out on the server, never taken from the browser or from whatever the model put in a tool call. It also changes how you think about reusable skills. Generating a PowerPoint deck or a Word document shouldn't be rebuilt inside every agent. It's a shared capability with its own permissions, and an agent doesn't automatically get it just because the person asking is allowed to use it. Something has to hand the right capabilities to the right agent for this person and this request.
There's an obvious way this goes wrong, and it's the reason the inbox needs as much design as the agents. If every agent can drop things into your inbox, you've rebuilt email, with more senders. A dozen agents each sending a daily summary is a dozen things nobody reads.
So the inbox needs rules from day one. Merge the duplicates. Fold the low-priority updates into a digest you read when you like. Cap how often any one agent can interrupt. And only let something demand attention if it needs a decision. The test for every item is whether a person has to do something about it. If not, it doesn't belong in the inbox at all. The failure mode next to it is agent sprawl: without a catalogue that requires an owner, a purpose, an audience and an evaluation suite for every agent, employees end up choosing between several slightly different research bots, which is just the counter again with worse signage.
Put it all together and I think enterprise workspaces go through three generations. The first is chat-centric: employees ask agents questions, with a dropdown and an Auto mode. That's where most firm-wide platforms are now. The second is work-centric: tasks persist, agents start work on events and schedules, approvals and rich results replace paragraphs. The third is agent-native: you delegate an objective rather than a question, agents coordinate with each other and with systems, and a person gets pulled in only when a decision is genuinely theirs.
Chat doesn't disappear in any of them. It just stops being the place where all the work has to start. That's why the decision that matters for anyone building one of these right now isn't which chat framework to use. It's whether you're building a chatbot that exposes several agents, or a workspace that owns conversations, tasks, notifications and permissions independently of whichever agents happen to exist this quarter. Build the second, even if what you ship first looks like the first.
The counter stays open. It just stops being where most of the work gets picked up.