SEARCHOps

SEARCHOps is an autonomous research agent returning reports where every claim is cited, quoted, and cross-checked across sources—powered by Nebius AI Studio, with Tavily for web search.

Comment

Inspiration

We kept hitting the same wall with AI research tools. You ask a question, you get back a confident, well-written answer, and then you're stuck: where did this actually come from? Does anything else back it up? And what did the tool quietly fail to find and just not mention? For anything we'd put our name on — a decision, a brief, something with a citation at the bottom — "trust me" wasn't good enough.

So we flipped the whole thing around. We decided the evidence should be the product, not a byproduct. If SEARCHOps can't point you to the exact sentence on the exact page that backs a claim, it doesn't get to make the claim. That one rule ended up shaping everything we built.

What it does

You give SEARCHOps a question. It plans out the angles, searches the web, reads the best pages, pulls out the facts that matter, checks them against each other, and writes you a report where you can click into any claim and see where it came from.

Under the hood that means:

  • It breaks your question into focused sub-queries, searches, ranks the results, reads the strongest pages, and extracts claims straight from the passages that are actually relevant — not the first few paragraphs of a page.
  • Grounding isn't left to the model. We decide it in code: the citation is the page the claim came from, and the quoted sentence has to appear word-for-word on that page. If we can't find the quote, we drop the claim. The model literally cannot make up a source.
  • A verifier then pulls passages from other pages and asks the model to label each one as supporting, contradicting, or irrelevant. We compute the verdict ourselves — supported, contested, or refuted — so the model never just declares something true. If another source contradicts a claim, it's thrown out.
  • A critic looks at what we've gathered, decides what's still missing, and turns those gaps into fresh searches. Each loop only chases what's new, so a second pass widens the evidence instead of repeating itself.
  • Finally it writes the report — with a trust summary, the open questions it couldn't resolve, a methodology note, and a proper sources list — and lets you export the whole thing to PDF, DOCX, or PPTX. You also get a live view of the pipeline running and a knowledge graph of everything it found.

And it's honest about itself. Grounding rate, citation coverage, how many claims have more than one source, and the hallucination rate are all measured against the real corpus and shown as measured. If something wasn't measured, it says so instead of inventing a number.

Make the report yours — and keep researching from it

A report isn't a dead end. You shape it before it's written, edit it after, and keep going from it.

Customize it before the run:

  • Choose the kind of report. It ships with nine profiles, each with its own audience, voice, and section structure — research report, executive brief, detailed analysis, comparative analysis, narrative, academic, business analysis, policy brief, or fully custom.
  • Steer it in plain English. Add your own instructions — "focus on licensing," "write it for a non-technical exec," "lead with the risks" — and the writer follows them.
  • Set the length. Ask for a longer or shorter report; it still never pads past what the evidence can honestly support.

Edit it after, block by block. The report is a block document, so you can rework any single block with one click — condense it, deepen it (pull in more detail), or rewrite it — without disturbing anything else.

Keep going from it — the "study & next" layer, all generated from the report's own content:

  • Next steps — the gaps the critic found are turned into clickable follow-up questions; one click launches the next run to close them, so research compounds instead of stopping.
  • Study guide & FAQ — revise from the report, or hand someone else a briefing, straight out of what it established.
  • Glossary & trust summary — key terms defined, plus an at-a-glance read on how well-supported the whole thing is.
  • Every one of these obeys the same honesty contract: an empty study guide says it's empty rather than inventing questions, and a glossary term with nothing to define stays blank.
  • Export the finished report to PDF, DOCX, or PPTX, all rendered from one canonical block document so they never drift from each other.

How we built it

The brain of the thing is a LangGraph state machine: planner → search → ranker → scrape → extract → critic → (reflect) → verifier → report writer → evaluation. Each step does one job and hands state forward, and the reflection loop is what decides whether we've got enough to write.

The web and the models — the two things an agent like this actually depends on — are where Tavily and Nebius carry the whole product. More on both below.

Around that we built a multi-provider LLM router that abstracts the model entirely (so swapping providers is a config change, never a rewrite), with a fallback cascade, per-run token and dollar budgets, deterministic response caching, and rate-limit backoff baked in. The backend is FastAPI on Python 3.12, async throughout, with Redis holding job state so a restarted run resumes instead of dying. The frontend is React + TypeScript + Vite + Tailwind — a landing page and the workbench, served as one container in production. It's typed with mypy --strict, linted with ruff, and has an end-to-end test that runs the real graph and pins the grounding and verification guarantees so we can't break them by accident.

