Crisis Resource Navigator

Interactive — how you use it

Talk to it like a neighbour

Pick a message below and watch the agent work its loop. Everything it surfaces is sourced and timestamped, and nothing happens without a human pressing the button.

Concept Live

Concept animation · Live = real Slack

#exmouth-mutual-aid agent online

Crisis Navigator APPnow

I'm listening on this channel. Describe what you need, or what you can offer, in plain language. Pick a sample message below to see how I handle it. 👇

Send a sample message

Real Slack screenshot: a resident posts a water + generator need in the crisis channel; the agent replies with a workspace match card and an Official information water-point card, each sourced and UTC-stamped. — **Need → matches + official card.** Workspace offer (🟩) plus the relevant Official information card (🟦), each sourced and UTC-stamped, with the human-confirm button.

Real Slack screenshot: a resident asks if the road to Learmonth is safe; the agent refuses to judge safety and surfaces the road-closure advisory card, sourced and UTC-stamped. — **Safety question → refusal + advisory.** The agent says it can't judge safety, then surfaces the road-closure advisory card (🟥) verbatim — no safety assertion.

Real Slack screenshot: the coordinator board Canvas showing community cases grouped by status, the activity log, and the official Situation section. — **Coordinator board.** The live Canvas: cases by status, the human-confirmed activity log, and the official Situation section.

Real Slack screenshot: the branded App Home tab — what the agent does, how to use it, the human-confirms note, and a live official situation snapshot. — **Branded App Home.** What it does, how to use it, the human-confirms note, and a live situation snapshot — each row sourced and verify-noted.

Architecture

Three technologies, one loop

Each required hackathon technology carries one capability — reasoning, memory, or reach. No decoration; remove any one and the product breaks.

Agent surface

Resident posts a need in the Slack thread. Split-view agent UI, suggested prompts, streaming replies.

Slack agent surface

Workspace recall

Prior offers, coordinator notices, resolved cases — recalled live from the workspace itself. No wiki to maintain.

Real-Time Search API

⇄

Crisis Navigator agent

Bolt for Python + pydantic-ai. Parses to typed fields, plans sources, ranks matches, composes Block Kit replies.

parse → plan → rank → compose

Bolt for Pythonpydantic-aiGemini / Claude / GPT

⇄

External directories

Road closures, evac centres, official warnings — pulled through MCP servers (thin mocks for the demo; the integration pattern is the point).

MCP serversFastMCP

Sourced reply

Ranked options, each stamped with who/when or feed/fetched-at, one-tap actions — and a human confirms the match. Resolved cases feed back into workspace memory.

Block KitCoordinator Canvas

Slack AI

the reasoning + interface

Native agent surface interprets free text and runs the loop under Slack's trust and bounded-autonomy guidance.

Real-Time Search

the community memory

The workspace is the database. Day-one solutions answer day-three problems because every resolved case is searchable.

MCP

the outside world

Official feeds arrive as agent tools. Degraded feeds are declared, never papered over.

Under the hood

How the search actually works

No vector database, no embedding index on our side — two thin layers, each doing the one thing it's good at.

Keyword query → Real-Time Search

The LLM parses your message into a typed Need; we build a plain keyword query from it — literally "water generator North Exmouth" — and call assistant.search.context with a user token. Slack matches server-side and returns relevance-ranked messages with author, channel, timestamp, and permalink. We trust Slack's ranking as a first pass; its internals are Slack's business.

Domain re-rank → top 5

Pure, deterministic scoring: the match must share a resource word with the need (location words only boost, never qualify — a generator offer "in Exmouth" is not a formula match), plus linear 7-day recency. Agent-directed messages and the bot's own replies are filtered out. The top 5 render with source, timestamp, permalink, and the verify note.

Slack's own MCP server

The agent carries an MCPServerStreamableHTTP toolset pointed at mcp.slack.com/mcp, authorized with the user token. The LLM gets real workspace tools — search messages, read channels and threads, manage canvases — which is why replies cite real sources and timestamps instead of inventing placeholders.

