How TinyResearch works: Inside the research loop

I've spent most of this year building TinyResearch, and the goal has always been easy to say and hard to build: you hand it a hard question, and what comes back is good enough that you don't have to redo it.

More and more, the one handing off that question isn't a person. It's an agent in the middle of a bigger job, like a sales agent prepping a brief before a call or an assistant comparing vendors for someone. An agent can't squint at a weak report and decide to double-check it the way you would, it just builds the next step on top of whatever it got back. So TinyResearch had to work as a step you can call and rely on, whether you're the one reading the report or your agent is.

That came down to five things I measure every change against: factual correctness, credibility, readability, comprehensiveness and instruction following.

This post is the long version of how TinyResearch gets there: what happens inside a run, how deep the loop actually goes, a few decisions I changed my mind on along the way, and how it does on three public benchmarks.

If you just want to try it, it's live at agent.tinyfish.ai/playground/research.

What a run looks like

Say you ask: "Should I buy a Tesla Model 3 or a Toyota Camry?"

That's not one question. It's a handful of them hiding inside one sentence. How much would each cost over five years, including insurance, maintenance, and fuel or charging? What changes if you can't charge at home? How do they compare on safety, comfort and reliability? And what do independent tests and long-term owners reveal that you won't find in the brochure?

TinyResearch starts by breaking your question down like that. Then it goes looking, reads what it finds, pulls out the specific claims each page supports, and checks what it has against the original question. Wherever there's a gap, say it has plenty on purchase price but nothing solid on long-term reliability, it goes back for another round on exactly that gap. It only writes the report once it's satisfied the question is actually covered, and it writes it only from the claims it collected.

You can watch all of this happen. The playground shows you the plan, what it's searching for, what it's reading, and a partial answer that builds up as it goes, so you're never staring at a spinner wondering what it's doing.

Inside the research loop

At the center of TinyResearch is one loop, run by an orchestrator. Here's what happens in each round.

1. Plan. The orchestrator looks at your question, everything it has learned so far, and the rules you've set, and decides which questions to chase next. Planning lives inside the orchestrator on purpose, so it's always planning with the full picture of what it already knows (more on why below).

2. Search wide. For each of those questions it runs searches on TinySearch, which brings back a large pool of candidate sources for every round.

3. Rank for the objective. Before reading anything, it ranks those candidates for credibility and relevance to your question. This part matters more than it sounds. A government statistics page is the best possible source for unemployment numbers and close to useless for public sentiment on a new product, where thousands of real posts tell you more. So ranking takes the research objective into account, instead of using one fixed idea of what a "good source" is.

4. Read live. The best sources get read through TinyFetch at the moment of the run, so it isn't relying on whatever an index saw weeks ago. Static pages like articles, docs and papers go through fetch, and dynamic, JavaScript-heavy pages go to a browse tool that navigates the page to get at the content.

5. Extract the claims. A separate pass pulls the specific claims each page supports and attaches the source to every one. The orchestrator never has to wade through raw pages. It gets back a clean set of ranked sources and evidence, which keeps its context focused on the only two things it really needs to do: plan, and decide where to look next.

6. Check against the question. The orchestrator compares what it has with what you asked. If parts of the question are still thin, it goes around again, deeper each time and aimed at exactly those gaps. Along the way it writes partial answers, so you see what it's learned as it learns it.

7. Write the report. Once the question is covered, or the run hits its depth budget, it writes the final report from the collected claims only, with numbered citations on every one. Nothing goes into the report that didn't come off a real page during the run.

Steering the loop with domain controls

The loop makes its own call on which sources to trust, but researchers kept telling me they already know which sources they want, and more importantly which ones they never want to see. So you can hand TinyResearch a list of domains and choose what it does with them:

• Include them, and they get priority whenever they're relevant, while the rest of the web stays open.
• Exclude them, and they never make it into the research at all. This is how most people filter out content farms, SEO blogs and anything else they'd never cite.
• Explore them exclusively, and the whole investigation happens inside that list. Nothing from outside it gets searched, read or cited.

The setting carries through every round of the loop, so it shapes what gets searched, how candidates get ranked and what gets read, which is why an exclusive run comes back with citations that all point inside your list.

Exclusive mode is the one that surprised me most in how people use it. Compliance teams use it to keep a question on the regulator's own site, because a third-party summary of a circular can get the paragraph numbers wrong, and when counsel has to sign off on the exact clause, the primary source is the only one that counts. You'll find it under domains in the playground, or as domain_filter in the API. Here's an example.

How deep it actually goes

"Deep" is one of those words every research product uses, and more isn't automatically better. Past a point, extra sources just bloat the context and slow you down without making the report any sharper. So we tuned these limits on purpose, to optimize for depth, accuracy and the time it takes to produce an actionable report. These are typical figures for a Deep run.

Max mode gives the loop more room: more rounds, deeper reasoning and a more thorough investigation, for the questions where you really want nothing missed.

Every run also has a ceiling on steps and on time, which we set deliberately, and when it gets there it writes the report with everything it has. I learned that one the hard way, because an early runaway run without those limits kept going far longer than any question deserved. A finished report you can read is obviously better than an investigation that never ends.

Why the loop changes what you get

