Consequence

Inspiration

Local development decisions — like clearing wetland for a commercial complex — often get made without anyone seeing the full tradeoff across water, biodiversity, health, and economic impact at once. Communities and city planners are usually handed a single verdict — "approved" or "not approved" — with the real reasoning buried in reports nobody reads before it's too late to change course. We wanted to build something that makes the consequences visible while a decision is still being made, not after.

What it does

Consequence Engine takes a proposed development plan and runs it through four specialist AI agents — Hydrology, Biodiversity, Public Health, and Economic — who independently analyze the plan and visibly disagree with each other, the way real domain experts would. An Arbiter agent then synthesizes those conflicts into a 10-year consequence timeline, showing how the tradeoffs compound over time rather than presenting a single flat score.

Users can hit "Try Another Future" to modify the plan — preserve more wetland, add permeable parking, restore a drainage corridor — and the agents rerun their full analysis, not just adjust a number. The two futures are then shown side-by-side with a computed tradeoff reduction, so the tool exposes what each choice costs instead of making the decision for you.

How we built it

Every specialist agent is grounded in real published coefficients and rules of thumb rather than invented statistics, and the tool is explicitly framed on-screen as a decision-support prototype, not a certified Environmental Impact Assessment — we were careful not to overstate what an AI simulation can responsibly claim.

For The Orchestra hackathon, we used Agent Orchestrator as our coding workspace end-to-end. The consequence-engine project was tracked on AO's Kanban board, with tasks moving through Idle → Needs You → In Review as work progressed — the "Bugfix audit" task is a direct example of AO coordinating against the live codebase. opencode was configured as AO's worker-agent adapter to execute delegated coding tasks straight from the board.

Challenges we ran into

Running on a RAM-constrained (7GB) machine, opencode's TUI renderer repeatedly crashed with an out-of-memory error, which intermittently blocked AO's Orchestrator view from spawning live agent runs. Rather than let that stall the build, we leaned on AO's Kanban board for planning, delegation, and tracking, and pushed code directly when live execution stalled — keeping the AO-driven workflow intact even when the ideal pipeline broke.

Accomplishments that we're proud of

Getting four independently-reasoning agents to genuinely disagree, and having an Arbiter meaningfully synthesize that disagreement into a coherent timeline instead of flattening everything into one verdict. We're also proud of shipping a fully working, interactive demo — including the counterfactual comparison mode — despite real hardware constraints mid-build.

What we learned

That the most useful framing for AI in high-stakes decisions isn't "here's the answer" — it's "here's what each choice costs, so you can decide." We also learned firsthand how much agent-orchestration tooling depends on local resources, and how to keep a build moving through task tracking and delegation even when the ideal execution pipeline breaks down.

What's next for Consequence

Expanding beyond wetland-to-commercial scenarios to any local development decision — housing, road expansion, industrial rezoning — so it holds up in an actual planning meeting, not just a demo. We also want to build a visible citation trail into the UI itself, so every agent's claim traces back to its published source and a city council could interrogate the reasoning directly instead of just trusting it. And once we're off a 7GB machine, we want to revisit full live-agent execution through AO rather than Kanban-tracked planning alone.

Built With

• ao
• api
• groq
• ts
• typescript