FindingNemo

Everyone's worst day has a map. We built the platform that lets any community draw its own.

Inspiration

In the 2018 Camp Fire, about 40,000 people evacuated through heavy traffic, closed roads, and direct fire exposure. Eighty-five people died. NIST's case study documents 198 evacuation assistance or rescue events and 31 temporary refuge areas.

The signal is often there, but nobody can trust it fast enough. In the 17 hours after Hurricane Harvey's landfall, Houston's 911 system took more than 56,000 calls, against about 8,000 on a normal day. In one study, 41% of 824 geocoded Harvey rescue requests on Twitter came from areas FEMA rated "minimal flood risk." And crowd data can be faked: 99 phones in a handcart once created a fake Google Maps traffic jam.

In a crisis, everyone needs answers to the same two questions: where is it happening, and which way is still safe?

The signals exist: panic buttons, GPS tracks, weather stations, local news. But every disaster app, campus safety tool, and community alert system has to rebuild the same stack to use them: data pipelines, GIS, scoring heuristics, trust systems, and routing. Most communities will never have that team.

So we turned the stack into a compiler. Describe the app in plain English, connect your sources, and FindingNemo builds a live geo-intelligence platform for your community, then keeps improving it during the event.

What it does

Nemotron beyond a chatbot: agents that refine each other

Nobody chats with FindingNemo. One plain-English description starts a team of NVIDIA Nemotron agents that build a live system, then keep improving it while it runs.

Every agent output is a draft. It becomes real only after it survives a check the model can't talk its way past.

Agent	Nemotron model	Draft it produces	What refines it
Compiler	3.5 Super, reasoning on	A complete app spec	Validator errors, then human review
Scout	3.5 Super + Lightning	A live data connector	Feed probes and a mandatory parse test
Critic	3.5 Super, reasoning on	New model weights and user trust	A held-out backtest
POI Labeler	3.5 Lightning	Named places on the map	Evidence from live tools, re-judged as it changes

How one output gets better

1. The Compiler drafts the system. Nemotron reasons over the developer's intent and proposes operators, weights, trust tiers, spoof limits, verification methods, public visibility, and place labels. It reads what each input means: the same GPS ping becomes a density signal or a flow-source signal depending on the developer's description. validate_spec returns every error and warning, Nemotron revises, and finalize_app checks again. Nothing goes live until the developer edits or confirms the proposal, including a preview of exactly what the public will see. If an input needs outside data, the Compiler can request the Scout.

2. The Scout grounds it in the real world. It decides what to search, probes candidates, configures one, and tests it. A connector that parses nothing is removed, and the Scout moves to the next probed feed. Lightning then reads each article, drops off-topic items, and extracts a location. Malformed output gets one repair pass. In a live run, the Scout connected a tested 40-item local news feed in 34 seconds.

3. The Critic improves the model while it runs. A new hotspot, an authority signal, fresh reference data, or a verification drop wakes it up. It reads the map, inspects each layer, checks suspicious users, and forms a hypothesis about which signals deserve more weight. Then it tests that hypothesis:

Nemotron defines a search over weights, up to 2,048 candidates.
Code discards anything that breaks tier bounds or developer pins.
Survivors are scored in a vectorized batch on the first 70% of recent history.
Only the top 5 are evaluated on the 30% holdout. Nothing is ever ranked on it.
The highest-priority verification method must improve, and no other may degrade by more than ε.
Nemotron chooses a passing candidate and explains why. Guards confirm the backtest is fresh, unused, and was measured against the weights still live.

"No change" is a valid answer, but it has to come from a backtest result. Each accepted change becomes the baseline for the next run, so the model keeps refining itself as the event unfolds. In a live crowd-only app, the Critic raised held-out predictive accuracy from 0.711 to 0.780 by shifting weight toward the better-corroborated source. In a 15-minute full-stack run, it made 9 backtest-gated weight changes without a human touching a slider.

Tier	Used for	What agents can change
`locked`	Authority inputs	Nothing, ever
`stiff`	News, official sensors	±10% per hour, only with authority evidence
`flexible`	Crowd inputs	±25% per step, renormalized, never below 10% of the starting weight

Trust is asymmetric: agents can lower a user's trust with a reason, but raising it needs a passing backtest and is capped at +0.1 per user per 5 minutes.

