Devis Agent

From a one-line client request to a sourced, priced quote: Nemotron researches the market through Tavily, the code does the arithmetic.

Comment

Inspiration

This comes out of running a small web and automation agency. A prospect writes one sentence, "patients book by phone and no-shows are costing us chair time", and before anyone can answer with a number, someone has to break the need into modules, estimate hours, check what developers charge in that country this year, find which API the build would sit on, and remember which data protection rules apply. The research is the slow part. A plain chatbot skips it and invents a rate and a total, which is worse than no answer, because it looks finished.

We wanted the opposite: an agent that looks things up before it prices anything, shows its work while it does it, cites what it found, and is never trusted with the arithmetic.

What it does

A visitor describes a client's need in English or French, or clicks one of three examples, and picks the client's market: France (EUR), Senegal (XOF), Switzerland (CHF) or the United States (USD).

The agent then works in the open. A live trace shows each step as it happens:

  1. Nemotron plans the research and its short reasoning is shown.
  2. Tavily searches the live web, one topic at a time: developer rates in that country this year, the products or APIs the build would rely on and their pricing, the regulation that applies to the data involved (HIPAA for a US dental clinic, GDPR and the CNIL for a French one).
  3. Nemotron picks the most useful source and Tavily Extract reads it, returning the passages that answer the model's question rather than a snippet.
  4. Nemotron writes the quote as strict structured output.
  5. The code checks it: schema validation, and every citation matched against a source the agent actually retrieved.
  6. The code prices it: hours times rate, inside a per-market guard band, rounded per currency.

The result, in about 15 to 20 seconds, is a quote draft with modules and hour ranges, a one-time setup range, monthly support, the hourly rate with its rationale, tools and integrations, compliance points, assumptions, questions to ask the client, and numbered sources, the one read in full marked as such. It is written in the language of the request and can be copied as Markdown, downloaded, or printed to a clean PDF. It is labelled as a draft for a consultant to review, because that is what it is.

How we built it

  • Nebius Token Factory and NVIDIA Nemotron. nvidia/nemotron-3-super-120b-a12b through the OpenAI-compatible chat/completions endpoint, called with plain fetch, every response validated with Zod. The agent loop uses Nemotron's native tool calling with two tools, web_search and read_page. Each call sets chat_template_kwargs: { enable_thinking: true, low_effort: true }, so Nemotron keeps a short thought that the trace can show, without a full reasoning pass on every turn. The draft uses response_format with a strict JSON schema generated from the same Zod schema that validates it afterwards, with one automatic repair round if validation fails.
  • Tavily. Search runs with the country parameter set from the chosen market. Extract runs with query and chunks_per_source, so only the relevant passages of the chosen page reach the model. read_page only accepts a URL that a search returned, and only unlocks after two searches. Results are treated as untrusted data in the prompt, and citations are verified in code.
  • Deterministic pricing. The model proposes hour ranges and a rate band, nothing else. lib/pricing.ts lifts the inline citation marks Nemotron sometimes writes into its prose, drops citations to unknown sources, clamps the rate into a wide per-market band, multiplies, and rounds per currency. No line amount or total comes from the model.
  • Bounded agent. At most 3 searches, 1 page read, 4 planning rounds, 25 seconds of research, 500 output tokens per research turn, 2,200 for the draft, 30 second timeouts on model calls, 8 and 10 seconds on Tavily. A failed search or extract becomes a failed step in the trace and the agent carries on.
  • Product. Next.js 15 App Router, TypeScript strict, the route streams NDJSON events that the client renders as a live trace next to a skeleton shaped like the quote. Responsive down to 390 px, keyboard and screen reader friendly (live region for trace progress, labelled controls, skip link), print stylesheet, Open Graph card.
  • Cost and abuse controls. Same-origin check, 4 KB body limit, Zod input validation, 3 quotes per hour per IP and 40 per day in total, CSP and security headers, keys server side only.
  • Tests. node:test suites cover the tool budgets, a failed search, a refused extract URL, a failed extract, citation filtering, the rate guard band, the repair round and language detection. A smoke script runs one real end-to-end generation from the command line.

