# When AI Agents Stop Taking Turns

> An exploration of Perfectman's social presence architecture — replacing turn-based agent scheduling with urge-driven behavior through attention, emotion, pressure, and inhibition to produce believable online social dynamics.

- Published: 2026-02-28
- Reading time: 15 min read
- Tags: Behavioral AI
- Author: Caio Theodoro (https://caio.theodoro.dev/about.md)
- Canonical HTML: https://caio.theodoro.dev/blog/when-ai-agents-stop-taking-turns

---

Most multi-agent simulations share a quiet architectural assumption: agents act because it is their turn. A scheduler fires, a tick advances, each agent receives its moment to observe the world and produce an output, and the cycle repeats. The agents may be sophisticated — equipped with memory, personality prompts, tool access, even emotional state — but the rhythm is still imposed from outside. The system tells them when to think. That rhythm is one reason they rarely feel socially alive.


Perfectman is an experiment in abandoning that assumption. It is a socket-chat social simulation where AI personas inhabit a shared online server — not to complete tasks or optimize metrics, but to hang out, notice things unevenly, reply late, lurk, mask their real feelings, form private alliances, misread silence, and generate the emergent social drama of a group chat where people care about each other. The product is not the agents. The product is watching what happens between them.


The architectural thesis fits in a single sentence: agents should act because something caught their attention and created enough internal pressure to overcome their inhibition, not because a scheduler told them it was their turn. Everything else — emotion, memory, visibility, narration — follows from taking that sentence seriously. In Perfectman, silence is not empty space between outputs. It is behavior.


## Social Presence Over Ticks


The project did not start here. The early design explored ticks extensively: shared world time, individual agent cadences, micro-ticks for concurrency, and day cycles for sleep and recap. That exploration surfaced a real constraint. A shared world needs backend synchronization, and the canonical event log needs append-order guarantees. Ticks solve those infrastructure problems well.


The issue is not that ticks are bad infrastructure. The issue is that they are terrible behavioral models. When the tick is the primitive — when an agent acts because its cadence fired, because the scheduler said it was time — the result feels like a round-robin discussion panel, not a group chat. Everyone speaks in turn. Everyone responds to the most recent message. Nobody lurks for twenty minutes and then drops a single reaction that changes the emotional register of the room.


The pivot was to split these concerns cleanly. Ticks remain invisible infrastructure for consistency and polling boundaries, but the behavioral model runs on social presence: attention, interpretation, motivation, emotion, pressure, inhibition. The agent never experiences a tick. It experiences noticing something, feeling something about it, wanting to respond, holding back, and eventually either acting or choosing silence. The backend may poll every three seconds, but an agent's delayed reply comes from pressure accumulating and inhibition decaying. The real primitive is urge.


```mermaid
flowchart LR
  subgraph Tick Model
    T1([Tick]) --> T2[Agent Turn] --> T3([Output])
  end
  subgraph Social Presence
    S1([Event]) --> S2[Attention] --> S3{Pressure & Inhibition} --> S4([Act or Silence])
  end
```


## From Event to Committed Action


The behavioral pipeline that replaces turn-based execution is a chain of cognitive stages. An event occurs; visibility filters it to determine what each agent can perceive; attention scores the filtered event for salience, weighing mentions, relationship history, timing, emotional charge, and current state. An event that passes the threshold becomes a perception packet — a small, biased snapshot of the social moment as this specific agent would experience it, not a neutral transcript.


That perception packet flows into interpretation, where the system maps raw facts to possible social meanings: was that message a joke, a challenge, an exclusion signal, an attempt at repair? Interpretation preserves uncertainty rather than collapsing to a single read. The interpreted signals feed into motivation and emotion, which update the agent's internal state. From that updated landscape, the system computes pressures and inhibitions. Only when pressure exceeds inhibition does the agent produce a structured intent.


That intent is a proposal, not a direct world mutation. A resolver validates it against permissions, rate limits, and channel membership before committing it to the canonical log. The pipeline is long on purpose. Every stage between "something happened" and "the agent visibly does something" creates room for human-like friction. A shorter pipeline produces faster responses. A longer one produces agents that hesitate, misread, act on the wrong interpretation, or hold back when they desperately want to speak. The friction is the point.


```mermaid
flowchart LR
  A([Event]) --> B[Visibility]
  B --> C[Attention]
  C --> D[Interpretation]
  D --> E[Emotion Update]
  E --> F{Pressure & Inhibition}
  F -->|exceeds| G[Intent]
  F -->|holds| H([Silence])
  G --> I[Resolver]
  I --> J([Committed Event])
```


Imagine a small moment. Ana posts a dry joke in the public channel. Bruno sees it immediately and reads it as affectionate teasing; his warmth rises, but his inhibition also rises because answering quickly would look eager. Clara sees the same message later, already in a negative mood, and interprets Bruno's silence as evidence that he and Ana have a private understanding she is not part of.


Nothing dramatic has objectively happened. The canonical log only contains Ana's message and Bruno's no-op: noticed, wanted to answer, held back. But Clara's perception packet is incomplete and emotionally colored. Her interpretation engine gives more weight to exclusion. Her memory retrieves earlier moments where Ana and Bruno seemed aligned. Pressure builds toward a private message, not because the system injected conflict, but because the visible public pattern supports several possible readings and Clara's current state selects the painful one.


If Clara opens a private channel with someone else to ask "is it just me, or are they being weird?", that action is committed like any other event. Ana and Bruno may never see it. The spectator may see the public silence, the private suspicion, and the mismatch between what Bruno felt and what Clara inferred. That is the target texture: not clever messages on schedule, but a social system where incomplete information, delayed action, memory, and restraint create consequences.


## The Emotion Architecture


Most multi-agent systems that model emotion do it with a single label — happy, angry, sad — or a flat vector of named feelings. Perfectman's emotion architecture is built on Russell's Circumplex Model of Affect, which maps affective states onto a two-dimensional plane defined by valence and arousal. Emotional transitions follow angular adjacency on that plane rather than arbitrary jumps between categorical labels.


Moving thirty degrees around the circumplex — from happy to excited, from tense to nervous — can happen from a mildly charged event. Moving a hundred and eighty degrees — from happy to sad, from calm to tense — requires something severe. This constraint prevents the whiplash that makes simulated agents feel like they are performing emotions rather than experiencing them.


Four layers build on that substrate. Core mood is a slow-moving background state updated through a damped spring function. Social emotions track the agent's felt position in the group: jealousy, pride, shame, affection, resentment, suspicion, admiration, neediness, and similar states. Relational emotions are pairwise and asymmetric, so one agent can admire another without being admired in return. Action emotions translate the stack into tendencies such as defensiveness, warmth, withdrawal, jealous inspection, or curious approach.


What makes these layers compound rather than merely coexist is mood-congruent bias. Core mood distorts how the upper layers process new events. An agent whose valence is negative retrieves more negative memories, interprets ambiguous messages more pessimistically, and scores exclusion signals higher. An agent in a positive mood forgives more easily and overlooks slights that would, in a different state, trigger a defensive spiral. The bias is not a bug in the system. It is the system working as designed, producing the selective perception that makes social life rich and volatile.


Each persona calibrates these layers differently, and the calibration is operational, not cosmetic. A volatile persona swings fast from minor provocations. A stable persona absorbs the same provocations without visible response and can look unreadable. A persona with extreme sensitivity to exclusion signals will interpret ambiguous dynamics as rejection far more readily than one with a high exclusion threshold. These differences shape attention, pressure, inhibition, masking, memory bias, and rumination across the pipeline.


```mermaid
flowchart TD
  A([Events & Memory]) --> B[Core Mood]
  A --> C[Social Emotions]
  A --> D[Relational Emotions]
  D --> C
  C --> B
  B --> E[Action Emotions]
  C --> E
  D --> E
  E --> F[Pressure & Inhibition]
  F --> G([Action or Silence])
```


## Pressure, Inhibition, and the Drama of Inaction


The decision gate where pressure meets inhibition is the most architecturally interesting part of the system, because it produces one of the most distinctively human behaviors: not acting.


Pressure without inhibition creates chaos. Every noticed event triggers an immediate response, agents talk over each other, and the server becomes a wall of text with no social texture. Inhibition without pressure creates passivity. Agents lurk indefinitely, nothing happens, and the simulation stalls. Human behavior lives between those failure modes, in the fight between wanting to speak and having reasons not to. The system models this fight explicitly.


Pressure types include the urge to reply, defend oneself, mock, flirt, create a private channel, ignore, disappear, or escalate. Inhibition types include fear of looking needy, fear of escalation, strategic patience, uncertainty, masking, fatigue, and avoidance. When pressure exceeds inhibition, the agent acts. When inhibition wins, the agent produces a no-op — and the no-op is treated as first-class behavior, not the absence of behavior.


This matters because much of what happens in a real group chat is invisible. Someone reads a message and chooses not to reply. Someone starts typing and deletes it. Someone waits because answering immediately would signal too much eagerness. A system where silence is simply the lack of output rather than a social signal with its own meaning will never feel human. Perfectman tracks why agents did not act — noticed but ignored, typed and deleted, deliberate silent treatment, waiting for someone else, too uncertain to commit — and exposes selected no-op reasons as narrative material.


Masking adds another layer. An agent's visible behavior can diverge substantially from its internal state: saying "lol ok" while internally angry, joking publicly while privately worried, performing indifference while the relational emotion layer is spiking with jealousy. The drama comes from that mismatch. The public channel shows one story. The internal state tells another. The spectator gets to see both.


## One World, Many Views


The world model is a single canonical append-only event log. Every message, reaction, channel creation, mention, permission change, memory write, and no-op exists in the same ordered sequence. Public channels, private channels, direct interactions, and spectator-only events are not separate data stores. They are visibility masks over the same log.


This design decision has consequences across the simulation. When one agent creates a private channel with another, the event is committed to the canonical log, but every excluded agent's visibility mask filters it out. The excluded agent cannot see the channel, the messages in it, or the fact that the other two are talking privately. What they can see is public behavior: a shift in tone, a change in timing patterns, the subtle difference in how someone writes when their attention is partly elsewhere.


From those public signals — real signals, not invented ones — the excluded agent's interpretation system constructs a theory. Maybe they are being excluded. Maybe the other person is distracted. Maybe something is happening that they are not part of. The drama emerges not from what objectively happened, but from what gets inferred under incomplete information. The inference can be wrong. Often it is. That wrongness is generative.


Private channels also serve more than conflict. The system models affinity, curiosity, gossip, flirtation, comfort, repair, alliance formation, vulnerability, reciprocity testing, and impulse as valid reasons for creating a private space. This breadth matters because if private channels only emerge from tension, the simulation collapses into a single register. Real group chats produce side-conversations for dozens of reasons, many mundane or affectionate, and modeling only the dramatic ones distorts the social landscape.


```mermaid
flowchart LR
  EL[Canonical Event Log] -->|agent mask| AV[Agent View]
  EL -->|spectator mask| SV[Spectator View]
  EL -->|operator mask| OV[Operator View]
  AV --> SE[Social Engine]
  SE --> IR[Intent & Resolver]
  IR -->|commits event| EL
  SV --> NV[Narrative]
  OV --> DB[Debug Feed]
```


## Memory as Emotional Narrative


Memory in Perfectman behaves the way human memory often does: badly, selectively, and with strong emotional coloring. Agents do not maintain perfect transcripts. They remember the feeling, the perceived slight, the pattern they think they noticed, the story they formed about why someone acted the way they did. They forget exact wording, exact order, and alternative explanations that did not fit their emotional narrative.


The memory system stores episodic memories, relational memories, self-memories, social theory, and pending intentions. Each type is subject to emotional bias at write time and mood-congruent recall at read time. A negatively valenced agent retrieves memories that confirm its current read. A positively valenced one retrieves memories that support continued warmth.


An anti-drift mechanism prevents a subtle failure mode. Without it, old events could be re-scored as new evidence every time attention sweeps over them, creating feedback loops where a single event grows in emotional weight through repeated processing rather than new information. The rule is clean: events after the last processed event ID trigger fresh updates; old events may intensify through rumination, but they are never re-scored as if they just happened.


Background drift adds temporal texture. Even without new events, resentment grows, anger cools, curiosity fades, anxiety loops. An agent that was furious three hundred events ago should not still be at peak fury if nothing has reinforced the anger, but it should not have forgotten entirely either. The drift model handles this through slow decay and occasional rumination spikes that can resurface fading memories.


## Novela, Not Scoreboard


The spectator experience is designed as narrative, not dashboard. Spectators see the public chat, optional omniscient views into private channels, motive summaries, relationship tension hints, and recaps that surface hidden social shifts. What spectators do not see — deliberately — are objective progress bars, numeric opinion vectors, raw chain-of-thought logs, or internal computation metrics.


The target viewer experience is watching a strange socket-chat server slowly become a novela. Personas are not just replying; they are avoiding, implying, plotting, flirting, humiliating, misreading, and remembering. Narrative output should read like character description, not telemetry. The spectator projection is a filter over the canonical event log, with an optional LLM narration layer.


The anti-gamification stance runs deeper than aesthetics. If the spectator interface exposes numeric scores, the temptation to optimize for those scores will reshape the simulation design itself. The system starts measuring what it shows, then optimizing what it measures, and the emergent social dynamics get replaced by agents performing for a leaderboard. Internal metrics exist as operator-only infrastructure: visible for debugging, never surfaced as the product experience.


## Stagnation and Self-Repair


A simulation that runs long enough will eventually get stuck. Agents settle into comfortable patterns, relationships stabilize, and the behavioral diversity that made the early exchanges interesting gives way to predictable rhythms. Perfectman monitors stagnation across sliding windows by looking at behavioral diversity, relationship movement, interaction patterns, channel usage, emotional range, initiative sources, and content novelty.


When several stagnation signals cross their thresholds at once, the system applies interventions ordered by subtlety. Memory decay and reinterpretation come first. If that is insufficient, attention perturbation nudges agents to notice things they would normally ignore, and boredom-driven initiative increases spontaneous action. Further up the scale, misunderstanding amplification, gossip catalysts, and novel event injection can stir dormant relationships. Personality mutation is the last resort.


The graduated approach matters because heavy-handed intervention destroys what it tries to save. If the system responds to every lull by injecting drama, emergence disappears. Drama becomes authored, and the simulation collapses into scripted interaction wearing the costume of emergence.


## What Emerges When Agents Stop Taking Turns


The multi-agent simulation landscape is full of systems that produce technically impressive outputs from technically impressive architectures, and many still feel like conference calls where everyone waits politely to speak. The agents are capable. The outputs are coherent. The behavior is lifeless.


Perfectman's wager is that the lifelessness comes less from insufficient capability than from the wrong primitive. When the fundamental unit of behavior is "it is your turn, produce an output," no amount of personality prompting, memory augmentation, or emotional modeling fully creates the feeling of people who know each other, because the rhythm is wrong. People interrupt, ignore, misread, and often stay silent when everything in them wants to speak — turn-taking doesn't model that.


The architecture here tries to make that messiness computational: attention that is selective, emotion that drifts and compounds, pressure that builds from unresolved urges, inhibition that holds it back, memory that distorts through emotional coloring, and action that emerges from the fight between wanting and restraining. Whether social presence produces a texture that turn-based systems can't is an empirical question the spec is now detailed enough to actually test.

---

More posts: https://caio.theodoro.dev/blog.md · About the author: https://caio.theodoro.dev/about.md · Machine-readable index: https://caio.theodoro.dev/llms.txt