Lifeline AI

Inspiration

There is a landslide blocking the only road out of town. The hospital has four hours of fuel left in its generator, and the water pump draws from the same feeder. There are 100 litres of diesel in town.

Split it 50/50 and the feeder browns out: the pump gets 30 minutes and then stops. Give the hospital its 70 litres first and the pump still runs for 90 minutes on its 30. Same diesel, same town, three times the water. But the arithmetic depends on factors outside the town's control.

Those factors are whether the road is blocked, how a landslide affects the supply chain, and how much fuel the hospital generator actually burns. That information comes from the web, and a wrong fact is worse than no answer.

Lifeline AI works out that order.

What it does

100 L diesel -> 70 L Hospital, 30 L Pump (no wastage, total = 100 L)
Route        -> 7.8 km village road vs 13.0 km signposted bypass (-40% trip fuel)
Pump uptime  -> 30 min -> 90 min (three times the water)
Decision     -> human gate

The application has 8 stages. Graph, Route, Allocate and Budget are pure calculation — no model, no network. Two more replay stored artefacts. Only the remaining two call a model. That split is deliberate: during a road outage there may also be a cloud outage, and we did not want to build a demo that stops working exactly when it is needed.

How we built it

We implemented three tiers of NVIDIA Nemotron 3, served through Nebius Token Factory. The models were read from the live GET /v1/models endpoint, and the pricing was taken from the same response. Ultra (550B) makes the one allocation decision, Super (120B) drafts and reviews the 8 locales, and Nano (30B-A3B) was tried first for triage. We measured them at 3.37s, 6.7s and 59s respectively. One file, brain.py, is aware of the provider; the engine itself never outputs a model name.

We used Tavily to search, extract, map and crawl. Five checks gate every claim: quoted, retrieved, timestamped, relevant (score >= 0.20) and regional. That produced 47 calls, 132 credits and 17 claims: 9 passed, 8 failed — one of them a high-scoring story (0.872) from the wrong region.

The core of the application — Kahn topological sort, A* over 9 surveyed edges, a 70/30 constrained solver with validation, a seeded ant colony, and a local open-weight voice gate with a hashed ledger — makes no network calls and therefore costs $0.00. Every piece of evidence comes from outside the town. Everything inside the town is data.

Challenges we ran into

Tier selection was measured, not assumed. Nano burned 6,000 tokens and returned finish_reason=length with an empty response; reasoning_effort=low does not cap how much it thinks. We moved drafting to Super, which answered in 966 tokens and 6.7s.

In the first Tavily run, a BBC article about the M25 footbridge was accepted as evidence, purely because both sentences contained the word closed. That is why check 4 exists: a relevance floor of 0.20. In the second run a New Indian Express story from Odisha passed the first four checks, and check 5 (regional) rejected it.

We also had to reject a misunderstood "no". Anything short of a clear yes — a cough, a "maybe", a stray word — counts as a no. The gate requires confidence above 0.80, and nothing is dispatched without a yes.

Accomplishments that we're proud of

78 acceptance tests, standard library only, covering the route audit, the 70/30 constraint, validation rejections, evidence provenance, the five checks, hashing, the 8 locale rules (7 spoken, Mandarin text-only), budget matching and offline operation.

$0.027049 across 18 inference calls and $1.056 across 132 Tavily credits — all measured, none estimated. Inference used 0.0917% of the $29.50 balance.

Ultra returned valid JSON on the first attempt: hospital 70, water pump 30, confidence 0.95. The validator passed in 3.37s.

The whole plan runs on calculation with the network off. The model is the fast path, not the only path.

What we learned

Even a perfect JSON response can be wrong — the verifier is what makes it trustworthy. And measuring one real call taught us more than any benchmark table: watching the 70/30 constraint validate in 3.37s reshaped the design.

A verifier that rejects is worth more than one that accepts. We publish the rejections next to the accepted rows.

What's next for Lifeline AI

We want a small quantised Nemotron that can run on the 6 GB laptop GPU, so the reasoning path also survives a total network loss. We also want multilingual streaming output: the gate is a voice, so the next step is lower first-token latency and natural prosody in Tamil and Swahili.

Built With

• a-star
• ant-colony
• json-mode
• multilingual
• nebius
• nemotron
• nemotron-3-nano
• nemotron-3-super
• nemotron-3-ultra
• next.js
• nvidia
• offline-first
• python
• react
• tailwindcss
• tavily
• tavily-extract
• tavily-search
• three.js
• token-factory
• topological-sort
• torch
• transformers
• typescript
• vercel