Software still makes humans do routing work
You are the middleware between your tools. That was never supposed to be your job.
Watch someone work for ten minutes. Not what they produce — what they do between producing. The copy-paste. The tab switch. The moment where they stop mid-thought to open a new window and re-explain something they already explained somewhere else. The manual summary they write so that the next tool in their chain has enough context to be useful.
This is routing work. It is constant, invisible, and almost entirely unacknowledged by the software industry.
We have better models than ever. Better editors, better agents, better code generation, better search. The capability layer has improved by orders of magnitude. And yet the person sitting in front of all of it still spends a remarkable percentage of their day doing something that looks a lot like being a human message bus.
What routing work actually looks like
It is not dramatic. It does not feel like a bottleneck because it has always been there. But once you see it, you cannot unsee it.
You finish a conversation with an AI assistant. You learned something, made a decision, generated an artifact. Now you need to act on it elsewhere. So you copy a link. Open a new tab. Paste it in. Realize the new context has no idea what you just decided or why. So you summarize. You re-explain the constraints. You provide background that existed, perfectly formed, in the previous context — but that context is gone now. It ended when you closed the tab.
Or you are tracking a project across three tools. The task lives in one place. The conversation about the task lives in another. The artifact the task produced lives in a third. You are the only entity that knows these three things are related. So you maintain that relationship manually — in your head, or in a document you update by hand, or in the disciplined structure of your browser tabs.
You are the integration layer. You carry state between systems. You decide what context is relevant. You translate between formats. You track what happened and what still needs to happen. You are, in the most literal sense, performing the function of middleware.
Why software is shaped this way
Every application is built as a capability island. It does its thing well — editing, generating, searching, communicating — and exposes that capability through an interface. The interface assumes a human operator who will provide input, interpret output, and decide what happens next.
This made sense when software was a tool you picked up, used, and put down. A word processor does not need to know about your email client. A spreadsheet does not need to understand your project management system. Each tool is self-contained. The human provides the connective tissue.
But the nature of work has changed. Knowledge work now involves dozens of systems, often within a single task. The connective tissue has become the dominant workload. And the architecture has not adapted.
We have tried to solve this with integrations — Zapier, webhooks, APIs, plugins. These help. But they connect actions between systems. They do not connect intent. They can move a file from point A to point B when triggered. They cannot understand that you are trying to accomplish something that spans five systems and three days, and that the context from Tuesday's conversation is critical to Friday's decision.
The gap is not between systems. The gap is between what you are trying to do and the routing required to do it across the systems you have.
The missing layer
If you draw the stack honestly, there are three layers to any work that involves software.
At the top: thinking. Planning, reflecting, deciding. The cognitive work that determines what should happen. Most AI chat products live here. They help you think. That is valuable.
At the bottom: execution. The models, the agents, the APIs, the tools that actually do things. The infrastructure layer. A huge amount of investment lives here. Also valuable.
In the middle: coordination. The layer that connects what you decided to what should execute it. The layer that carries context forward. The layer that tracks what happened, what is pending, what stalled, what needs a human decision before it can proceed. The layer that knows which runtime is appropriate for which action, and what information that runtime needs to do its job.
Almost nobody is building the middle layer. It is not glamorous. It does not demo well. You cannot show a coordination layer in a tweet. But it is the layer that, today, is implemented entirely by the human sitting at the keyboard.
What coordination as infrastructure looks like
Imagine that when you make a decision, the system does not just record the output — it captures the decision itself, with its constraints, its context, its dependencies. When that decision needs to become an action, the system knows what kind of action it is. Does it need AI generation? Human review? Should it be dispatched to an external tool? Should it wait until a dependency resolves?
The system does not ask you to figure this out. It routes. It carries the relevant context to the right destination. It tracks the lifecycle — pending, dispatched, executing, completed, stalled, deferred. When something stalls, it surfaces that fact instead of letting it disappear into the gaps between your tabs.
This is not automation. Automation replaces human action with machine action. This is something different. This is replacing human routing with machine routing, while keeping human judgment exactly where it belongs — at the decision points, not at the junctions between systems.
The human still decides what matters. The human still sets constraints. The human still intervenes when something is ambiguous or high-stakes. But the human stops being the one who carries a paragraph of context from one window to another. That is infrastructure work. It should be infrastructure.
Why this is harder than generation
Generation is a function call. Input goes in, output comes out. You can benchmark it. You can compare models. You can optimize latency and cost and quality along clear dimensions.
Coordination is stateful, contextual, and ongoing. It requires understanding what happened before, what is happening now, and what should happen next — across time, across systems, across the boundary between human intent and machine capability. It requires judgment about when to act and when to wait. It requires carrying forward not just data but meaning — why something was decided, not just what was decided.
This is why the industry has largely avoided it. It is easier to build a better model than to build a better middle. The middle is messy. It touches everything. It requires opinions about workflow that the capability layer can remain agnostic about.
But the middle is where the time goes. Not in generation. Not in thinking. In the space between them — the routing, the carrying, the translating, the tracking. That is where knowledge workers live, eight hours a day, maintaining connections that their software refuses to maintain for them.
The quiet implication
If routing becomes infrastructure — real infrastructure, not another integration platform — then the shape of work changes in a way that is hard to overstate and easy to underestimate.
It means your context persists. Not as a chat log, but as an operational state that moves with you. It means decisions have consequences that propagate without you manually propagating them. It means the gap between "I decided this" and "this is happening" shrinks from hours of tab-switching to seconds of structured dispatch.
It does not look revolutionary. That is the point. The most important infrastructure never does. It just removes friction you had stopped noticing because it had always been there.
You were never supposed to be the middleware. The fact that you still are is not a failure of your workflow. It is a gap in the architecture of software itself. And gaps in architecture, once identified, tend to get filled.