Skip to main content

Google Deep Review Explained

Google Deep Review checks long documents with parallel AI agents. See how it works, its SPOT results, and how to use it for free.
Vaibhav Mehra
Vaibhav Mehra

Create Your Free Account

Practice and track your progress.

Continue with GoogleBy continuing, you accept our Terms of Use, our Privacy Policy and that your data is stored in the USA.

Imagine you hand a friend a 40-page report and ask, "Can you check this for mistakes in the next 10 minutes?"

They will probably find a couple of typos and a grammatically incorrect sentence here and there. Would they notice that a number on page 3 doesn't match the same number on page 31? Probably not.

Now give the same report to a team.

One person who is good at math takes the equations, someone else goes through the experiments, everyone gets a copy of the full report, and an editor collects all their notes and double-checks anything that looks off.

That team will find a lot more, including the kind of mistakes that actually matter.

Google Deep Review is that second approach as software. It's an agentic AI system from Google Research that checks long, complex documents by splitting them into sections, reviewing each section in parallel, and combining the results into one report.

Google opened it to the public on October 14, 2026, with 2 free reviews per week.

In this article, I'll cover what Deep Review is, how its 4-stage pipeline works, what Google's published results show, and how to build the same pattern yourself. You can also see our guide to Gemini 3.1 Pro and our Multi-Agent Systems with LangGraph course.

In a Nutshell

  • Deep Review splits a document into sections, gives harder sections more compute, reviews every section in parallel with the full document in view, then merges and fact-checks the findings.
  • On a math and computer science subset of the SPOT benchmark (26 papers, 29 errors), Google's Paper Assistant Tool (PAT) caught 89.7% of errors, against 55.2% for Gemini 3.1 Pro used on its own.
  • Every user gets 2 free reviews per week. It accepts PDFs and plain text only.
  • All accuracy numbers come from Google and from authors who opted in. Nobody has independently tested the public version yet.
  • It checks the reasoning in your document, not your code, so a pipeline bug can still produce wrong numbers that look consistent.

What Is Google Deep Review?

Google Deep Review is an agentic AI system that gives feedback and technical verification on long, complex documents. It splits a document into sections, checks each section in parallel, and combines the results into one report.

Deep Review was first built for research papers. Google now says it also works for design documents, presentations, and legal and financial documents. You can use it through the Google Research Portal, and Google announced it at its Research@ event.

Going back to our analogy, Deep Review is the team plus the editor. It splits the work up so that each part gets a careful look, instead of reading your document once and giving a first impression.

Why did Google build Deep Review?

AI has made writing documents cheap, but checking them is still slow and expensive. Google calls this the validation bottleneck: information is generated faster than it can be rigorously reviewed.

According to Google, combined submissions to 3 major AI conferences (ICLR, NeurIPS, and ICML) grew from about 23,000 in 2023 to roughly 74,000 in 2026.