You can watch it learn. The Critic checks crowd reports against independent sources that can actually confirm a location. Reporters it cuts below a trust of 0.35 stop adding heat to the map. In the console, the map shows which source is driving each cell, flashes the cells a change moved, and displays that change's holdout improvement. A built-in simulator can inject normal or spoofed traffic to test this on any app.

4. The POI Labeler decides what the map means. Code finds persistent clusters, because agents can never invent coordinates. Nemotron chooses which evidence to gather: layer drivers, time patterns, raw readings, or OpenStreetMap features. It names a place only if the evidence clears the app's confidence bar, then updates or retires that place as the evidence changes. If nothing in the label set fits, it proposes a new label for the developer to accept.

The agents improve each other's work

Compiler → Critic: the verification methods it proposes define how the Critic is judged, and its starting weights are what the Critic corrects.
Compiler → Scout: it can request outside data for an input.
Scout → Critic: each new live signal gives the Critic something new to weigh.
Critic → POI Labeler: corrected weights and trust change which places persist.
POI Labeler → people: a place named as a safe destination becomes a route target.

Built to the Nemotron brief

Challenge	How FindingNemo delivers
Beyond a chatbot	Agents wake on live events, act through tools, and change a running system
Multi-step workflows	Bounded plan-act-observe loops of up to 5–8 steps per run
Tool integration	30+ registered tools, scoped by agent, including Tavily, OpenStreetMap, Open-Meteo, RSS, and our backtester
Real-world applicability	Plain-language evacuation guidance that updates as conditions change
Multi-agent system	Four specialized agents, each with a model tier matched to its job
Agentic retrieval	Agents decide when to search, what to fetch, and when they have enough evidence
ReAct	Every run reasons, calls tools, observes results, and adapts
Simulation and eval	Simulators and a built-in spoof mode post through the real ingest path, held-out backtests judge every weight change, and each Critic run is logged for future fine-tuning

What the agents power

Add a source by describing it. Say "local news that reports on this" and the platform infers the data type and recommends how to connect it: REST, webhook, RSS, or a JSON API. Each app gets a generated setup guide with ready-to-run examples.

Watch risk move, every 2 seconds. A deterministic engine turns every input into a grid layer and combines the layers into a live score map with hotspots, streamed over WebSocket. Vector fields such as wind are drawn directly on the map as arrows.

Operator	What it reads from the world
`flow_source`	Where moving entities are fleeing from or converging on
`density`	Time-decayed, trust-weighted concentration of reports
`dwell`	Where entities stopped and stayed
`field`	Sensor data on the grid, with hazards carried along a vector field
`event_points`	Geocoded documents, weighted by confidence and source reliability
`override`	Authority markers that always win

Get people out. Anyone with the public link can open a phone-friendly page and share their position to get one plain-language instruction: the safest reachable destination, walking time, and what to avoid. If no destination is close enough, it routes them to the nearest safe area. Raw inputs, other people's locations, and sensitive places stay private. The server takes only the caller's own position, so the endpoint can't be used to find someone else.

One platform, any domain. Wildfire evacuation and bird migration tracking run on the same backend. There are no if wildfire branches: domain knowledge enters only through the app spec. Our operators don't even know what wind is. They know vector fields.

How we built it

Backend: FastAPI, Python, Pydantic v2, NumPy, SQLite. Frontend: React, TypeScript, Vite, Tailwind, Leaflet, and a WebGL pond built with Three.js. AI: NVIDIA Nemotron through the NVIDIA API Catalog. Geo and data: OpenStreetMap, Open-Meteo, Tavily.

Nemotron proposes, code decides

Agents can't write state. Every action is a schema-validated tool call checked by code guards, and no LLM sits in the 2-second map loop. If the rate budget runs out, the agent skips its turn and logs why. The map keeps moving.

The audit trail doesn't take the model's word either: each run's recorded result comes from the tool calls that actually succeeded, while the model's own summary is labeled unverified. Every change records before and after values, so a developer can revert it from the console.

The scoring engine

Each operator produces a layer, normalized so a single stray event can't look like a crisis:

$$\text{norm}(L) = \frac{L}{\max(p_{99}(L),\ \text{noise floor})}$$

Layers combine under agent-tuned weights, and authority overrides are applied last:

$$S = \max\left(\text{clamp}\left(\sum_i w_i \cdot \text{norm}(L_i),\ 0,\ 1\right),\ O\right)$$

Hazards can travel. The field operator carries a layer along a live vector field with advection-diffusion, using RK2 substeps limited to CFL ≤ 1:

$$\frac{\partial c}{\partial t} + \mathbf{u} \cdot \nabla c = D \nabla^2 c$$

flow_source finds the origin of an event from movement alone, using weighted least squares on back-extended tracks with robust reweighting. Our reference tests landed within about 13–29 m median error across a 300 m area with 40+ phones.

Routing runs Dijkstra over the 8-connected grid and prices danger into every step, while cells above the impassable score are blocked:

$$\text{cost} = d_{\text{step}} \cdot (1 + \alpha \cdot S_{\text{cell}})$$

Built for an adversarial crowd

Spoof detection flags duplicate coordinates across accounts, bursts of new IDs, and physically impossible movement using limits set per input. It never flags people for being close together, because in a crisis real clusters are the signal.

Every directions message passes a code guard: the destination must be safe, the route passable, the text free of other users' coordinates and sensitive labels, and the length under 360 characters. On failure, users get code-built text.

Challenges we ran into

Crowd data was grading itself

Our first verification let an input's events score against a map that already included that input, so the crowd "predicted" itself. We rebuilt the check as leave-one-input-out and weighted it by each input's share of the model. Before the rework, the Critic could search 256 configurations and find nothing to improve on a crowd-only app. After it, the same kind of app passed a held-out backtest and improved from 0.711 to 0.780.

The Critic cited the wind as evidence

In live testing, the Critic lowered a reporter's trust by citing a wind field. A vector field can't confirm where a report happened, so corroboration now excludes field-shaped inputs at the tool level. The fix went into code, where the model can't forget it.

Trust cuts disappeared in the math

When the Critic distrusted most of a layer's reporters, percentile normalization rescaled the remaining signal and canceled the change. Now reporters below the trust threshold add no heat at all, so what the agent learns actually changes the map.

One weather station turned the whole map red

A broad field layer could lift every cell at once and merge the map into one giant hotspot. Fields now contribute only their spatial contrast, so a uniform or single-station reading adds nothing.

A finished compile isn't a working app

In live tests the Compiler finalized 9 of 9 specs, but often omitted verification methods, which left the Critic with nothing it was allowed to act on. It also turned place labels off for intents that literally asked "where." After we tightened the validator and task, 12 of 12 live compiles finalized in 3 model calls, with labels named from the intent every time.

Agents on a shared rate budget

The whole system shares roughly 40 requests per minute. We added token buckets, trigger cooldowns, and batched evidence calls. The POI Labeler had been running out of steps in 7 of 9 repeat runs; it now stops early when nothing is new.

Accomplishments that we're proud of

Measured self-improvement: Nemotron raised held-out predictive accuracy from 0.711 to 0.780 on a live crowd-only app, with no human tuning.
A 15-minute live run on a real server: 245 events ingested with 0 rejected, 450 WebSocket frames with 0 errors, 9 backtest-gated weight changes, and a place named by the POI Labeler.
Far under the clock: a full engine tick on the maximum 250,000-cell grid with 5 weighted layers took a median of 0.33 s on CPU, against a 2-second budget.
12 of 12 live compiles finalized and 16 of 16 plain-English source descriptions classified correctly.
900+ automated backend tests, with no network or live LLM calls, covering the guarantees that matter: holdout gating, locked weights, and privacy over REST and WebSocket.
A complete path from idea to public link: describe it, confirm it, connect it, watch it learn, and share it by link or QR code.
Agents with real authority and real limits, where every decision can be inspected and reversed.

What we learned

The most useful thing we did for our agents was take power away from them. Once a model couldn't change anything without evidence, we could let it try ambitious things, because a bad idea would die in a backtest instead of reaching someone trying to get out.

We also learned to measure agents on what happens after they finish. A spec can validate perfectly and still produce an app that can never improve itself. An agent can also make a persuasive argument from the wrong evidence, so the evidence itself has to be constrained in code.

And building for "any domain" was harder than building for one, but it kept us honest. Every time a threshold depended on fire, birds, or people, it had to move into the spec.

What's next for FindingNemo

SMS inputs, so a community can report without installing anything
NVIDIA cuOpt to dispatch responders across multiple shelter-in-place groups
GPU-accelerated backtests with CuPy for far larger weight searches
NVIDIA OpenShell as a production sandbox for agents
A proposal model fine-tuned on the Critic's logged accepted and rejected decisions

Built in a weekend, for everyone's worst day.