All of that machinery exists for one reason, which is to change what lands on your screen, or in your agent's context. Each part of the loop maps pretty directly onto one of the five things I care about.

Factual correctness comes from extracting claims before writing anything. The model writing your report isn't summarizing pages from memory, it's assembling a report from claims that were each pulled off a specific page, with that page attached.

Credibility comes from TinyResearch judging its sources on its own, even when you haven't told it which ones to trust. Every claim in the report is backed by a source, and how much confidence it carries depends on how strong that source is for your question. That's why ranking is built around your objective, and why the report reasons about the strength of its evidence instead of treating every cited claim as equally solid. A claim backed by an independent long-term reliability study should count for more than one backed by a dealer's blog, and the report treats it that way.

Readability comes from the same place. Because the report is built from claims and not from raw pages, there's no room for filler. Every line is there because it tells you something.

Comprehensiveness comes from the check-and-go-back step. A tool that stops at the first plausible answer will always sound confident but misses the most important things. Going back for every gap is slower, and it's the reason the report covers the parts of your question that are hard to find.

Instruction following is about the rules you set, and carrying them through every round. That covers the domain controls above, plus limiting a run to news or research papers or a date window, and reviewing the plan before it starts. Those rules shape the searching, the ranking and the reading, not just the final write-up.

A few things I changed my mind about

The loop didn't start out looking like this. I wrote about the full journey in Lessons from Building a Deep Research System, but three changes shaped TinyResearch more than anything else.

I removed the planner. The first version had a separate planner that wrote the research strategy and handed it to the orchestrator. It looked clean on paper, but every time the planner was called it was starting from a snapshot of what the orchestrator knew, and things got lost in the handoff. It showed up most on follow-ups: you'd ask to focus only on pricing risks in Southeast Asia, and the planner would drift right back to the whole market. Moving planning into the orchestrator fixed that, because now the thing doing the planning is the thing that's been following the whole investigation.

I stopped making everything an agent. My instinct early on was to spin up a subagent for every search query. It was slow and expensive, and it turned out none of those steps were judgment calls. Ranking results and extracting claims are predictable jobs, so they became plain tool calls that hand back something already distilled. The orchestrator got faster, cheaper and more focused.

I started optimizing for how researchers decide what to trust. I used to optimize for coverage, meaning more sources and more evidence. When I showed reports to actual researchers, they cared much more about the strength of the evidence behind each claim. That's what led to objective-aware source ranking, to the report reasoning about how strong its evidence is, and to giving you direct control over which sources it uses.

How it performs

I ran TinyResearch, in Deep mode, on three public research benchmarks. Each one uses its own evaluation protocol, so the scores are best read within that benchmark, and alongside each one is a real report from the run so you can see what the output actually looks like.

DRACO

DRACO is the benchmark Perplexity published. It covers 100 complex research tasks across ten domains and grades each report on factual accuracy, breadth and depth of analysis, presentation and citation quality.

TinyResearch scored 51.74 out of 100, graded with GPT-5.2, one of the judges evaluated in the DRACO paper, averaging five passes over all 100 reports (± 0.31).

To show how TinyResearch turns research into a recommendation, we selected a report on protecting sensitive data when employees use ChatGPT Enterprise. The passages below show recommendations for two different corporate environments, each paired with the trade-offs it would need to consider.

Selected excerpts. *Wording and citation numbers are unchanged; references are available in the full report.*

DeepResearch Bench II

DeepResearch Bench II grades reports against expert-written reports on how well a system finds the important information, analyzes it and presents its conclusions. TinyResearch scored 46.42 out of 100, graded using the benchmark's evaluation code with GPT-5.5 as the judge.

For a sample of how TinyResearch handles scientific literature, we selected a report on T-cell exhaustion, covering molecular mechanisms, transcription-factor comparisons and laboratory research methods, with cited sources.

*The report includes research published after the question's July 2023 cutoff; this limitation is also noted alongside the full report.*

ResearchRubrics

ResearchRubrics comes from a Scale AI-led team and grades each report against expert-written requirements for that task, covering things like reasoning, synthesis and how well claims are supported by sources. It's 101 tasks and 2,593 criteria in total. TinyResearch scored 77.10 on compliance, which gives half credit when a requirement is partly met, and 71.04 on strict compliance, which only counts requirements that are fully met.

We selected a report on legal personhood for AI to show how TinyResearch handles a question with competing arguments. These three rows from the report's comparison of corporate and AI personhood examine identity, enforcement and liability.

Three selected rows. *Wording and citation numbers are unchanged; references are available in the full report.*

Start researching

Pick the mode that fits your question:

You only pay for completed reports, and every new account starts with $8 in the wallet.

You can run TinyResearch wherever you already work:

To start a run through the API, set your TINYFISH_API_KEY environment variable and run:

curl --no-buffer \
  https://agent.tinyfish.ai/v1/automation/run-research \
  -H "X-API-Key: $TINYFISH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Should I buy a Tesla Model 3 or a Toyota Camry?",
    "mode": "deep",
    "stream": true
  }'

If you want to see what it can do before you write your own question, we put 30+ real reports and datasets, with the exact prompts, at tinyfish.ai/deep-work. And if you build something with it, or it gets something wrong, tag @Tiny_Fish and tell us.

We read everything.