The number of qualified reviewers did not triple over the same period. (The 2026 figure is partly estimated, since the NeurIPS count in Google's paper is a projection.)

From Paper Assistant Tool to Deep Review

Deep Review started out as the Paper Assistant Tool (PAT). Google piloted it with 4 computer science conferences: STOC 2026, ICML 2026, NeurIPS 2026, and ICLR 2027.

Authors could opt in and get private feedback on their paper before the deadline.

More than 16,000 papers went through the pilots.

The feedback was kept separate from the official peer review, so it had no effect on whether a paper was accepted.

The public version adds support for Gemini 4 Argon, which Google says makes it stronger than the older PAT. Google has also built a related pattern into Antigravity, its agent-based coding environment.

The Teamwork Deep Document Review Pattern runs with the /teamwork-preview command.

How Does Deep Review Work?

Deep Review works as a 4-stage pipeline: it splits the document, budgets effort per section, reviews the sections in parallel, and merges the findings.

The obvious way to review a paper with a large language model (LLM) is to paste the whole thing in and ask for feedback.

That's the "friend with 10 minutes" from our analogy. Google gives 3 reasons it falls short:

  • The model runs out of thinking budget before it reaches the hard parts
  • It misses dependencies between distant sections
  • It accepts nuanced claims without scrutinizing them

Our team of reviewers follows the same 4 steps as the pipeline. Let's go through each stage.

Stage 1: Document segmentation

A segmenter agent breaks the document into logical pieces such as the introduction, methods, experiments, and proofs.

The pieces can overlap, but together they must cover the whole document.

In our analogy, this is the team deciding who checks which chapter before anybody starts reading. No part of the document gets skipped.

Stage 2: Adaptive compute budgeting

Some sections are much harder to check than others.

A long mathematical proof needs far more careful thought than a related work section, which is mostly a list of other papers.

Deep Review inspects how dense each piece is and gives the harder ones more compute.

Google's paper describes light, medium, and high thinking tracks, with proofs and theory getting the high track. If you have used a model with a "thinking" setting, it's a similar idea applied to each section separately.

Stage 3: Deep parallel verification

Next, reviewer agents check all the sections at the same time. Each agent focuses on its own section, but every agent can still see the whole document.

Say Section 5 uses a result that was worked out in Section 2.

The agent checking Section 5 can go back and see whether the two match. A model that only had Section 5 in front of it would have no chance of catching that.

Stage 4: Global synthesis and grounding

Lastly, a synthesis agent plays the role of our editor.

It combines the section reports, removes duplicate comments, looks for contradictions between sections, and reruns any logic checks it isn't sure about.

It also runs grounding checks against outside sources, including Google Search, to catch hallucinations such as papers or theorems that don't exist.

Without this step, the reviewer could confidently flag problems that aren't real and waste your time.

How to Build a Deep Review-Style Pipeline in Python

Deep Review is a map-reduce pattern built from LLM agents: split the work up, check the pieces in parallel, then put the results back together. You can build a simple version in under 80 lines.

The example below uses the Google Gen AI SDK with Gemini 3.1 Pro.

Its thinking_level setting gives us a way to build our own version of Stage 2.

from concurrent.futures import ThreadPoolExecutor

from google import genai
from google.genai import types

client = genai.Client()  # reads GEMINI_API_KEY from your environment
MODEL = "gemini-3.1-pro-preview"


def split_into_sections(text):
    """Stage 1: split a Markdown document on its headings.
    Deep Review uses a segmenter agent for this step."""
    sections, current = [], []
    for line in text.splitlines():
        if line.startswith("#") and current:
            sections.append("\n".join(current))
            current = []
        current.append(line)
    if current:
        sections.append("\n".join(current))
    return sections


def thinking_level_for(section):
    """Stage 2: a very rough version of adaptive budgeting. More math, more thinking."""
    math_signals = section.count("$") + section.count("=")
    if math_signals > 20:
        return types.ThinkingLevel.HIGH
    return types.ThinkingLevel.LOW


def review_section(section, full_doc):
    """Stage 3: review one section while still seeing the full document."""
    prompt = (
        "You are reviewing one section of a technical document.\n\n"
        f"Full document for context:\n{full_doc}\n\n"
        f"Section to review:\n{section}\n\n"
        "List math errors, logic gaps, and claims not supported by evidence. "
        "Quote the exact text for each issue. Say 'No issues' if there are none."
    )
    response = client.models.generate_content(
        model=MODEL,
        contents=prompt,
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(
                thinking_level=thinking_level_for(section)
            )
        ),
    )
    return response.text


def deep_review_lite(full_doc):
    sections = split_into_sections(full_doc)

    # Map step: review every section in parallel
    with ThreadPoolExecutor(max_workers=4) as pool:
        reports = list(pool.map(lambda s: review_section(s, full_doc), sections))

    # Stage 4 (reduce step): merge, remove duplicates, drop issues the document resolves
    merge_prompt = (
        "Merge these section reviews into one report with three headings: "
        "Major concerns, Minor corrections, Suggestions. "
        "Remove duplicates and drop any issue the full document clearly resolves.\n\n"
        f"Full document:\n{full_doc}\n\n"
        "Section reviews:\n\n" + "\n\n---\n\n".join(reports)
    )
    final = client.models.generate_content(model=MODEL, contents=merge_prompt)
    return final.text


