The Coordination Layer
Every tool you need already exists. Nobody is wiring them together.
This is Part 3 of a series on the coordination bottleneck. Part 1 explored how AI made us more productive, but our days feel worse. Part 2 diagnosed why: and in this part I’ll go through my solution.
Imagine an agent that opens up summaries before your meetings, not summaries you asked for, but context it knows you’ll need because it’s been watching how you and your team operate. It preloads the relevant threads, flags decisions made three weeks ago that were never followed up on, and surfaces one Slack message from your designer that everyone missed. You walk into the meeting, and the conversation is focused because everyone already has the context. The riffing can start immediately, rather than spending the first 15 minutes getting everyone on the same page.
This doesn’t require some new technological leap; we just need to stitch together tools that already exist. Transcription, summarization, search, storage, cataloging, and orchestration all solved problems individually. We simply lack the imagination. Side bar, I am surprised when some people look at the power of AI tools and think the highest impact thing they can do is more SEO. We keep pointing AI at individual productivity when the real unlock is collective coordination.
What if we had a new layer of communication that handled all the boring and tedious stuff in the background, so we could focus on going deeper into what we’re actually good at and enjoy?
Consider the Mushroom
Mushrooms have mycelium, dense underground networks of fungal threads connecting trees across entire ecosystems. When researchers started mapping them, they found that the architecture is scale-free: a few massively connected hub nodes and many peripheral ones. In one mapped old-growth Douglas-fir plot, the most connected tree was linked to 47 others via 11 distinct fungal species. The biggest trees can often attribute their size to being hubs of a resource and information network the whole forest depends on. Lesson there.
The mycelial network runs three channels simultaneously. Slow channel: nutrient and carbon transfer over days to weeks, plants export photosynthate, fungi return phosphorus and nitrogen. Fast channel: chemical warning signals over hours; when one plant is attacked by insects, connected neighbors upregulate defense genes within 6 hours before anything touches them. Fastest channel: electrical signals propagating along hyphal membranes in seconds, though the research on this one is contested enough that I won’t oversell it. Persistent state, alerts, and real-time coordination. The same network, differentiated by urgency.
Fungi are strategic actors, moving resources from rich patches to poor ones to achieve higher returns, and building networks that optimize trade. Cooperation emerges not from altruism but because the infrastructure makes cooperation the rational move. This makes for a useful model for how to do the implementation.
What the Layer Needs to Do
The coordination failures I see over and over come down to three things: institutional memory, information routing, and medium selection. An agent layer worth building has to handle all three.
Institutional memory is the expensive one. Every time someone leaves, every reorg, every “we discussed this six months ago, but nobody remembers” An agent that maintains and surfaces this context, that knows your team discussed this exact problem in November and what you decided, that remembers the trade-offs you already weighed. That agent is worth more than any code generator. Imagine walking into a meeting and having the relevant threads pre-loaded, decisions from three weeks ago that were never followed up on flagged, and that one Slack message from your designer that everyone missed already surfaced. Not because you asked for it, but because the agent has been watching how your team operates and knows you’ll need it. The riffing starts immediately, rather than spending the first 15 minutes rebuilding context.
Information routing is the silent time sink. We waste enormous amounts of time either over-including people in meetings or under-including them. An agent that maps decision-makers from org context, communication patterns, and project history could route the right information to the right people without anyone scheduling a single meeting.
Medium selection sounds trivial, but it isn’t. The medium is the message; whether something should be a Slack message, an email, a 5-minute call, or a doc is a decision that people get wrong constantly. Meetings that should have been a Slack thread. Slack threads that should have been a 5-minute call. Another straightforward agent use case with compounding time savings.
Every meeting, every decision, every piece of context that currently lives in someone’s head or a Slack thread that nobody can find. Not generating more stuff. Connecting the stuff that already exists.
What the Infrastructure Needs to Look Like
So what does the infrastructure need to look like for this to actually happen? I have some thoughts.
CLIs and MCPs. If I can’t script it, I can’t integrate it, and if I can’t integrate it, it’s another silo. MCPs allow tools to be embedded in existing apps where you already do work and can handle the auth. This is the connective tissue. You shouldn’t have to leave the tool you work in to coordinate. The coordination layer should come to you.
Full front-end and back-end API parity. If you can do it in the UI, you can do it via API. No exceptions. Seat-based pricing is an anti-pattern for agent-driven workflows. If I have 10 agents coordinating across 5 tools, I’m not buying 10 seats for each one. Pricing models need to catch up with how work is actually being done now. Data silos and walled gardens are rent-seeking and will be less competitive going forward. Too long have we been held hostage by these pit bull systems that bite onto you and never let go. The coordination layer can’t work if every tool hoards its data behind proprietary walls.
The Google Workspace CLI was a good step forward in this direction, but trying to do anything in slides or docs is a horrendous experience at this point. 5 API calls just to write a paragraph.
Use an existing orchestrator for state management (shocker, the orchestration man suggests an orchestrator). The DAG-centric, composable, metadata-driven nature of modern orchestrators makes them a natural coordination infrastructure. You’re already defining dependencies, managing state, tracking lineage, and triggering workflows. If you have one running your data pipelines, you’re sitting on coordination infrastructure you’re not using. The pattern that matters is declarative: define what should exist gather context, notify stakeholders, document decisions and let the system figure out how to get there. That’s how orchestrators already work for data. The same architecture applies to coordination.
Context storage built for multimodal data. Structured data is going to be a smaller and smaller share of the pie. Meeting transcripts, design files, whiteboard photos, call recordings, that’s where the coordination context actually lives. Storage is a solved problem, but cataloging it so both humans and agents can find what they need is where data catalogs become an important piece of the stack.
The challenge isn’t any one of these pieces. It’s wiring them together into a coherent layer that runs in the background of how teams actually work. And the security question is critical, most security leaders would blow a gasket if someone suggested ingesting that much context and having models sift through it. The opt-in problem alone is significant: this kind of network effect doesn’t work unless most people are in the network.
How the Agents Talk to Each Other
Once you have agents handling coordination for individuals, the next question is obvious: how do those agents talk to each other?
Centralized approaches won’t work. A single orchestrating agent that manages all coordination across a team becomes a bottleneck itself. You’ve just recreated the overloaded project manager problem in software. It might work for small teams, maybe up to 6 people, but that’s the ceiling. The consensus is worse. Anyone who’s tried to get more than 6 people to agree on anything in a Slack thread knows consensus doesn’t scale. Agent consensus would be even slower, more costly in terms of tokens, and prone to the same groupthink dynamics that make human consensus meetings painful.
The interesting path is emergent coordination. You start with hierarchical because it’s simple and debuggable. You run it for a while. Then you let the system observe its own patterns where bottlenecks form, which agents frequently need to sync, and where decisions stall. Over time, the topology evolves. Some connections become direct. Some coordination becomes ambient in a shared context that doesn’t require explicit communication. Some decisions get delegated down.
This mirrors how high-performing human teams actually work. You start with structure. You build trust and shared context over time. And eventually, the team operates with less explicit coordination because everyone has internalized the patterns. The best teams I’ve been on barely needed meetings by the end because they’d built enough shared understanding that a quick message could do the work of an hour-long sync. I think agent systems will follow the same trajectory if we let them.
The Right Question
One day, we’ll look back on this period of everyone being their own PM, doing admin overhead work instead of going deeper or wider in the skill area that they have been building on their entire lives and laugh at how wrong our approach was. We pointed a technology that is fundamentally about language and communication and focused on making individuals faster, when the real opportunity is making teams and organizations exponentially more effective.
All the tools are right there. We just need to wire them together for coordination instead of code generation. Maybe this is my turn to get a little too optimistic about what AI can do. But after spending the last couple of years watching it make my days worse while improving my output, I think I’ve earned the right to be excited about something that might actually fix the problem.
What I want is simple. The breathing room to go deep on something. To riff with a coworker on a half-formed idea. To waste an hour on something that might turn into the best idea I’ve ever had. Like my old boss said if you can’t waste hours, you’ll waste years. AI can give us those hours back. It just hasn’t yet, because we’ve been asking it the wrong question.
We’ve been asking, “How do I do more?” We should be asking, “How do we work better together?”
If any of this resonated, I’d love to hear from you — especially if you’re building in this space or have seen teams solve the coordination problem in interesting ways.