Inspiration
Most of us are one blackout, bushfire or supply disruption away from realising we have no plan. Preparedness advice is scattered across government sites and PDFs, it's generic, and nobody reads it until the power is already out. I wanted a personal AI that already knows your family, your pets, your medication and what's in your cupboard, and that stays useful from the calm "prepare" phase all the way to "how do we restore power ourselves?"
What it does
Prometheus is one continuous AI companion, a little fire spirit whose face reacts as it listens, thinks and answers. You talk to it in a chat beside a canvas of cards, and the chat drives the canvas.
Say "I bought 5 L of water" and the flame flies out of the chat to your Water card, pencils in 60 L → 65 L and "7 left for 3 days", and waits. Tap Save and it stamps the number. Nothing changes until you do.
- Prepare: readiness in stages (3 days → 1 week → 2 weeks → your goal) instead of a scary percentage, with a short Next up list for the stage you're on. One card per supply area, in human units ("2 of 5 torches", "3.9 days of food for everyone"), each with a Why? that shows the cited working.
- Survive: scenario guides (extended blackout, supply disruption, isolation, plus a clearly labelled fictional zombie drill), your household's real resource picture, and a drafted response plan you save and tick off.
- SOS: a red button on every screen opens a full-screen emergency flow that needs no AI and works offline: is anyone hurt (call 000), what's happening, one safety question per screen, then the steps one at a time.
- Rebuild: the electricity technology tree as a numbered path of lessons, from "Energy & power" to "Small off-grid DC power", with materials checked against your inventory and mains wiring kept theory-only.
- Knowledge Vault: 20 curated offline entries, linked to sources such as the Australian Red Cross, Emergency WA, Ready.gov, CDC, FoodSafety.gov, OpenStax and PhET. When the vault is thin or you need current advice, Prometheus searches those same publishers' live sites with Tavily.
Permission modes, like Claude Code: Ask first shows every change and waits. Auto saves small supply changes itself, but only when the number is in your own message ("I bought 5 L" saves; "I bought a slab of water" asks), and every automatic save can be undone. Plan drafts everything and offers Save all.
Prometheus drives all of it through 17 real tools that read and write your saved data, and it remembers you across sessions. For anyone who wants the details, Advanced mode keeps the full workspace: every table, the tool log, and Under the hood.
How I built it
- Model: NVIDIA Nemotron served by Nebius Token Factory through its OpenAI-compatible chat completions API with tool calling.
- Live search: Tavily, limited to the trusted publishers in the source registry (see below).
- Agent loop: a bounded loop: model → Pydantic-validated tool calls → execute → feed results back → final answer, with a cap on tool rounds.
- Backend: FastAPI + SQLite. Each browser gets its own isolated household, keyed by a cookie. The database holds memory notes, inventory, tasks, pending actions, plans, a tool-call log and rate-limit usage.
- Deterministic engines: the supply calculator, readiness and shortage logic, BM25 search over the knowledge base, and a validated tech-tree graph (acyclic, with safety prerequisites).
- Canvas: an infinite canvas of real DOM cards (pan, zoom, drag; zoomed out, cards turn into a map of how ready you are). Each tool says which card its result belongs to, deterministically in code, and the app places it; the model never moves things around.
- Honest previews: a pencil value comes from a preview endpoint that runs the calculator on a copy of your data and saves nothing. You can edit a proposal before saving it, and undo any saved change.
- Frontend: vanilla HTML/CSS/JS with no build step, a dark and a light look, and an offline service worker. Prometheus's animated fire-spirit face uses the eye expressions from my Notch Face Kit: it blinks at idle, burns violet while thinking, sparkles when happy, flares red on errors and dims to an ember when offline.
- Transparency: an "Under the hood" panel shows the model ID Nebius reported, the response ID, latency, token usage, and every tool call with its arguments and effect.
- AI coding tools: I built this with help from Claude Code, an AI coding assistant.
How I used Tavily
Prometheus's offline vault is deliberately small and curated, so it can't answer everything, and some advice changes over time. I added Tavily as a live search tool, web_search, that Nemotron can call. It runs for real at runtime on the live app.
The catch is that in a safety app, "search the web" can't mean "search any website". Prometheus has a source registry (data/sources.json) of publishers I've vetted: Ready.gov, the Australian Red Cross, CDC, Emergency WA / DFES, healthdirect, FoodSafety.gov, OpenStax and others. So:
- Every Tavily request passes those publishers' domains as
include_domains, so Tavily only searches inside them. - The backend checks every result again and drops any page that isn't on a trusted domain or one of its subdomains, so a lookalike site like
evilready.govcan't get through. - The model can cite these pages in chat, but it can't use them as sources for steps in a saved survival plan. Those still have to come from the curated vault.
- Nemotron checks the offline vault first and only reaches for Tavily when the vault is thin or the user asks for current information. The tool only switches on when a Tavily key is set, and if Tavily can't be reached, Prometheus says so and falls back to the vault.
The result is fresher, more detailed answers from the live web without giving up the "no invented citations" rule. Ask the live app "Search the web: what does Ready.gov say about power outages right now?" and it answers with links to Ready.gov's current power-outage page, its hazard fact sheet PDF and its business toolkit, none of which are in the offline vault.
Challenges I ran into
- Adding live search without losing trust. Open web results would have broken the "only cite vetted sources" promise, so I limited Tavily to the vetted publishers' domains and re-checked every result in code.
- Keeping an LLM honest in a safety-critical domain. I moved every number out of the model. Water, food (counted in kcal, not cans) and shortfalls come from a deterministic calculator and a cited assumptions file. The model can only cite sources returned by its own tools, and plan steps that reference unknown sources are rejected.
- Agency without surprises. Write tools never change state directly. They create pending actions, and only the user's Approve click executes them.
- Reliable tool calling. I had to handle malformed tool calls, multi-round tool use and provider failures, and show those failures to the user instead of hiding them.
- Working offline. If the cloud AI is unreachable, the app says so plainly, and every data view still works. SOS and the guides keep working with no internet at all.
- Making it feel calm, not like an IT hub. My first version showed four panels at once and an unweighted 33% "coverage" score where a can opener counted as much as water. I rebuilt it around stages ("8 left for 3 days"), human units and one card per thing, and kept the dense view as Advanced mode.
Accomplishments that I'm proud of
- An agent that feels like one companion, yet every action it takes is auditable and needs your approval. Watching the flame pencil a change onto the exact number it affects makes approval feel natural instead of like a form.
- An emergency mode that works with no AI and no internet, quoting only curated guidance.
- No survival probabilities. Prometheus reports "coverage of planning targets", and AI guesses stay marked suggested until you confirm them.
- A Rebuild mode that turns "the grid is gone" into a learning path tied to what's actually in your inventory.
- Automated tests covering the calculator, readiness, tool validation, the approval flow, the agent loop, the tech tree, and persistence across restarts.
What I learned
Tool calling is only as trustworthy as the tools around it. The more I pushed into deterministic code (calculations, citations, state changes), the better and safer the model's answers got. I also learned that being upfront about limits ("Cloud AI unavailable", "planning default", "suggested") builds more trust than a polished but opaque answer.
What's next for Project Prometheus
- A local AI mode (llama.cpp + GGUF behind the same client interface), so the companion works when the internet doesn't.
- More Rebuild trees: water purification, food preservation, first aid and radio communications.
- Fully worked guides for more scenarios, plus localised guidance by region.
- Shared household plans for families and neighbourhoods.
Log in or sign up for Devpost to join the conversation.