if __name__ == "__main__":
    with open("my_report.md", encoding="utf-8") as f:
        print(deep_review_lite(f.read()))

Don't worry if you don't follow every line. The overall structure matters more than the exact code. Here is how it lines up with the 4 stages:

  • split_into_sections() is our segmenter (Stage 1)
  • thinking_level_for() decides the effort for each section (Stage 2)
  • ThreadPoolExecutor runs the reviewers in parallel, and each one gets the full document (Stage 3)
  • The merge_prompt at the end is our editor (Stage 4)

This version is much simpler than the real thing. There is no segmenter agent, no check against Google Search, and no second look at uncertain findings.

It does address 2 of the 3 problems Google lists: running out of thinking budget and missing connections between sections.

It also has costs to watch.

Every reviewer call carries the full document, so token usage grows with the number of sections.

The splitter also treats any line starting with # as a heading, including comments inside code blocks, so test it on your own files first.

How to Use Google Deep Review

Using Deep Review takes a few minutes of setup, then a wait while the agents work.

Setting up your first review

Six steps for running a Deep Review, from signing in to acting on the feedback

Figure 1: The steps to run a Deep Review, from signing in to acting on the feedback. Diagram by author, based on Google Research's Deep Review page.

  1. Go to the Google Research Portal and open Deep Review.
  2. Sign in with your Google account.
  3. Upload a PDF or paste in plain text.
  4. Optionally, add custom context to tell it what to check, and set the review depth and thinking level. Free reviews use Medium for both.
  5. Start the review. Google says it takes about 10 to 20 minutes, and longer documents can take up to 30.

A few limits to know about:

  • You get 2 free reviews each week, and you don't need an API key for them.
  • PDFs and plain text are the only accepted formats right now.
  • Google says multi-file support is coming soon, which would suit a paper plus its appendix.

Reading the report

A Deep Review report shown beside the DeepSeek-V4.1-Flash paper, with a high-level summary and strengths

Figure 2: An example of a Google Deep Review report, shown next to the paper it reviewed. Image taken from: ScriptByAI, Deep Review: Google's AI Reviewer for Papers and Technical Documents.

The report starts with Overall Feedback, a summary, then gives Detailed Feedback underneath.

You can filter the detailed comments into major concerns, minor corrections, and suggestions, and each comment names the section or page it refers to.

There is also a comment view and a Copy Report button that copies the whole review as Markdown. That's handy for pasting into your notes and working through it point by point.

How Accurate Is Google Deep Review?

Google's own results show that Deep Review's predecessor, PAT, caught 89.7% of math and computer science errors on the SPOT benchmark, against 55.2% for Gemini 3.1 Pro used on its own.

The numbers come from the PAT paper, Towards Automating Scientific Review with Google's Paper Assistant Tool.

SPOT is a benchmark built from real mistakes in papers that were later retracted or corrected. Google tested PAT on the math and computer science subset with equation and proof errors: 26 papers containing 29 errors.

PAT's recall was about 34 percentage points higher than the single-call baseline.

Two caveats apply.

First, the authors used their own grader, which accepts logically equivalent descriptions of an error, so you can't compare these numbers directly with the original SPOT results.

Second, the paper isn't consistent about the model: its text describes PAT as powered by Gemini Deep Think, while the results table labels the 89.7% figure as PAT with Gemini 3.1 Pro. Either way, this isn't the public Deep Review.

The pilot feedback also looks good.

Google surveyed authors from the STOC and ICML pilots, which reviewed more than 4,700 submissions in total. Among the 857 respondents (124 at STOC, 733 at ICML):

  • 92.7% of STOC and 90.7% of ICML respondents said the feedback was very or mostly helpful
  • About 1 in 10 STOC authors and more than 1 in 3 ICML authors (35.4%) said it found a significant theory error that took over an hour to fix
  • 31% of ICML respondents ran new experiments because of what PAT told them

That last figure stood out to me.

Running extra experiments right before a deadline is a big ask, so the feedback must have been convincing.

Still, all of these numbers come from Google and from authors who chose to take part, and nobody has tested the public Deep Review independently yet. Treat them as a promising signal, not proof of how it will do on your own documents.

