A few months ago, we received a fairly typical customer request.
The source material wasn't ideal. It consisted of handwritten notes, scanned documents, and a handful of supporting files. Before anyone could begin working on the actual request, someone first had to make sense of everything.
Today, the first part of that workflow is handled by AI. An OCR agent reads the handwritten content and converts it into structured text. A research agent uses that information to gather supporting material. Depending on the request, another agent prepares a presentation or produces the first draft of the final deliverable. By the time a human picks it up, the groundwork has already been done.
Watching that workflow for the first time felt like a glimpse into the future. Multiple AI agents, each responsible for a specific task, working together to help complete a real customer request. On paper, it looked like exactly the kind of system that should dramatically improve productivity. It didn't.
The OCR agent was fast. The research agent found the right information. The presentation draft was surprisingly good. Yet the overall turnaround time for the request barely changed. The reason had nothing to do with the AI.
Someone still needed to verify unclear handwriting. Someone had to decide whether the research actually answered the client's question. The presentation still went through reviews, revisions, approvals, and conversations with the customer. Work still paused while people waited for context that wasn't captured anywhere. Information still lived across multiple systems. Ownership still shifted between teams.
The agent was excellent at its task. The task was never the bottleneck.
We've spent the last few years building AI systems for enterprise workflows, and that invoice project changed how I think about all of it. The organizations getting the biggest productivity gains from AI aren't necessarily the ones running the smartest agents. They're the ones building better workspaces—the environment the agent works inside.
That sounds backwards. Intelligence is the thing we've all been chasing. Every new model gets benchmarked on reasoning, coding, and tool use. We compare context windows and token costs and celebrate when an agent clears one more task without a human. But when you watch how work actually moves through an organization, intelligence is rarely what's slowing it down.
Coordination is.
The gold rush is repeating an old mistake
The excitement around agents reminds me of the early cloud era. Back then, moving to the cloud was pitched as the answer to every scaling problem. Plenty of teams lifted their existing systems up, expected a transformation, and discovered the architecture hadn't changed — they'd just moved the same mess somewhere more expensive. Cloud wasn't the solution. It was an enabler.
Agents are in the same phase now. The reflex is to bolt one onto whatever process is annoying and assume it gets faster.
Need document processing? Add an agent. Customer support? Add an agent. Project management? Add an agent.
Sometimes it works. More often it produces a fraction of the gain people expected—and not because the model is weak. The model is fine. The process around the model never changed. We've gotten very good at asking "what task can an agent perform?" and we spend almost no time on the harder question: "where does this agent actually fit in the work?"
The work you can see is the smallest part
When we picture work, we picture execution. A designer builds slides. A translator translates. An analyst writes a report. An engineer ships code. Those are the visible outputs, so those are what we try to automate first.
But execution is the tip of the iceberg. Before anyone can translate a document, someone has to receive the request, identify the language pair, estimate effort, assign the right linguist, pull reference material, chase the missing context, and slot it against everything else in the queue. After the translation is done, it still needs review, QA, delivery, feedback, and often another round. The translation itself might take thirty minutes. Everything wrapped around it can take hours.
The same shape shows up almost everywhere, and OCR is the cleanest example. Most people think OCR is about pulling text off an image. Technically, yes. Operationally, no. A business doesn't care whether text was extracted—it cares whether the invoice reaches finance, whether the mandatory fields validate, whether the missing ones get flagged, and whether the exceptions land with the right person. Extraction is one step. The workflow is the product.
This is easy to miss because coordination is invisible. We don't celebrate the meeting that quietly prevented an outage. We don't measure the hours lost hunting for the right file or the tax of switching between five systems to close one request. But that's where the time actually goes.
Knowledge and context are not the same thing
Modern agents are genuinely capable. They summarize, search, draft, generate, and call APIs. Hand one an isolated task and it'll often beat your expectations. Drop it into a live business process, and the picture changes—not because it got dumber, but because intelligence alone was never the thing that was missing.
Think about onboarding a new hire. You don't hand them a laptop and wait for results. You explain the team's priorities. You introduce them to the people they'll depend on. You show them where things live, which approvals matter, and who to ask when something breaks. You give them context. Without it, even a brilliant new hire stalls.
Agents hit the exact same wall:
- It knows how to summarize a document. It doesn't know whether that summary goes to the client or stays internal.
- It writes a clean translation. It doesn't know this client insists on their old approved glossary over the newer phrasing.
- It reads a scanned invoice perfectly. It doesn't know the extracted total just violated a business rule that's been in place for six years.
Large language models have become exceptional at knowledge. Organizations still run on context. Those are different problems, and only one of them gets solved by a better model.
So what actually is a workspace?
I've been throwing the word around, so let me pin it down, because "workspace" gets used so loosely it starts to sound like a buzzword.
A workspace isn't a nicer UI, and it isn't just giving an agent a pile of tools. It's the operational context that makes any participant — human or AI — effective. Concretely, a workspace holds the following:
- Shared state — a single source of truth for what a request is, where it is, and who owns it, so nobody has to reconstruct it from scattered systems.
- Persistent memory — what happened last time with this client, this vendor, and this document type so the same lesson doesn't get relearned every time.
- Defined roles — a clear boundary of what each participant is responsible for and trusted to do.
- Routing and handoffs — the rules for where work goes next and when it moves, instead of waiting on someone to remember to pass it along.
- Business rules — the constraints and validations that encode how this organization actually operates.
- Human-in-the-loop checkpoints — the points where a person has to approve, review, or decide, made explicit rather than improvised.
- Visibility — a live view of status, so exceptions and stalls surface before someone goes looking.
Give an agent that, and it stops behaving like a chatbot waiting for prompts. It knows where a request came from, who owns it, what already exists, what happened before, which rules apply, and when to pull in a human. It's no longer completing tasks in a vacuum—it's participating in the work.
And that's where productivity actually shifts. Not because the model got smarter. Because the workspace made the intelligence useful.
What this looks like in practice
Picture two organizations running the identical language model.
The first uploads a document into a chatbot and asks for a translation. The output is technically impressive.
The second routes the request through a workspace. The agent identifies the client, pulls their previous translations, checks their approved terminology, estimates effort, recommends the right linguist for the pair, flags the ambiguous sections, prepares a first draft, and keeps everyone updated as it moves. A human still does the translation—but they start with context instead of a blank page. The agent didn't replace the translator. It removed the coordination that used to pile up around the translator.
Same model. Completely different kind of productivity.
Invoices work the same way. A traditional OCR system stops once it's read the document. A workspace keeps going: it notices the missing field before a human does, routes the exception to the right approver, tracks what's pending, and nudges when something's been sitting too long. The gain was never "read the document faster." It was collapsing everything that happens after the document is read.
Now put this against the hypothetical everyone in AI is quietly betting on—that a model twice as smart as today's best is coming. Say it ships tomorrow. Do meetings disappear? Do approvals become automatic? Does unclear ownership resolve itself? Does scattered information organize on its own? Of course not. None of those are intelligence problems. They're organizational problems, and organizations don't get more productive because one participant got smarter. They get more productive when everyone coordinates better. Humans figured this out a long time ago—it's why we build teams, processes, and standards instead of just hiring smarter individuals. AI should slot into those systems, not try to replace them.
The bet we're making
This is the thesis behind what we're building, and I'll be direct about it since it's the reason I'm writing this at all.
With FLIP, our service operations platform, the most valuable part was never the interface — it was the conversations that stopped needing to happen. Nobody asks who owns a request, because ownership already exists in the workspace. Nobody digs through four systems, because the information is already connected. Nobody manually updates status after every small move, because the workspace already knows. Introduce an agent into that, and its role gets obvious: it's not replacing the ops team; it's helping them keep momentum—gathering information before someone asks, prepping updates before the meeting, and surfacing the requests likely to slip a deadline. The agent didn't get smarter. The workspace got more aware, and awareness scales better than raw intelligence.
Our Translation product runs on the same principle—the linguist's job is real work that a model shouldn't touch, but everything crowded around it is coordination a workspace can absorb.
Both are expressions of one bet, and it's the same bet behind the Workspace Management system we're building now: the workspace is the product. The agent is a teammate inside it, and like any teammate, it doesn't need to do everything. It needs to reliably own its piece while collaborating with everyone else. Nobody joins a team on day one making strategic calls; they start with repetitive work and earn trust over time. Treat an agent as a drop-in human replacement, and you'll set expectations it can't meet. Treat it as a new teammate that needs a role and context, and you build something that actually works.
Where this leaves us
Technology keeps changing how we work. The internet changed how we communicate, the cloud changed where software runs, and mobile changed where work happens. AI is changing who participates in the work.
But participation alone isn't the win. An incredibly capable teammate with no context, no visibility, and no understanding of how the organization actually operates will struggle to matter—a human wouldn't survive those conditions either. We've spent a few years asking how to build smarter agents. The more useful question now is how to build better environments for them to work in.
So if you're deploying agents and the gains aren't showing up, resist the urge to reach for a bigger model. Look at the process around the agent instead. That's almost always where the time is hiding — and it's the part a smarter model was never going to fix.
That's the problem we're building toward. If it's the one you're wrestling with too, I'd like to hear how you're thinking about it.