Challenges we ran into

  • One tool call per turn. We asked Nemotron for parallel searches in its first turn. In every real run it issued one call per turn, reasoning about what was still missing before the next. We rebuilt the loop around rounds, which also made the trace more readable: you can watch it decide.
  • Language drift. An English request for a French clinic came back in French: the model followed the client's country rather than the request. Language is now detected in code and imposed in the prompt and on the output.
  • Thin research. Our first real run did a single search, went straight to reading a page, and concluded that patient reminders needed no compliance section. Unlocking read_page only after two searches, and stating plainly that patient records and phone numbers are personal data, fixed both: the next runs searched rates, the messaging API and the regulation, and cited the CNIL and HIPAA sources.
  • Citation marks in the prose. On top of the citation arrays the schema asks for, Nemotron sometimes annotated its sentences with its own marks, 【1†Loxala】, which showed verbatim on the quote. The code now lifts them out of every text field and folds their ids into the line's citations, where the usual check against retrieved sources applies.
  • Account setup. The hackathon promo code NEBIUS-DEVPOST-GLOBAL26 returned error-no-event on our Token Factory account, and the onboarding step after Google sign-in sits behind a Cloudflare Turnstile check that an automated browser could not clear (details in the feedback section).

Accomplishments that we're proud of

  • A real agent, not a prompt: the model decides what to search, what to read, and when it has enough, and every decision is visible.
  • Numbers you can audit. Each amount traces back to hours and a rate, each rate to a cited source, and each citation to a page the agent actually retrieved.
  • A finished product rather than a notebook: four markets and currencies, two languages, export, print, mobile, loading states, accessibility, and a public demo that is protected against draining a paid key.

What we learned

  • Pairing a reasoning model with a search tool is not enough on its own. The quality came from the guard rails around it: tool budgets, an order of operations enforced in code, citations checked against what was really retrieved, and arithmetic taken away from the model.
  • Tavily Extract with a query is the difference between "the model saw a snippet" and "the model read the rate table".
  • Showing the model's short reasoning in the UI does more for trust than any disclaimer.

What's next

  • Calibrate hour estimates against the agency's own delivery history, so each module range reflects real past projects.
  • Let the consultant edit the draft inline and keep a version history before anything is sent.
  • More markets and languages, starting with other West African francophone countries, where the XOF pricing already applies.
  • Route the short research turns to a smaller Nemotron model and keep Nemotron 3 Super for the draft, as the track suggests, once we have measured that the smaller model plans searches as well.

Impact

Who it is for: small web and automation agencies and freelancers who answer inbound requests every week, in markets where rates and rules differ, which is our own situation across France, Senegal and Switzerland.

What the demo shows, measured on the production deployment on 30 October 2026: a complete, sourced quote draft in about 15 seconds, with 5 Nemotron calls, 3 Tavily searches, 1 page extract and about 11,000 tokens. That is the research and first-pass structuring that a consultant otherwise does by hand before a first reply. The gain is not only speed. Every rate, tool and rule in the draft comes with a source the consultant can open, which is exactly what a client asks for when they question a price, and the same request works in four markets without anyone knowing the local rates by heart. Our estimate of the manual equivalent, step by step, for a market the consultant does not quote every day: checking this year's local rates (10 to 15 minutes), finding and pricing the APIs involved (10 to 15 minutes), checking the data protection rules (about 10 minutes), then breaking the need into modules and hours (15 to 20 minutes). Roughly 45 to 60 minutes of research and structuring, against about 15 seconds for a sourced draft. This is an estimate, not a timed study. The draft still goes through a person, by design.

Testing instructions

  • Open https://devis-agent-nebius.vercel.app, click one of the three examples, then "Draft the quote". No account and no key are needed.
  • The public demo runs on paid API keys, so it allows 3 quotes per hour per visitor and 40 per day in total. If you reach a cap, the page says so; the code can also be run locally with your own Nebius Token Factory and Tavily keys (README, "Run it locally").
  • npm install && npm test runs the agent loop end to end against scripted model and search responses, with no key at all.

Built With

  • nebius-token-factory
  • next.js
  • nvidia-nemotron
  • tavily
  • typescript
  • vercel
  • zod
Share this project:

Updates

Submission history