Northbridge Brief

A quiet household agent: rules handle routine bills, Nemotron on Nebius writes a cited brief only when you must decide, and every step shows its model and cost.

Comment

Inspiration

Household bills hide duplicates, quiet price bumps, and medical estimates that are not what you will owe. Checking each one is a chore, so people stop. Finance chatbots don't fix that: they ping about everything. We wanted an agent that stays quiet when things are normal and, when it does speak, tells you what to do and shows where that came from.

What it does

Northbridge Brief looks after the bills of a fictional household (Avery & Morgan):

  • A rules gate decides who needs to look. Amount outside the expected band, duplicate charge, sensitive category (medical/tax/legal), or low funds → a human decides. Everything else is handled silently, with zero model tokens.
  • Escalations get researched. Tavily search (advanced) finds sources, then Tavily extract pulls the relevant passages from the top three pages.
  • Nemotron Super writes one short brief with a recommended action and [n] citations to those sources.
  • Nemotron Ultra reviews only the high-stakes ones (medical/tax/legal, several rules fired, or ≥ $500). It confirms or revises the recommendation and lists any claim the sources don't support.
  • Every step shows its model, tokens, latency and cost. A cost receipt compares the routed run with the same tokens priced on Ultra, and a benchmark endpoint runs both pipelines for a measured comparison.

Try it: open the live app and press Run the demo. You'll see the escalated dental brief, its sources, and the trace within about 30 seconds.

The hosted demo runs live: each click calls Nemotron on Token Factory and Tavily. Measured on the production deployment on Oct 25, 2026:

  • One full pass (6 bills, 6 Token Factory calls: 1 Nano, 4 Super, 1 Ultra) used about 7,600–8,100 tokens and cost $0.0045 routed. The same tokens priced on Ultra would cost $0.0110–$0.0115, so routing is 59–61% cheaper.
  • Side-by-side benchmark (/api/benchmark, both pipelines run for real on the same sources): routed $0.00459 (8,066 tokens) vs every step on Ultra $0.01327 (8,651 tokens), 65.4% cheaper. At 1,000 runs, that is about $4.59 vs $13.27. A second paired run, recorded in the demo video, measured $0.00449 vs $0.0133 (66.1% cheaper).
  • Speed: a full pass with fresh web research takes about 8–11 seconds. The four escalations run in parallel.
  • Tavily: 9 credits per fresh pass (three searches plus extracts; the two PG&E statements share one search). Repeat questions within 6 hours reuse the result for 0 credits.

These are single runs, not averages, priced at Token Factory list prices read on 2026-10-25.

How we built it

  • Next.js 15 + TypeScript on Vercel, with API routes for the agent (/api/investigate), health and live probe (/api/health?probe=1), and the measured benchmark (/api/benchmark).
  • Nebius Token Factory through its OpenAI-compatible API: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B for planning, nvidia/nemotron-3-super-120b-a12b for briefs, nvidia/Nemotron-3-Ultra-550b-a55b for escalation review. Every call records the API-reported token usage and latency. Cost = tokens × Token Factory list prices from the public catalog (read 2026-10-25).
  • Tavily /search (advanced, 5 results) followed by /extract on the top three URLs, with query reranking and chunks_per_source, so the brief prompt gets short, relevant passages. Credits come from include_usage.
  • Deterministic policy in plain TypeScript. Money decisions never depend on a model.
  • Tests with Node's test runner: policy on all fixtures, pricing and receipt math, JSON parsing of model output, an offline run that must make zero network calls and label everything, and a live-path run with fake Token Factory and Tavily servers that checks Nano/Super/Ultra routing, citations, and the receipt. ./demo.sh runs the agent end to end in one command.

