LivingTown

Inspiration

The most useful evacuation knowledge often lives in everyday neighborhood conversations: “this crossing floods,” “this path is too narrow for a wheelchair,” or “this place is a safe waiting point.” Traditional maps rarely turn that local, changing knowledge into evidence that can safely affect a route.

LivingTown explores a future where people and agents build a shared, verifiable memory of a town together.

What it does

LivingTown lets residents contribute local knowledge about barriers, flooding, darkness, narrow paths, and safe spots. Other participants can verify or dispute each item. Only verified knowledge can affect routing.

In the evacuation drill, a person can register a privacy-safe household profile using only allowed constraints such as wheelchair, infant, elderly, or pet. LivingTown then calculates a deterministic route and explains exactly which verified knowledge changed it, which graph edges were avoided, and why.

The production demo includes a long-distance wheelchair evacuation example: under flood + rain + daytime conditions, verified flood knowledge changes the route to a 1,330 m / 28 min evacuation to the existing shelter. The original canonical demo remains 440 m / 10 min for comparison.

The experience is available in both 2D and 3D. A route-following 3D walkthrough moves from the household origin through the safe route, pauses at the avoided hazard with an explanation, and finishes at the shelter. Replay provides a KNOWLEDGE → ROUTE debrief so people and agents can review what changed and why.

Why WebMCP

LivingTown is a strong WebMCP use case because an agent should not have to guess how to operate a disaster-prevention UI. The app exposes structured, phase-scoped tools that let agents participate in the same workflow as people while respecting verification and privacy boundaries.

MAP exposes contribute_knowledge, verify_knowledge, and query_area.

DRILL exposes register_household, get_evacuation_route, and report_bottleneck.

REPLAY exposes control_replay and get_debrief_summary.

That is exactly eight WebMCP tools. The native adapter uses document.modelContext.registerTool, supports getTools() and toolchange, and uses per-registration abort handling. Native WebMCP was verified in Chrome 152. When the API is unavailable, LivingTown explicitly labels the local compatibility path as SIMULATED rather than presenting it as native evidence.

Better user experience

The user does not need to translate a vague request into a sequence of UI clicks. A person can ask an agent about an area, contribute or verify local knowledge, prepare an anonymous wheelchair household, calculate a route, and retrieve a debrief through explicit tool contracts.

At the same time, the visual interface remains understandable for humans: pending → verified → affecting route is visible on the map, the avoided route is shown as a red dashed segment, the chosen route is shown in green, and the system explains why the route changed.

What people and agents can do together

Before LivingTown, community observations, accessibility constraints, route planning, and explanation typically lived in separate systems. LivingTown combines them into one accountable loop:

Human observation → verification → agent-accessible structured knowledge → evacuation route → explanation → replay.

An agent can help a wheelchair household without needing to know who that household is. The agent boundary is deliberately limited to anonymous labels, safe constraint enums, and temporary/demo locations rather than personal identity or exact private addresses.

How we built it

The frontend uses React, TypeScript, and Vite. Mapping uses MapLibre for 2D and a Navara/Three-based 3D visualization with GSI/OSM data sources and Dynamic PLATEAU-supported city visualization where available.

A deterministic graph routing engine makes route changes reproducible. Verified knowledge affects routing only when agreements minus disagreements reach the verification threshold. Avoided edges and reasons are returned as structured route evidence.

Production runs in SUPABASE_SHARED mode using Supabase Anonymous Auth, Realtime, RLS, owner-scoped temporary drill households, and RPC-only protected mutations. Community knowledge is shared; private drill state is owner-scoped. The production database and client share the same trusted graph-node boundary.

Production demo

No credentials are required.

Recommended flow:

1. Explore MAP and inspect community knowledge.
2. Open DRILL and choose Try long-distance example / 遠距離の例を試す.
3. Calculate the flood + rain wheelchair route: 1,330 m / 28 min with a verified flood avoidance reason.
4. Switch to 3D and use the route walkthrough to see the avoided hazard and reach the shelter.
5. Open REPLAY for the knowledge-to-route debrief.

LivingTown is a prototype. Moderation, retention policy, stronger identity/Sybil resistance, and broader real-world routing coverage remain future work and are documented in the public repository.

Built With

• maplibre-gl
• navara-map
• netlify
• plateau
• react
• supabase
• three.js
• typescript
• vite
• webmcp