Atrium

Inspiration

California wildfires are not an abstraction when you go to school at UC Santa Cruz. The campus sits in redwood forest, PG&E shuts power off during red-flag wind events, and evacuation routes are a real topic of conversation every fall. When the Cisco Outshift Level 3 challenge, "Build a Collective Intelligence," landed at the UCSC AI Hackathon during SF Tech Week, the forest-fire framing was not a random pick from the prompt's example list. It was the scenario on our campus's doorstep.

What pulled us in specifically was the second half of the challenge: agents that disagree, not agents that cooperate on cue. Most multi-agent demos we had seen (including our own earlier experiments) quietly cheat the hard part. One agent is secretly a supervisor. The "negotiation" is a few turns of scripted-sounding dialogue that always resolves the way the demo needs it to. We wanted to build something that could not cheat that way, where an agent's objection had to be backed by a simulator result, where a plan could only execute if three independent actors genuinely all signed off on the identical version of it, and where the system was allowed to fail to agree and say so honestly instead of faking consensus for the demo reel.

The wildfire domain gave us a real reason for agents to disagree instead of a manufactured one. A single shared transport vehicle can move evacuees or move a fire crew, never both at once. A road that is closed cuts off one agent's plan while leaving another agent's plan intact. These are not contrived conflicts bolted on afterward, they fall directly out of how emergency response actually works: everyone is fighting over the same small pool of trucks, routes, and shelter beds, and every reasonable priority (save the most people, contain the fire, keep the response feasible) can point in a different direction at the same moment.

We were also explicitly trying to avoid a specific failure mode we had read about in disaster-tech projects before: the temptation to oversell a toy simulation as something that saves real lives. So from the first planning document, we wrote our own claim boundaries into the brief itself. This is a synthetic simulator with a fictional map inspired by the UCSC area, not a forecast of real fire behavior, not a real dispatch tool, and not evidence that "AI agents would make better emergency decisions than humans." What we wanted to demonstrate was narrower and, we think, more honest: that independent agents with real tool access and real evidence constraints can negotiate toward a decision, adapt when the ground truth changes under them, and know the difference between a resolved disagreement and one that needs a human.

What it does

Atrium runs a synthetic wildfire scenario (three communities, two shelters, three fire crews, two evacuation buses, and one shared multi-purpose vehicle) behind three independent AI agents:

Evacuation Agent, minimizing civilian exposure and assisted-evacuation delay.
Fire Operations Agent, reducing fire growth and exposure while limiting crew risk.
Logistics Agent, enforcing what is physically feasible: routes, fuel, capacity, timing.

Each agent starts with different private evidence, proposes a structured plan, and can challenge, counter-propose, or request evidence from the others. Every proposal is graded by a deterministic simulator, never by the agents' own claimed numbers. A plan only commits when all three independently accept the identical plan hash at the same state version, so there is no supervisor picking a "best" plan. Mid-scenario we inject a wind shift and a road closure, the agents' prior agreement is invalidated, and they have to renegotiate from the new evidence. In a compound-failure preset, resources are scarce enough that no plan satisfies every target, and the system is built to say so explicitly and hand the trade-off to a human instead of forcing a fake consensus.

How we built it

Architecture. A deterministic Python simulator is the sole source of truth for physics and feasibility: fire spread over a graph/grid, road capacity, vehicle and shelter limits. Agents never invent outcome numbers. Three actor loops each hold their own prompt, local state, and inbox, and call tools (get_local_observations, find_routes, validate_plan, evaluate_plan, submit_message) against the simulator through an injected context that enforces evidence isolation in code, not just in prompt wording. A message router delivers PROPOSE, CHALLENGE, COUNTERPROPOSE, REQUEST_EVIDENCE, ACCEPT, and ESCALATE envelopes, applies timeouts, and dedupes, but it never ranks or selects a plan itself. A commit gate checks for a canonical, unanimous plan-hash match at the current state version before anything executes, and any new evidence bumps the state version and voids stale acceptances.

Stack. FastAPI and Pydantic on the backend, streaming state over server-sent events, with JSONL-logged runs and replay. A React and TypeScript command-center frontend (map, agent cards, proposal comparison, decision timeline) consumes that stream. A standalone Three.js 3D visualization renders the UCSC-inspired forest-edge scenario for the live demo. backend/app/models.py is the single generated source for the frontend's TypeScript types, so the two sides cannot silently drift apart.

Process. Four of us split ownership by workstream (simulation, agents and negotiation, backend integration, UI) with file-level ownership rules, feature branches, PR gates, and a handoff doc per branch, so any of us, or any coding agent helping us, could pick up a task with zero missing context. That mattered a lot in a 24-hour format where people had to context-switch or hand off work mid-stream.

Challenges we ran into

Keeping "private evidence" actually private. It is easy to leak an agent's hidden information through prompt phrasing alone. We moved isolation into the belief-view and ToolContext code path instead of trusting prompt discipline.
Making "agreement" mean something. Silence, timeouts, and malformed tool output all had to be hard-coded as non-acceptance, otherwise a stalled agent could look like consent.
Staleness under renegotiation. A wind-shift or road-closure event has to invalidate in-flight evaluations and prior acceptances without corrupting state mid-round. This needed an explicit state_version bump and router-level drop rules.
Four people, one fast laptop with the strongest model. We scheduled time-boxed borrowing of the one high-capability seat for the negotiation-protocol core and used normal models and Codex for scaffolding and UI work.
No live model credentials for most of the build window, so the negotiation pipeline had to be proven correct end-to-end against a deterministic test provider before we ever spent a real model call on it.

What we learned

Multi-agent "negotiation" is only convincing when disagreement is enforced structurally (hashes, versions, tool-grounded evidence), anything resting on prompt wording alone collapses the first time you poke at it.
A deterministic, simulator-graded baseline makes every other claim checkable. Agents proposing their own outcome numbers is a trap even when it would be faster to build that way.
Escalation is a feature, not a failure mode. A system that can say "these targets cannot all be met, here is exactly why, and here is the choice a human needs to make" is more trustworthy than one that forces consensus every time.
Running a four-person team with strict file ownership and written handoffs, instead of everyone touching everything, kept parallel work from blocking on any one person, which was the difference between finishing and not in 24 hours.

Accomplishments that we're proud of

A negotiation protocol that is actually enforced in code: canonical plan hashing, a real unanimous commit gate, and state-version invalidation, not a scripted conversation that looks like one.
200+ tests on the simulator alone (204 green, about 27ms per evaluation) and a fully wired negotiation path (up to 156 tests green) proving commit, escalation, and fallback behavior before we ever spent a live model call on it.
A command-center UI that distinguishes fixture or preview data from live backend state everywhere, so nothing we show judges can be mistaken for a real forecast or a real dispatch order.

What's next for Atrium

Run the paired benchmark (fixed-rule planner vs. single-agent planner vs. Atrium) across the four presets with real model credentials and publish honest results, including any case where a baseline wins.
Wire the shared-vehicle and road-bottleneck conflict against live model calls end-to-end for the public demo, not just the test provider.
Explore AGNTCY-style capability discovery for a fourth specialist agent, and a second disaster domain to test how portable the negotiation core is beyond wildfire.