Can agents develop shared abstractions through communication pressure alone?
This explores whether the simple need to coordinate — without any external reward shaping the language itself — is enough to push agents toward shared, compact concepts, and where that pressure helps versus where it breaks down.
This question is really asking whether coordination alone — the friction of having to be understood — can manufacture a shared vocabulary between agents, rather than that vocabulary being hand-designed or directly rewarded. The corpus says yes, with a clear caveat: it depends heavily on *how* the agents are wired to talk. The most direct evidence is that cooperative task pressure does drive agents to invent shorter utterances and reach for higher-level abstractions on their own, building up a reusable library of concepts as they go Can communication pressure drive agents to learn shared abstractions?. Efficiency isn't engineered in; it falls out of the need to coordinate.
But "communication" turns out to be a loaded word here, and the corpus pulls in two directions on what channel the pressure should flow through. One camp argues that natural language is actually a *bottleneck* — that agents coordinate better when they exchange structured artifacts (engineering documents, standardized schemas) and pull information from a shared environment rather than chatting back and forth Does structured artifact sharing outperform conversational coordination?. Another camp goes further and skips language entirely, sharing internal representations directly: latent thoughts recovered from hidden states with identifiability guarantees Can agents share thoughts directly without using language?, or KV-cache exchange that passes reasoning between agents losslessly and without any extra training Can agents share thoughts without converting them to text?. So the shared abstraction can live in compressed text, in structured documents, or in raw latent space — communication pressure shapes all three, but the substrate changes what kind of abstraction emerges.
The more interesting wrinkle is where this *fails*. Shared abstractions assume agents actually converge on the same understanding — and at scale, they don't. Coordination degrades predictably as the network grows: agents either agree too late or adopt strategies without telling their neighbors, and crucially they accept incoming information without verifying it, which lets errors propagate through the group Why do multi-agent systems fail to coordinate at scale?. That's a sharp counterpoint to the optimistic story. Communication pressure can build a shared language, but the same pressure to agree quickly can produce premature, uncritical consensus — a shared abstraction that's shared precisely because nobody checked it.
There's also a quieter thread worth pulling: the abstractions agents converge on don't have to stay between two agents in a single task. They can be *accumulated*. Reusable sub-task routines get induced from experience and compounded hierarchically, with bigger payoffs as tasks drift further from training Can agents learn reusable sub-task routines from past experience?; interaction histories get folded into structured memory schemas Can agents compress their own memory without losing critical details?; and skills learned by one user's agent get centrally aggregated and synchronized back across the whole ecosystem How can agent systems share learned skills across users?. That last one is the quiet rebuttal to the premise: the richest shared abstractions in the corpus aren't grown from communication pressure *alone* — they lean on a central aggregator to curate and broadcast them.
So the honest answer is: communication pressure genuinely is sufficient to *originate* compact shared abstractions in small cooperative settings, but the corpus suggests the durable, scalable versions need something more — a verification step to stop bad consensus, or a central mechanism to consolidate and redistribute what's learned. The thing you might not have expected to find: across these papers, the most reliable shared abstraction often isn't language at all, but a structured artifact or a latent representation that sidesteps language's ambiguity entirely.
Sources 8 notes
ACE agents under cooperative task pressure develop shorter utterances and higher-level abstractions through neurosymbolic library learning combined with bandit-based exploration-exploitation. This demonstrates that communication efficiency emerges naturally from the need to coordinate about shared tasks.
MetaGPT demonstrates that agents producing standardized engineering documents achieve superior coordination compared to conversational exchange. Active information pulling from shared environments eliminates noise and mirrors efficient human workplace infrastructure.
Research formalizes inter-agent thought sharing via sparse autoencoders that recover individual, shared, and private latent thoughts from hidden states. This approach detects alignment conflicts at the representational level before they manifest in language.
LatentMAS enables agents to share internal representations directly via KV caches, reaching 14.6% accuracy gains and 70.8-83.7% token reduction with no additional training. Hidden embeddings preserve reasoning fidelity that text-based systems cannot.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Agent Workflow Memory induces sub-task routines at finer granularity than full tasks, abstracts example-specific values, and compounds them hierarchically. This produces 24.6% relative gain on Mind2Web and 51.1% on WebArena, with larger gains as train-test gaps widen.
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.
SkillClaw aggregates interaction trajectories across users, processes them through an autonomous evolver that identifies patterns and refines skills, then synchronizes updates system-wide. This converts siloed individual learning into shared capability improvement without manual curation.