I built a murder mystery game where the suspects lie to you. Not scripted lies — real-time, motivated, adaptive deception from nine concurrent AI agents, each with their own secrets, alibis, and self-preservation instincts. Every playthrough is different because nobody is following a script. And that's exactly where everything interesting broke.

Detective Agentic Mysteries runs 9+ simultaneous GitHub Copilot SDK sessions: suspects, a forensics analyst, a criminal profiler, a narrator, and a director agent orchestrating the world. Each agent has its own tools, state, and objectives. Some agents cooperate. Some actively undermine each other. The cooperative multi-agent demos you've seen at conferences don't prepare you for what happens when Agent 4 contradicts Agent 7, both are partially right, and the player is watching.

I'll walk through the architecture, then focus on what broke: the suspect who invented evidence that didn't exist. The director agent that overrode a rogue character and collapsed narrative coherence. The moment I realised partial information sharing wasn't a feature — it was the entire design problem. Each failure taught me something that transfers directly to enterprise multi-agent systems: how to handle competing objectives, when an orchestrator should intervene versus observe, and how to maintain system coherence without scripting away the autonomy that makes agents useful.

The patterns I found — state isolation, bounded autonomy, orchestrator-as-referee, evidence-based convergence — aren't game patterns. They're system patterns. I know because I've now built two multi-agent systems on them. The detective game is adversarial: agents compete and deceive. Git-Ape, an open-source infrastructure deployment framework, is cooperative: agents collaborate through governance gates. Different domains, same structural problems. State management, agent coordination, knowing when to let an agent run and when to stop it. The patterns transferred directly.

You'll leave with design principles forged in the most adversarial multi-agent environment I could build — and a clear sense of which coordination problems your production system is about to hit.

Key takeaways:
1. Adversarial multi-agent systems expose coordination failures that cooperative systems hide — building both gives you a deeper understanding of orchestration than building either alone.
2. State isolation and bounded autonomy are universal multi-agent patterns — they work whether your agents are lying about a murder or validating a security policy.
3. The orchestrator's job isn't to control agent behaviour — it's to create the structural conditions where independent agents produce coherent outcomes, whether that's a solvable mystery or a safe deployment.