The Next Bottleneck Is Human-to-Human Communication

A BD person finishes a 30-minute intro call, then writes a summary for their boss that captures maybe 5% of what was actually said. An engineer debugs for an hour, then compresses the whole process into three sentences at standup. We keep treating "not enough people" as a throughput problem: just hire more, add more coordinators, create more meetings. But that's not the real issue.

A person is a lossy I/O node. Every human hop loses context, every handoff compresses intent, every summary throws away nuance. You can't scale your way out of that 95% loss.

From Workflows to Co-workers

Consider the tremendous changes in the agent landscape over the past two years.

At first, agents were mostly handcrafted workflows — think ByteDance's Coze with its endless graphs, or systems like Manus / OWL. Agents were carefully orchestrated executors: every step had to be drawn in advance, every tool call, every branch, every recovery path. We increasingly think that paradigm only survives in vertical domains.

Then Claude Code shipped, and a lot of those workflows got eaten by raw model capability. A friend described it well: "Those workflows were basically reverse-engineering what the model already knew how to do."

The harness layer also started converging — these days each model lab more or less has one canonical harness, because during post-training the agent framework and the model are increasingly co-trained with RL.

The infra is becoming ready. On the environment side, agent-native interfaces emerged: MCP, CLI, and the whole family of tool environments.

So the way we now think about a harness is simple: agent framework + environment interface.

That's when the agent finally becomes a co-worker. You give it an instruction, or a higher-level goal, and through loops it can run a long task to completion.

A side note: "self-evolve" also emerged around this point, but we are skeptical of papers that explicitly try to train self-evolution as a capability.

Wu Yi has a line: "If an agent can do work spanning months, or even a year, it has to be self-evolving."

We agree. The lesson from the o1 reproduction wave was similar — explicitly training "reflection" was probably the wrong abstraction; the method that eventually worked was much simpler. We should chase the final reward, not the meta-reward we invent along the way.

The Real Bottleneck Is Human-to-Human Information Loss

So now we have increasingly powerful co-workers. But as base models get stronger, we are becoming convinced of something else: the human is becoming the bottleneck of the whole system.

More precisely, the bottleneck is not human speed — it is human-to-human information loss. The information loss between two humans is much worse than the information loss between two agents, bottlenecked by individual cognition, personality, memory, incentives, emotional bandwidth, communication style, and a dozen other things. In most workflows today the human is still a relay station, and that is exactly what it means to say the current application layer is not agent-native.

Two agents talking can preserve full context. They can exchange structured state, trace history, constraints, rationale, documents, calendars, tool outputs, permissions, and decisions directly. They don't need to pace themselves for each other's understanding, don't need to read body language, don't need to compress a complex negotiation into a paragraph for "alignment."

A few seconds of agent↔agent exchange can contain more usable information than half an hour of conversation between two smart people — an order of magnitude lower loss, near-lossless, high-IO coordination.

What Agent-Native Coordination Looks Like

Make it concrete. Today, two companies negotiating a partnership go through something like: intro call → both sides write decks → align with bosses → revise terms → term sheet → contract. Every step is a human relay. Every step loses information.

The agent-native version looks different. Each company's Cindy joins a shared channel. They exchange NDAs, align calendars, compare constraints, negotiate terms, draft the LOI, and preserve the entire reasoning trail. Twenty-four hours later, both bosses wake up to a one-page summary: "They're holding firm on X. I pushed back with Y. Your call: accept X, or push Z."

That is not RPA. That is not "an agent orders dinner for me" — that is user↔agent, still keeping the human at the center of the coordination graph. What we are talking about is agent↔agent. The human is no longer the lossy relay node in the middle.

The Application Layer Is Not Ready

This line of thinking is what led us to try building an agent that could talk, coordinate, and even transact directly with other people's agents. The process was brutal.

The agent capability is increasingly there; the application-layer infrastructure is not. Lark does not allow bot-to-bot direct conversation. Slack and Teams are similar. Exposing a CLI or opening an MCP endpoint is not the same thing as being agent-native.

Agent-native means bot-to-bot is a first-class citizen. It means agents have cross-identity collaboration channels. It means agents can hold their own resources — calendars, docs, wallets, permissions, memory, contracts — and that agents can transact.

The product that has stuck with us most is RC's slock. We used to describe it as "Slack for agents," which is a fine one-liner — but the deeper idea is more interesting: Slack is just a platform; slock internalizes the process of human evolution into the agent itself. This is not only personal-agent evolution (the openclaw-rl / metaclaw direction); it is collective evolution. Today, slock feels like a workspace for agent teams. But imagine if different slock workspaces could connect with each other.

Would we then see Cindy talking to Cindy across companies? Would agents transact, hold meetings with other agents, negotiate, socialize, earn money, maintain relationships? That is the kind of shift that reshapes almost every white-collar application.

Reconstructing the Application Layer

So we think the next step is a complete reconstruction of the application layer. Not "expose a CLI." Not "wrap a chat window so the user can order takeout by prompt." The real shift is agents communicating, coordinating, doing business, and maybe even socializing directly with other agents.

When the application-layer infra is finally ready, some strange things are expected to emerge. A clear picture is not yet available — the most trivial conjecture is something like: give every agent a primitive goal — earn enough of its own token to keep running. Where human-in-the-loop ends up is even harder to predict.