The stack that makes it run: Nebius & Tavily

This is the part we're proudest of, because these two aren't bolted on — the product doesn't work without them.

Nebius powers every thought the agent has. Every reasoning step in the pipeline — planning the research, extracting grounded claims, the critic deciding what's missing, the cross-source verification, and writing the final report — runs on models served by Nebius AI Studio. We wired it in through Nebius's OpenAI-compatible API: we point the router's base URL at the Nebius endpoint and drop in our Nebius API key, and from that moment the entire agent is running on Nebius inference. Because we went through the OpenAI-compatible surface, Nebius instantly inherited everything our router already does — the fallback cascade, the caching, the token and cost budgets, the prompt-cache breakpoints — so it slotted in as a couple of config lines and immediately came with every cost and reliability guardrail we'd built. And since Nebius AI Cloud runs on NVIDIA GPUs, every one of those calls is NVIDIA-accelerated under the hood — the sponsor stack end to end.

Tavily is how it sees the web. A research agent is only as good as what it can actually read, and that's Tavily's job — it's our default web profile and it does two things we lean on hard. Tavily Search finds the candidate pages for every sub-query the planner generates, across the whole run and every reflection loop. Tavily Extract then pulls back clean, readable text from those pages — which is the "scraping" half of the pipeline — so instead of running and babysitting a fleet of headless browsers just to turn a URL into text, we get reliable page content from a single API. Every source our reports cite was found and read through Tavily, and the verbatim quotes we verify claims against come straight out of what Tavily Extract returned. It's also why the whole thing stays light enough to run on a free VM with about a gigabyte of RAM: no browser farm, just Tavily.

Put together: Tavily brings the world in, Nebius does the thinking on NVIDIA silicon, and our code makes sure nothing gets claimed that the evidence won't support.

Challenges we ran into

Getting trustworthy output out of an LLM was the first fight. Free-form JSON from a model breaks all the time, so we moved extraction and critique onto schema-constrained structured output and kept a repair ladder as a backstop — that killed almost all of the parse failures. Keeping the thing genuinely honest about provenance was the next one: it's far too easy to let a model paraphrase a page and call it a citation, so we made grounding a hard code check — quote matches or the claim is gone. Cost was a real constraint too, since a multi-stage agent makes a lot of calls; we answered it with hard per-run budgets, caching, and a cascade that retires dead models and backs off when a provider rate-limits us. And because the full pipeline is minutes long, we spent real effort on latency — exiting the reflection loop early when the evidence is already sufficient, verifying once at the end instead of every loop, overlapping the first search with planning, and throwing away duplicate and off-topic pages before any model ever reads them.

Accomplishments we're proud of

  • Reports you can actually audit — verbatim-grounded citations, cross-source verdicts computed in code, and a straight answer about what the run couldn't establish.
  • Real, measured quality numbers instead of vibes.
  • A clean sponsor integration: Nebius runs every model call through the OpenAI-compatible router, Tavily handles all the search and page reading, and the two of them are genuinely load-bearing rather than decorative.
  • It runs on free tiers with hard cost ceilings, so anyone can try it without a bill.
  • It's built properly — strict types, a real test suite, and a test that pins the trust guarantees so they can't silently rot.

What we learned

Schema-constrained generation beats cleaning up JSON after the fact, every time. Verification belongs in your code, not in the model's self-assessment — let it label the evidence and do the judging yourself. The biggest speed and cost wins came from decisions about the graph as a whole (where to spend a call, when to stop looping) rather than from fiddling with any single prompt. And abstracting the model provider paid for itself the moment we pointed it at Nebius — what could have been a migration was two lines of config.

What's next

  • Wire in dense and graph retrieval alongside the current lexical search (the Qdrant and Neo4j adapters are already there).
  • Lean further into Nebius — benchmark a few of its hosted models against each other for this workload and publish the latency and cost we actually see.
  • Scheduled, continuously-updating research briefs, and shared multi-user workspaces.

Built With

Share this project:

Updates

Submission history