Vera

Inspiration

We surveyed nine open-source deep-research repos — gpt-researcher (~30K★), HF smolagents (~24K★), Alibaba DeepResearch (~20K★), langchain open_deep_research (~10K★), and others — and found two field-wide gaps: every one of them is stateless (same brief, same generic report, no memory of you or past research), and all of them are weak on citation quality — claims cite sources nobody verified, or nothing at all. The insight that became Vera: treat model disagreement as a feature. One model hallucinating is a bug; several open models disagreeing on a claim is a detectable signal — and it is only possible on open multi-model infrastructure. The hackathon's sponsor constraint (Nebius Token Factory + NVIDIA open models) turned out to be the product's engine, not a limitation: single-model APIs structurally cannot do what Vera does.

What it does

Vera is a personal deep research agent. Give it a brief and it runs a five-stage pipeline: Plan (Nemotron decomposes your brief into sub-questions phrased for your persona), Search (live Tavily queries with your trusted domains preferred inside the query and banned domains excluded at the source), Draft (atomic claims, each required to cite a real fetched URL — uncited claims are dropped, not guessed), Verify (a prosecutor pass hunts counter-evidence for every claim, then 2+ independent models vote; disagreement triggers a live web re-check → supported / contradicted / disputed), Synthesize (a persona-voiced report capped at readable length, with unused sources published for transparency).

Because it remembers, it can also do what no surveyed repo can: run a delta on a topic you researched before and report only what changed/confirmed/reversed — truly-reused sub-questions skip search, drafting, and verification entirely. A topic watcher keeps researching while you're away (probe-gated so it never wakes the models unless the web actually changed), private notes steer the research with a deterministic code gate ensuring verbatim note text never reaches Tavily, skills package persona + brief + source prefs into one-click recipes with template variables, and every run is tagged with its mode in an honest activity log.

How we built it

• Backend: FastAPI with one async stage function per pipeline stage, every stage taking its clients as injectable parameters. Strict TDD throughout — 178 tests; test doubles fake every client, so the suite never makes a real API call.
• Inference: everything through Nebius Token Factory's OpenAI-compatible API — NVIDIA nemotron-3-super-120b-a12b as planner/synthesizer, deepseek-ai/DeepSeek-V4-Pro + Qwen/Qwen3-235B-A22B-Instruct-2507 as the two independent verifier models.
• Search: Tavily in six distinct roles — grounding, prosecution, community prosecution (reddit-restricted), refereeing re-checks, full-page extraction, and the transparency pool — with role-labeled telemetry and a deterministic per-run search budget.
• Memory: SQLite (profile, runs with provenance, verdicts, feedback, topic reports, watches, notes, skills). Feedback is a closed loop: 👎-rated claim texts raise verifier strictness on future runs.
• Deterministic enforcement, never prompt-hope: search budgets consumed in priority order, evidence caps (top-8 sources × 800 chars), output caps (≤120 words/section), a coverage gate that retries the planner on missed brief bullets, and a privacy gate at every Tavily dispatch site.
• Frontend: Vite React consuming SSE — live pipeline view, per-claim proof expansion showing each model's vote and the prosecutor's evidence, telemetry panel, persona/notes/skills/memory panels.
• Deploy: a single render.yaml blueprint (backend + static frontend, cost-postured for a public demo).

Challenges we ran into

• Structured output garbled. Token Factory's response_format=json_schema returns gibberish on Nemotron-3 reasoning models ({"sub_questions":[{"id":", ","text":""}]}). We rebuilt every JSON call as schema-in-prompt with brace extraction and a retry — and lost nothing.
• Verifier greed. The first live run drafted 84 claims — noise plus 4× verification cost. We answered with deterministic caps, not prompt-hope: 5 claims per sub-question, budgeted searches, evidence caps. Measured on a real brief: 45 → 16 searches, 411K → 120K tokens (−71%), with a healthier verdict spread.
• Hosting walls. Render's API demands a payment card even for free services; Hugging Face's Docker Spaces moved behind PRO; Vercel architecturally cannot host background runs or a watcher loop. We answered with a cardless blueprint posture (watcher off by default, capped watches, token ceiling) — and by learning the demo-hosting clause is platform-neutral.
• The machine fights back — Avast TLS interception breaking Python's ssl, SSE replay edge cases, a heredoc that silently no-op'd a patch. The superpowers TDD workflow (failing test first, always) is what kept every fix honest.

Accomplishments that we're proud of

• The moat is visible. Expand any claim and you see each model's individual vote and the prosecutor's counter-evidence verbatim — judges watch models disagree instead of trusting a badge.
• True delta mode, live-validated: 15 of 40 claims reused on a follow-up run at 118 vs 189 calls — the report shows what changed, not a re-research.
• Privacy enforced in code at all six Tavily dispatch sites, with an honestly scoped claim (verbatim text and short echoes blocked; paraphrases may evade) instead of an overpromise.
• An honest activity log: every run tagged manual/delta/skill/watch — the automation footprint is inspectable, and provenance is server-owned (spoof-proof, pinned by test).
• 178/178 tests across the entire pipeline, written before the code they verify.

What we learned

• The sponsor constraint can be the product. Multi-model verification is impossible on a single-model API — the rule that looked like a limitation was the differentiator.
• Deterministic beats hopeful. Budgets, caps, gates, and privacy rules in code do what prompt-instructions merely suggest.
• Measure, then cap. We only understood the token burn (411K/run!) by instrumenting it — telemetry became a feature, not an afterthought.
• Model disagreement is information. Verifier models from independent training lineages catch each other's errors — that's worth more than any single "better" model.

What's next for Vera

Persistent hosted memory (the demo runs on ephemeral free storage today), a per-watch run-history timeline, verified-report export (PDF/Markdown with full proof chains), multi-user auth on top of the existing memory-control layer, and skill-linked watches that re-fill template variables each cycle.

Built With

• fastapi
• httpx
• nebius-token-factory
• nvidia-nemotron
• pydantic
• pytest
• python
• react
• render
• server-sent-events
• sqlite
• tavily
• uvicorn
• vite