Emergent Behavior

Simple rules, complex outcomes

Flocking birds follow three rules: stay close, don’t collide, match heading. From these three rules, murmurations emerge — thousands of birds moving as one fluid shape. No bird knows the pattern. The pattern emerges from the rules.

The same principle applies to AI agent systems. Individual agents with simple role constraints, operating on shared state, produce team-level intelligence that no single agent was programmed to exhibit.

Real example: Werewolf

The werewolf demo is a social deduction game with 6 AI agents: 2 werewolves, 1 seer, 3 villagers. Each agent knows only its own role and has simple rules:

• Werewolves: Vote to eliminate a villager at night. During the day, blend in.
• Seer: Investigate one player per night. Share findings carefully.
• Villagers: Discuss, deduce, vote to eliminate the suspected werewolf.

No agent sees the full game state. No agent is told how to argue, form alliances, or make accusations. Yet when you run the game:

• Werewolves naturally deflect suspicion to villagers
• The seer drops hints without revealing their role (self-preservation emergent behavior)
• Villagers form voting blocs based on discussion patterns
• Agents reference previous rounds, track who voted for whom, and build mental models of other players

All of this emerges from simple role descriptions + shared state + ACP events. The protocol just defines the phases (night → day → vote), the roles, and the communication channels. The complex social dynamics emerge.

How ACP enables emergence

Shared state as the environment

ACP’s state store is the shared environment where emergence happens. Agents read and write state. The pattern of reads and writes — who wrote what, when, what changed — creates information that other agents interpret and respond to.

# No agent was told to track voting patterns.
# But shared state makes voting history visible.
# Agents naturally reference it in their arguments.
state:
  vote_round_1: "player_3 eliminated (4-2 vote)"
  vote_round_2: "player_1 eliminated (3-2 vote)"

Events as signals

Events are the triggers that wake agents and prompt decisions. The ACP runtime pushes events — agents don’t poll. This means reactions are immediate, and the conversation unfolds naturally.

# Night phase ends → day phase begins
# All agents receive the transition event
# Discussion emerges from each agent's perspective on what happened

Governance as guardrails

Unconstrained emergence can be destructive — runaway costs, infinite loops, agents going off-topic. ACP governance provides guardrails without constraining the emergent behavior itself:

• Budget caps: Agents can’t spend more than allocated, regardless of how creative they get
• Phase exit conditions: The system moves forward even if agents want to argue forever
• Heartbeat monitoring: Dead agents are detected and their resources freed
• Quorum requirements: Decisions require minimum participation

Governance doesn’t dictate what emerges — it bounds how much can emerge.

The Queen pattern

In more complex systems, one agent watches the emergent patterns and adjusts. This is the Queen — an Opus-tier agent that reads telemetry, observes coordination patterns, and intervenes when things go wrong.

The Queen doesn’t micromanage. It observes emergence and makes structural adjustments:

• “Backend nest has failing tests — spawn a debug agent”
• “Frontend workers are claiming the same components — add more granular claims”
• “Token budget is 80% consumed — switch remaining agents to Haiku”

The Queen is itself an emergent coordinator — it reacts to patterns it observes, not to pre-programmed rules. Its system prompt provides judgment; the environment provides data.

Design for emergence

When building multi-agent protocols, design for emergence rather than scripting every interaction:

1. Define roles, not scripts — Tell agents what they’re responsible for, not what to say
2. Use shared state — Let agents see each other’s work through the environment
3. Set constraints, not behaviors — Budget caps, phase limits, claim rules
4. Trust the model — LLMs are surprisingly good at social dynamics and collaborative problem-solving
5. Observe and adjust — Use telemetry to watch what emerges, then refine the protocol