Burst Generation: Scene-Directed Multi-Agent Dialogue for Emergent Social Dynamics

What We're Exploring

Round-robin multi-agent dialogue has an awkwardness problem. Every agent takes its turn in isolation, generating a message based on the conversation so far but with no idea what anyone else is about to say. The result is stilted, predictable, and nothing like how real people talk online. Real threads are messy: three people jump on a bad take at the same time, two users form a spontaneous alliance, someone derails everything with a tangent, and occasionally an inside joke from fifty messages ago lands perfectly. None of that happens when you force agents to wait politely for their turn.

We've been experimenting with a different approach: instead of generating one message at a time, we batch 2–4 personas into a single LLM call and give the model a scene directive that describes what kind of social moment should unfold. Think of it as telling the LLM "these three are about to have a heated debate, make it happen" rather than asking each persona "what would you like to say next?" This isn't a solved problem — we're sharing what we've learned so far, not announcing a conclusion. The architecture is in active development and plenty of things are still breaking in interesting ways.

How It Works

Each burst cycle starts with participant selection: picking 2–3 personas from the active pool who should be in the next exchange. We don't select randomly. Instead, we compute a weighted score for each persona that balances several factors we've found useful through trial and error. Opinion strength matters — personas with extreme beliefs tend to drive more interesting exchanges. Topic relevance gives a boost to personas whose interests align with the current thread. During the deep-dive phase of a conversation, we give extra weight to personas with domain expertise. And we apply a balance penalty to prevent any single persona from dominating the conversation, which was one of the first things that went wrong in early experiments.

Once the participants are selected, we assign a scene directive — a natural language instruction that frames the multi-message exchange as a directed social moment. We've identified six dynamics that we rotate through: pile-on (multiple people gang up on one position, some harsh, some apologetic), alliance (two personas back each other up against a third), debate (direct disagreement with substantive counter-arguments), derail (someone drags the conversation off-topic), callback (a reference to an earlier exchange that recontextualises the current thread), and normal (organic reactions without a strong organising dynamic). The distribution shifts as the conversation progresses — more debate during deep-dive, more callbacks toward the end — which gives the simulation a rough narrative arc without requiring a hand-authored state machine.

The participant selection formula we've settled on, for a 0–1 belief scale, looks like this:

score = 0.3                              // base weight
  + abs(belief - 0.5) * 2 * 0.3          // opinion strength
  + (on_topic ? 0.5 : 0)                 // trigger match
  + (deep_dive_phase ? 0.4 : 0)          // expert boost
  - (over_represented ? 0.4 : 0)         // balance penalty
  + random(-0.25, 0.25)                  // jitter

Each term is a flat value, not a function call. The previous writeup made it look like base_weight(0.3) was invoking something — it's not. It's just 0.3. The jitter term randomises each score within a ±0.25 band to keep selection from becoming deterministic, which was another early lesson: without jitter, the system kept picking the same three personas on every cycle.

What We're Seeing

These are early, qualitative observations — we haven't run formal user studies yet, and everything here should be read as "here's what seems to be happening" rather than "here's what we've proven." That said, the results so far are encouraging. In side-by-side comparisons, burst-generated conversations feel noticeably more organic than round-robin equivalents. Pile-on dynamics work particularly well: when we give the "pile-on" directive, personas genuinely gang up, coming at the same point from different rhetorical angles — one aggressive, one faux-apologetic, one bringing receipts. It captures something about online pile-ons that round-robin approaches completely miss, because in a turn-based system each persona would just politely disagree in sequence without the simultaneity that makes a pile-on feel like a pile-on.

The alliance dynamics have produced some of the most interesting results. When two personas are directed to back each other up, we sometimes see eerily realistic "yes and" exchanges where each persona builds on the other's argument, one providing the principled stance and the other supplying practical examples. It's the kind of emergent coordination that would be impossible to script but emerges naturally when the LLM is framing the whole scene at once. The downsides are real too. Sometimes the LLM over-acts the dynamic, producing melodrama instead of authentic disagreement — the pile-on becomes a cartoonish pile-on, the debate becomes theatrical. Derail dynamics are the most unpredictable: they occasionally go completely off-topic in ways that are either brilliant (an unexpected tangent that actually enriches the discussion) or useless (a tangent about something unrelated that kills momentum). There's very little in-between.

What We're Still Figuring Out

The biggest open question is scene directive intensity. Too strong and the exchange feels scripted — you can almost hear the director shouting cues. Too weak and you get bland, generic responses that could have come from any system. We've been tuning this by adjusting how prominently the directive appears in the prompt preamble, but we don't yet have a principled way to calibrate it. Different dynamics seem to need different levels of direction: pile-ons need a strong hand to coordinate the multi-angle attack, while normal-mode exchanges work better with lighter framing. We've also only tested this on Claude Sonnet so far — we have no idea whether different models respond differently to scene directives, and we'd expect they probably do. Next we want to test whether GPT-4o and Gemini handle the framing differently.

Burst size is another thing we're tuning. Two messages per burst feels too sparse — it barely qualifies as a "burst" and doesn't exploit the multi-message advantage. Four messages sometimes loses coherence; the LLM occasionally forgets which persona is which by the fourth message in a single call. Three seems to be the sweet spot for now, but we haven't systematically tested this. There's also a tradeoff between computational efficiency and message quality that we don't fully understand yet. Burst generation cuts API calls by about 60–75% compared to round-robin, which is genuinely useful for keeping latency manageable in a real-time streaming interface. But we don't know whether the cost savings come at the expense of individual message quality, or whether the scene framing actually improves quality by giving the model more context. Formal user studies are the next step — everything we're reporting here is based on our own impressions after reading hundreds of generated threads.

How This Compares to Round-Robin

Most multi-agent systems — AutoGen, ChatDev, MetaGPT, LangChain's agent primitives — use some form of round-robin turn-taking. Each agent gets a turn, generates a message, then passes control to the next agent. This works well when the goal is structured problem-solving, like having agents take on distinct roles in a software development workflow. It's predictable, debuggable, and the output is easy to trace back to individual agents. Burst generation abandons that predictability in favour of something messier and (we think) more interesting. It's not that one approach is better than the other — they solve different problems. Round-robin is the right call when you need legible, auditable agent behaviour. Burst generation is for when you want conversation that feels like it happened between real people, with all the chaotic, interrupt-driven messiness that implies. We're not claiming superiority. We're just noting that the two approaches produce qualitatively different kinds of synthetic discourse, and if you're building something that needs to feel like a real online community, it's worth trying both.