How Can Data Scientists Use Deep Review?

You don't need to write math proofs to find Deep Review useful.

A lot of what data scientists and analysts write is a series of claims backed by numbers, which is what Deep Review is built to check.

Here are a few places where I think it makes sense:

DocumentWhat Deep Review can help check
Analysis reportsWhether each conclusion is supported by a number in the report
A/B test write-upsWeak statistical claims, or sample sizes that change between sections
ML design docsPlaces where the architecture section and the evaluation section don't agree
Notebook write-upsThe explanation around your results (export the notebook as a PDF first)

Google describes Deep Review as checking the reasoning in your document. It doesn't say anything about running your code, so a bug in your pipeline can still leave you with wrong numbers that look perfectly consistent.

A good workflow looks like this:

  1. Finish a full draft first. Reviewing half a document uses up one of your 2 weekly reviews.
  2. Run Deep Review and check every major concern yourself before changing anything.
  3. Fix whatever turns out to be a real problem, and rerun it if you still have a review left.

To use it inside your own tools, the Deep Review API lets you run reviews from code, for example, as part of a continuous integration (CI) pipeline.

You connect your own Gemini API key, so usage is billed through your Gemini API account.

Cost depends on document length and reasoning effort, so test it on one document before building anything around it.

Google Deep Review Limitations

The biggest limitation is that Deep Review can be wrong in both directions.

The PAT paper says the pilots surfaced cases where the tool wrongly called a correct proof incorrect because of a reasoning failure, and the authors say they are still working on it.

Grounding is the other number to watch.

Only 55.8% of STOC respondents and 64.8% of ICML respondents said the feedback was mostly or fully grounded, so roughly 35% to 44% of respondents did not find it mostly grounded.

Check every major concern against your document before acting on it.

It also doesn't make judgment calls.

It won't tell you whether your idea is new or interesting, and it doesn't rank papers. That part is still up to you and your reviewers.

Then there's privacy.

Google says it never uses uploaded documents to train, fine-tune, or improve its models, but it does keep them for 1 year so you can see them in the interface.

If you're working on something under a non-disclosure agreement (NDA), I would think twice before uploading it.

A few other limitations:

  • It's a closed system with no open weights and no way to host it yourself, so you rely fully on Google's models
  • It only accepts PDFs and plain text for now
  • 2 free reviews a week go quickly if you're making lots of changes to a draft
  • Every accuracy number so far has come from Google

Final Thoughts

Deep Review is closer to our team of reviewers than to the friend with 10 minutes. I think the best way to use it is as one more pass over the draft before you hit submit, with you checking each of its major concerns.

It flags things that aren't real problems; it can't judge whether your work is novel, and its accuracy still needs testing by people outside Google.

The design is the part worth taking away. Splitting the work up, giving the hard parts more effort, checking everything in parallel, and merging the results works in pretty much any agent that has to handle long documents.

If you're keen to build agents like this, I recommend checking out our Multi-Agent Systems with LangGraph course.

Google Deep Review FAQs

Is Google Deep Review free?

Yes, everyone gets 2 free reviews per week. If you need more, you can connect your own Gemini API key.

What file types does Deep Review accept?

At the moment, just PDFs and plain text. Google says support for multiple files is coming soon.

Does Google train its models on my documents?

No. Google says uploaded documents are never used to train, fine-tune, or improve its models. They are stored for 1 year so you can view them in the Deep Review interface.

Is there a Deep Review API?

Yes. The Deep Review API runs on your own Gemini API key, so you can run reviews from your own code, for example in a CI pipeline.

How long does a Deep Review take?

Google says around 10 to 20 minutes per document. Longer documents with a lot of math get more compute, so they can take up to 30 minutes.

How accurate is Google Deep Review?

On a math and computer science subset of the SPOT benchmark, Google's predecessor tool PAT caught 89.7% of errors, against 55.2% for Gemini 3.1 Pro alone. These results come from Google and haven't been independently tested on the public Deep Review.

Vaibhav Mehra

Author

Vaibhav Mehra

Topics

Related