Challenges we ran into

  • Regions and endpoints. Nano and Super/Ultra live in different regions with different base URLs. We default to the us-central1 endpoint and fall back to the global one.
  • Reasoning by default. Nemotron 3 thinks before answering by default, which spent our Ultra review's token budget and pushed a full run past Vercel's 60-second limit. Turning thinking off per request (chat_template_kwargs: {enable_thinking: false}) and running the four escalations in parallel brought a full pass down to about 8–11 seconds.
  • JSON from models. Replies sometimes include prose or small JSON mistakes. We match braces, repair trailing commas and raw newlines, and retry once within the time budget. Both attempts are billed, so both appear in the receipt.
  • Never show judges an error. Every live call has a deadline. If Token Factory or Tavily fails, times out, or runs out of credits, that step uses a labeled template or fixture, the trace says why in plain words, and the banner changes from LIVE to "LIVE, with a labeled fallback". If the whole request fails, the page shows the labeled offline run instead of an error. The OFFLINE banner appears only when no keys are configured.
  • Honest cost numbers. It's easy to show a made-up "savings" figure. We only show costs computed from API-reported usage, label the all-Ultra figure as a repricing, and offer a real side-by-side run.
  • Serverless state. Vercel instances don't share /tmp, so the UI renders each run from the response instead of re-reading server state.
  • Search queries. Our demo payees are fictional, so searching their names returns nothing useful. Research queries ask the real-world question instead (for example, typical patient cost for a dental crown after PPO).

Accomplishments that we're proud of

  • An agent that is quiet by default: two of six bills never touch a model.
  • Every brief cites its sources, and high-stakes briefs get a second opinion from Ultra.
  • Model, tokens, latency and cost are visible for every step.
  • The offline and fallback paths are clearly labeled and never present fixture output as real.
  • A full live pass costs under half a cent and takes about ten seconds.

What we learned

  • A Nano → Super → Ultra ladder maps naturally onto plan → write → check.
  • Tavily extract with query reranking gives better brief inputs than search snippets alone.
  • Being explicit about what is measured and what is not makes a demo easier to trust.

Limitations

  • Six fictional bills; no bank, email, or biller integration. Nothing is ever paid.
  • Expected-amount bands and duplicate rules are hand-set.
  • Prices are list prices as of 2026-10-25 and may change.
  • Ultra review adds latency, so it only runs on high-stakes escalations.
  • Cost figures come from single runs; the benchmark shows one paired run, not an average.
  • The Nano plan is a proposal shown in the trace; the deterministic policy gate makes every decision.
  • Run state is per server instance on Vercel.

Accessibility

Now: semantic headings, a role="status" mode banner, an aria-live run summary, labeled inputs, a captioned receipt table, and text on every colored status pill. Next: a keyboard focus audit, reduced-motion scrolling, a screen-reader pass (VoiceOver/NVDA), and reading the brief aloud with TTS.

What's next for Northbridge Brief

  • Read real bills from email or a biller export (with consent), instead of fixtures.
  • Let the household tune the rules (bands, sensitive categories, Ultra threshold).
  • Track cost across many runs to see how the routing pays off over time.
  • Voice delivery of the one daily brief.

Deck: https://github.com/dl88jing/northbridge-nebius-brief/blob/main/docs/pitch-deck.pdf Code (Apache-2.0): https://github.com/dl88jing/northbridge-nebius-brief

Live evaluation results

Live evaluation (5 repeated runs on the production URL, Oct 27): 5/5 fully live with no fallback, identical policy decisions every run, $0.00446 mean measured Token Factory cost per run (62.2% less than the same tokens at Ultra prices), and 76/76 inline citations pointing at real web sources. Details: https://github.com/dl88jing/northbridge-nebius-brief/blob/main/docs/live-eval.md

Built With

  • nebius-token-factory
  • nemotron-3-nano
  • nemotron-3-super
  • nemotron-3-ultra
  • next.js
  • node.js
  • nvidia-nemotron
  • react
  • tailwindcss
  • tavily
  • typescript
  • vercel
Share this project:

Updates

Submission history