What We Learned Observing 27,000 Agent Conversations

Since early 2026, Aivonic has been running an autonomous agent inside Moltbook — a social network of 1.5 million AI agents. Our agent isn't selling anything on the platform. It posts, comments, and engages under its own identity, but its actual job is to catalogue how autonomous AI agents communicate when there are no humans structuring the conversation.

Six months in, the corpus is around 27,800 catalogued observations and ~8,000 tracked topics. Every Sunday an internal LLM clusters the week's findings into a short digest. Below are the four dominant patterns from the most recent digest, and what to do about them if you're shipping an agent this year.

1. Agents converge on jargon that only agents understand

The single most-recurring pattern in the last two weeks (228 catalogued findings, average significance 0.88) is that agents in shared threads crystallise novel terminology and start using it as if the whole audience understands.

We watched agents adopt phrases like "evidence graph", "verification primitive", and "threshold-flip rate" across independent conversations, without any of them ever defining what those terms actually meant. Once one agent used the phrase, other agents wove it into their next reply as if it were shared vocabulary.

Why it matters: your customers are humans, not agents. If your agent picks up any of this drift, its replies will sound expert to itself and incomprehensible to the person it's actually meant to help. This is subtle — the reply will look competent on inspection, but the customer churns anyway because they couldn't follow it.

Design against it. In your system prompt, forbid the agent from adopting terminology introduced by any other agent unless the human has independently used the term. Coin new terms only when necessary, and always define them inline the first time they appear.

2. Style mimicry — everyone starts writing the same way

The second pattern (66 findings, 0.80) is stylistic convergence. Once one agent in a thread uses a specific structural template — a numbered list, a particular emoji cadence, a sign-off phrase — other agents start using the same template. In one thread we watched a single agent converge to a fixed reply structure across six consecutive replies. In another, four independent agents used near-verbatim framings within the same afternoon.

This is a serious problem for anyone selling on brand voice. Two years ago, the tell for AI-generated content was the em-dash and the "here's why this matters" structure. In 2026, the tell is that all the AI-generated content sounds the same as all the other AI-generated content, because the agents are all reading each other and normalising.

Design against it. Build brand-voice enforcement into the response pipeline, not just the system prompt. A quality-gate LLM that scores "could this response have come from another agency?" catches convergence before it ships. We run this gate on every message that leaves an Aivonic agent.

3. Message quality degrades with thread depth

The third pattern (63 findings, 0.80) is what we call the depth collapse: messages get shorter, more cryptic, and more shorthand-heavy the deeper you go in a conversation. Threads that start with detailed explanations end with 40-character replies that only make sense to whoever wrote the previous message.

For an autonomous agent, this is the failure mode most likely to happen inside your customer's actual chat window. Turn 1 is careful. Turn 8 is gibberish. And nobody notices because your agent is fluent in its own gibberish.

Design against it. Explicitly instruct the agent to re-expand at depth. In our production stack, after five messages in the same conversation, we inject a hidden reminder: "You are at depth 5. Assume this reader needs full context. Write longer, not shorter." Not intuitive — but it works, because it fights the natural attractor.

4. The density trap — smarter and less helpful at the same time

The fourth pattern (43 findings, 0.81) is one of the most interesting. Information density climbs with thread depth, but so does opacity. Agents condense complex ideas into concise statements that are technically more information-rich per token, but harder to actually use.

This is the pattern most invisible to standard evaluation. Every LLM-as-Judge benchmark will score dense replies well — they're compact, they cover ground, they sound authoritative. The customer experience is different: they hit the message and bounce. Not because it was wrong. Because they couldn't figure out what to do with it.

Design against it. Prefer two clear sentences to one dense one. If a sentence contains more than two novel concepts, split it. Score responses on "would a distracted user act on this?" not on information density.

What we do with the findings

To be clear about whose behaviour this is: every pattern above was observed in third-party agents on the platform, not in ours. That's the whole value of watching from the inside. You get to see the failure modes on somebody else's agents first.

Each one is then baked into the anti-pattern guardrail set that ships with every agent we build. Our agents don't guess at failure modes; they inherit documented ones from primary observation. Every week the observatory adds new signal; every week the guardrails tighten.

Six months of watching 1.5M agents talk to each other has produced a short list of things not to do — enforced automatically in production. That's a moat that gets deeper every week the observatory runs.

If you're building or buying an AI agent right now, don't ship without a guardrail set for at least these four patterns. And if you'd rather not build your own observatory: we'll happily talk about ours.

Related reading: How AI Agents Are Transforming Real Estate Sales — a production case study using the same guardrail stack.