Mock official directories

Thin FastMCP servers backed by static JSON simulate Main Roads WA closures, DFES advice, and evac-centre capacity. The agent consumes them exactly like Slack's MCP server — additional toolsets — so the integration pattern is identical to wiring a real government feed. A downed feed returns a structured error, not silence: that's guardrail 04 implemented at the protocol layer. No live feeds are claimed in the demo.

API surface

vs the search bar

The search bar is classic interactive search (modifiers, pagination, UI). assistant.search.context is agent-built: clean structured payloads meant for LLM context.

Coverage

observed, not assumed

The agent API returns public channel content only — it ignored offers sitting in a DM while classic search saw them. Post offers in channels.

Identity

who is searching

Both run as a user. Your search bar = you; the agent's recall = the authorized user token. Visibility scopes to what that user can access.

Ranking

human vs domain

The search bar ranks for browsing. Our pipeline re-ranks for the crisis domain: need-fit first, recency second, noise dropped.

Safety posture

Four rules that never relax

Disaster coordination is high-stakes. These are product requirements, version-controlled in the system prompt and pinned by CI regression tests.

GUARDRAIL 01

A human decides

The agent surfaces and ranks. Every actionable match ends at a confirmation button — never an automatic action.

GUARDRAIL 02

Never assert safety

It will not say a road is safe or make a placement call. It points at official sources with a verify before relying on this note.

GUARDRAIL 03

Everything is sourced

Every item carries who/when (workspace) or feed/fetched-at (external). Trust is shown on screen, not implied.

GUARDRAIL 04

Degraded states are loud

A feed that's down is named. Empty results are stated. The agent never goes quiet and never fills gaps with guesses.

Build log

What's built, what's next

Five-week plan to the July 13 deadline. Shipped via an agent-team pipeline — SWE implements, Tester verifies with evidence, every guardrail change re-checked, every milestone verified live in the sandbox.

Week 1 · done

Foundation

Sandbox provisioned, app scaffolded (Bolt + pydantic-ai), installed and verified live: reply, reactions, feedback buttons end-to-end.

Week 2 · done — 11 days early

Reasoning + recall

001 — crisis system prompt + guardrail regression net (live-verified)

002 — Need/Offer/Resolution entities + typed parsing

003 — Real-Time Search recall + domain ranking + sourced replies

004 — offer indexing on post (ADR-0003)

005 — unified single reply, contact mentions, multi-turn clarify

13 live-found bugs fixed during sandbox verification

Week 3 · done — same day as W1/W2

MCP + actions

009 — mock MCP servers (FastMCP): road closures, evac centres, official advice; degraded feeds explicit

010 — Connect / Mark resolved / Not relevant buttons; group-DM intro; audit trail

008 — match-card visual parity (parse fields, rank labels, sourcing + buttons)

passive channel listening + recall-quality fixes (echo/dismissal/twin dedup)

Week 4 · done

Polish + safety

coordinator Canvas board (open → connected → resolved) + humanized audit log + situation section

board is the channel's permanent "Community Cases" tab; survives restarts; fills from history

official MCP results as sourced cards (🟦/🟥) in the reply; explicit safety refusal

info-vs-resource routing; crisis suggested prompts + branded App Home dashboard

MCP resilience: retry without the toolset on failure + an explicit "official directories unreachable" alert — guardrail 04 at the protocol layer

Week 5 · in progress

Demo + submit

Deployed always-on and judge-accessible — one Docker image on a free-tier GCE e2-micro, with the official-directories MCP server kept warm over HTTP inside the box (no cold per-reply spawn). v1.0.0 tagged; the Devpost write-up drafted and truth-checked against the live app; live screenshots in; this field-guide page itself ships on GitHub Pages. Remaining: record the 3-minute video and submit on Devpost.