Can AI agents build their own shared vocabulary by reviewing what went wrong after each task and agreeing on rules?
How do postmortem convention-setting stages enable language evolution in agents?
This explores whether agents can build up shared terms and rules by reviewing what went wrong after a task (a postmortem), and how that review could make an agent's working language evolve over time.
This explores whether agents can build up shared terms and rules by reviewing what went wrong after a task, and how that could make their working language evolve. The corpus has no note on a postmortem stage that sets conventions, and none on agents inventing a shared vocabulary. It does hold the separate pieces such a mechanism would need, and they fit together in a suggestive way.
The postmortem half is well covered. In Reflexion, an agent that fails a task writes a plain-language diagnosis of what went wrong and stores it in episodic memory, then does better next time with no weight updates (Can agents learn from failure without updating their weights?). Two details matter for your question. The success/failure signal has to be unambiguous, because that stops the agent from rationalizing. And the reflections stay uncompressed, because compressing them makes them less usable. Here the lesson itself is a piece of language, and it is the thing that persists between episodes.
A convention is a lesson that outlives one episode and gets reused. Two notes describe how that could happen. DeepAgent's memory folding compresses raw interaction history into structured episodic, working, and tool memories, and it stays usable because the agent decides when and how to fold (Can agents compress their own memory without losing critical details?). That partly conflicts with Reflexion's advice not to compress. The likely resolution is that compression with a fixed structure is what turns a one-off diagnosis into a reusable rule or term. The reliability note makes the same point from a different angle: dependable agents move memory, skills, and protocols out of the model and into a harness, so the model doesn't have to solve the same problem twice (Where does agent reliability actually come from?). A protocol is a convention that has been written down outside the model. The character-sampling note explains why this is necessary. A model doesn't commit to a single stable character, and regenerating a response gives a different but still consistent answer (Do large language models actually commit to a single character?). So a convention can't live inside the model as a commitment. It has to be stored in text and memory, where it can be reused.
The "evolution" half is my inference, because no note describes a postmortem driving language change. Two notes come close to the machinery. Mind Evolution treats natural-language candidates as a population, using LLM-generated crossover and mutation with separate islands to keep variety, and it beats simple sampling and sequential revision (Can evolutionary search beat sampling and revision at inference time?). Another note models agents as graphs whose prompts and connections can both be optimized, and it shows that Reflexion and similar techniques are special cases of that structure (Can we automatically optimize both prompts and agent coordination?). Put together, a postmortem stage acts as the selection step. It decides which phrasings, rules, or protocols survive to the next round. If you're after a specific paper on emergent agent language, it isn't in this set of results.
Sources 6 notes
Reflexion demonstrates that unambiguous environmental feedback (success/failure) enables agents to write useful self-diagnoses and improve across episodes without parameter updates. The binary signal prevents rationalization, and keeping reflections uncompressed preserves their usability.
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.
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.
Shanahan's 20-questions test shows LLMs maintain a superposition of consistent objects or characters and sample from that distribution at generation time. Regenerating the same response yields different outputs, each consistent with prior context, proving no fixed commitment exists.
Mind Evolution, an evolutionary search strategy using LLM-generated crossover and mutation with island model diversity, solves 98%+ of planning tasks and significantly outperforms best-of-N and sequential revision strategies while working directly in natural language without task formalization.
Show all 6 sources
Language agents represented as computational graphs—where nodes are operations and edges define information flow—reveal that CoT, ToT, and Reflexion are formally equivalent structures. This unified view enables automatic optimization of both node prompts and edge connectivity without manual redesign.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Evolving Deeper LLM Thinking
- Language Agents as Optimizable Graphs
- DeepAgent: A General Reasoning Agent with Scalable Toolsets
- CLIN: A Continually Learning Language Agent for Rapid Task Adaptation and Generalization
- Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering
- AgentGrad: Intervention-guided Prompt Optimization for Multi Agent Systems
- AgentFly: Fine-tuning LLM Agents without Fine-tuning LLMs