When AI agents work together, do they build shared shorthand the way human teams do, or stay strangers?
How do LLM-based agents develop shared abstractions through interaction?
This explores whether LLM agents that talk or work together can come to share concepts, conventions, or vocabulary the way human groups settle on shorthand, and the corpus has little direct evidence of that happening on its own.
This explores whether LLM agents that talk or work together can come to share concepts, conventions, or vocabulary the way human groups settle on shorthand. The corpus has almost nothing showing agents inventing shared abstractions on their own. What it does have is a clear picture of what gets in the way, and of where shared structure comes from instead.
The first obstacle is common ground. Humans build shared meaning by jointly revising it: one person proposes a new framing, the other accepts or amends it. LLMs read every later turn inside the frame set by the initial prompt, so they can't symmetrically propose updates to shared assumptions. That leaves the human as the sole keeper of the conversational scoreboard (Can LLMs truly update shared conversational common ground?). If that holds between a person and a model, two models negotiating a new shared term start with the same handicap. Their footing is also shaky in another way: agents lack persistent goal representation and stable role identity, which shows up as role flipping and conversation drifting off course (Why do autonomous LLM agents fail in predictable ways?). It's hard to converge on shared vocabulary when your own role keeps wobbling.
The second obstacle is that interaction can spread a convention without checking it. In the AgentsNet benchmark, agents accept neighbors' information without verifying it. They also fail to coordinate either by settling on a strategy too late or by adopting one without telling anyone (Why do multi-agent systems fail to coordinate at scale?). Multi-agent deliberation has a related trap: Silent Agreement, where agents seem to agree but haven't reached a common understanding (What limits autonomous capability in large language models?). So when agents converge, that isn't evidence they share an abstraction. It may just be an error, or a mirror, that has propagated.
Where the corpus does find shared structure, it is built in rather than grown. Reliable agents move memory, skills, and interaction protocols out of the model and into a harness layer that every agent uses (Where does agent reliability actually come from?). LLM Programs do something similar by wrapping models in explicit algorithms that hand each call only the context relevant to its step (Can algorithms control LLM reasoning better than LLMs alone?). Code is a strong candidate for the common medium, because it can be run, inspected, and carries state, so two agents can check that they mean the same thing by executing it (Can code serve as the operational substrate for agent reasoning?).
The nearest thing to abstractions forming through interaction is agents interacting with an environment rather than with each other. In Think-In Games, language-guided policies are refined by environmental feedback, and the agent gains procedural competence while its reasoning stays readable (Can language modeling close the knowing-doing gap in AI?). One more finding cuts against the premise: a single model prompted to play several personas reproduces much of what multi-agent debate does (Can branching prompts replicate what multi-agent systems do?). That suggests the useful part of multi-agent interaction is structural, not social. The pattern across these notes, which is my reading and not a finding any one of them states, is that agents share abstractions through a common artifact such as a harness, a codebase, or a feedback loop. Conversation alone doesn't get them there.
Sources 9 notes
LLMs interpret all subsequent conversational turns within a fixed initial prompt frame, preventing them from symmetrically proposing updates to shared assumptions. Even when users pivot topics or contradict earlier framings, the model cannot absorb revisions into jointly held background—making the user the sole maintainer of conversational scoreboard.
Research identifies role flipping, flake replies, infinite loops, and conversation deviation as LLM-specific failures in multi-agent cooperation. These occur because LLMs lack persistent goal representation and stable role identity.
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.
Multi-agent deliberation produces specific failure modes (Degeneration-of-Thought, Silent Agreement), alignment at scale includes problematic self-valuation, and self-improvement is formally bounded by the generation-verification gap. Measurement error and conditional compliance hide the true capability ceiling.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
Show all 9 sources
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
Research shows code uniquely enables agent reasoning, action, and verification by being simultaneously executable, inspectable, and stateful. This unified code-centered loop improves reasoning and verification together compared to natural-language or prose-based approaches.
Think-In Games demonstrates that when LLMs generate language-guided policies refined by environmental feedback, they develop procedural competence while retaining explainability. The approach dramatically reduces data demands and makes agent reasoning transparent at every step.
Research shows single LLMs using dynamic persona simulation achieve multi-agent cognitive synergy without multiple model instances. Solo Performance Prompting validates that structured prompting techniques map directly to multi-agent debate architectures, enabling equivalent outcomes through structural equivalence.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Emergent Collusion in Long-Horizon LLM Agent Interaction
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Exploring Autonomous Agents: A Closer Look at Why They Fail When Completing Tasks
- Cultural Evolution of Cooperation among LLM Agents
- LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents
- Bilevel Coordinated Reflection: A Game-Theoretic Approach to Multi-Agent LLM Systems
- Think in Games: Learning to Reason in Games via Reinforcement Learning with Large Language Models
- Code as Agent Harness