Ga naar hoofdinhoud

Google Deep Review uitgelegd

Google Deep Review controleert lange documenten met parallelle AI-agents. Zie hoe het werkt, de SPOT-resultaten en hoe je het gratis gebruikt.
Vaibhav Mehra
Vaibhav Mehra

Maak je gratis account aan

Oefen en volg je voortgang.

Ga verder met GoogleDoor verder te gaan, accepteer je ons Gebruiksvoorwaarden, onze Privacybeleid en dat je gegevens in de VS worden opgeslagen.

Stel je voor dat je een vriend een rapport van 40 pagina's geeft en vraagt: "Kun je dit binnen 10 minuten checken op fouten?"

Die zal waarschijnlijk een paar typfouten vinden en hier en daar een grammaticaal onjuiste zin. Zou die merken dat een getal op pagina 3 niet overeenkomt met hetzelfde getal op pagina 31? Waarschijnlijk niet.

Geef hetzelfde rapport nu aan een team.

Iemand die goed is in wiskunde pakt de vergelijkingen, iemand anders loopt de experimenten door, iedereen krijgt de volledige tekst, en een eindredacteur verzamelt alle aantekeningen en dubbelcheckt alles wat vreemd lijkt.

Dat team zal veel meer vinden, inclusief de soort fouten die er echt toe doen.

Google Deep Review is die tweede aanpak als software. Het is een agentisch AI-systeem van Google Research dat lange, complexe documenten controleert door ze in secties op te splitsen, elke sectie parallel te beoordelen en de resultaten samen te voegen tot één rapport.

Google stelde het op 14 oktober 2026 open voor het publiek, met 2 gratis reviews per week.

In dit artikel behandel ik wat Deep Review is, hoe de pijplijn van 4 fasen werkt, wat Google's gepubliceerde resultaten laten zien en hoe je zelf hetzelfde patroon bouwt. Bekijk ook onze gids voor Gemini 3.1 Pro en onze cursus Multi-Agent Systems with LangGraph.

In een notendop

  • Deep Review splitst een document op in secties, geeft moeilijkere secties meer rekenkracht, beoordeelt elke sectie parallel met zicht op het volledige document en voegt de bevindingen samen en factcheckt ze.
  • Op een subset van de SPOT-benchmark voor wiskunde en informatica (26 papers, 29 fouten) ving Google's Paper Assistant Tool (PAT) 89,7% van de fouten, tegenover 55,2% voor Gemini 3.1 Pro op zichzelf.
  • Elke gebruiker krijgt 2 gratis reviews per week. Het accepteert alleen pdf's en platte tekst.
  • Alle nauwkeurigheidscijfers komen van Google en van auteurs die hebben ingestemd. Niemand heeft de publieke versie nog onafhankelijk getest.
  • Het controleert de redenering in je document, niet je code, dus een bug in je pijplijn kan nog steeds verkeerde cijfers opleveren die consistent lijken.

Wat is Google Deep Review?

Google Deep Review is een agentisch AI-systeem dat feedback en technische verificatie geeft op lange, complexe documenten. Het splitst een document op in secties, controleert elke sectie parallel en combineert de resultaten in één rapport.

Deep Review is eerst gebouwd voor onderzoekspapers. Google zegt nu dat het ook werkt voor ontwerpspecificaties, presentaties en juridische en financiële documenten. Je gebruikt het via het Google Research Portal, en Google kondigde het aan op het Research@-evenement.

Terug naar onze analogie: Deep Review is het team plus de eindredacteur. Het verdeelt het werk zodat elk deel zorgvuldig wordt bekeken, in plaats van je document één keer te lezen en een eerste indruk te geven.

Waarom heeft Google Deep Review gebouwd?

AI heeft schrijven goedkoop gemaakt, maar controleren is nog steeds traag en duur. Google noemt dit de validatieknoop: informatie wordt sneller geproduceerd dan rigoureus kan worden beoordeeld.

Volgens Google groeiden de gecombineerde inzendingen voor 3 grote AI-conferenties (ICLR, NeurIPS en ICML) van ongeveer 23.000 in 2023 naar ruwweg 74.000 in 2026.

Het aantal gekwalificeerde reviewers is in die periode niet verdrievoudigd. (Het cijfer voor 2026 is deels een schatting, omdat de NeurIPS-telling in Google's paper een projectie is.)

Van Paper Assistant Tool naar Deep Review

Deep Review begon als de Paper Assistant Tool (PAT). Google testte het met 4 informaticaconferenties: STOC 2026, ICML 2026, NeurIPS 2026 en ICLR 2027.

Auteurs konden zich aanmelden en vóór de deadline privé feedback op hun paper krijgen.

Meer dan 16.000 papers gingen door de pilots.

De feedback stond los van de officiële peerreview en had dus geen invloed op acceptatie.

De publieke versie voegt ondersteuning toe voor Gemini 4 Argon, wat volgens Google het systeem sterker maakt dan de oudere PAT. Google heeft ook een verwant patroon ingebouwd in Antigravity, de agentgebaseerde codeeromgeving.

Het Teamwork Deep Document Review Pattern draait met het commando /teamwork-preview.

Hoe werkt Deep Review?

Deep Review werkt als een pijplijn met 4 fasen: het splitst het document, begroot de inspanning per sectie, beoordeelt de secties parallel en voegt de bevindingen samen.

De voor de hand liggende manier om een paper met een groot taalmodel (LLM) te beoordelen is alles plakken en om feedback vragen.

Dat is de "vriend met 10 minuten" uit onze analogie. Google geeft 3 redenen waarom dat tekortschiet:

  • Het model raakt door zijn denkbudget heen voordat het de moeilijke stukken bereikt
  • Het mist afhankelijkheden tussen ver uit elkaar liggende secties
  • Het accepteert genuanceerde beweringen zonder ze te fileren

Ons team van reviewers volgt dezelfde 4 stappen als de pijplijn. Laten we elke fase doornemen.

Fase 1: Documentsegmentatie

Een segmenter-agent breekt het document op in logische delen zoals de inleiding, methoden, experimenten en bewijzen.

De delen mogen overlappen, maar samen moeten ze het hele document dekken.

In onze analogie is dit het team dat bepaalt wie welk hoofdstuk checkt voordat iemand begint te lezen. Geen enkel deel wordt overgeslagen.

Fase 2: Adaptieve compute-budgettering

Sommige secties zijn veel moeilijker te controleren dan andere.

Een lang wiskundig bewijs vraagt veel meer zorgvuldigheid dan een related work-sectie, die vooral een lijst van andere papers is.

Deep Review bekijkt hoe compact en dicht elk deel is en geeft de moeilijkere meer rekenkracht.

Google's paper beschrijft lichte, middelzware en hoge denksporen, waarbij bewijzen en theorie in het hoge spoor vallen. Als je een model met een "thinking"-instelling hebt gebruikt, is het een vergelijkbaar idee, toegepast per sectie.

Fase 3: Diepe parallelle verificatie

Vervolgens controleren reviewer-agents alle secties tegelijk. Elke agent focust op zijn eigen sectie, maar elke agent kan nog steeds het hele document zien.

Stel dat sectie 5 een resultaat gebruikt dat in sectie 2 is uitgewerkt.

De agent die sectie 5 controleert kan terugkijken of die twee overeenkomen. Een model dat alleen sectie 5 voor zich heeft, zou daar geen enkele kans op hebben.

Fase 4: Globale synthese en grounding

Tot slot speelt een synthese-agent de rol van onze eindredacteur.

Die voegt de sectierapporten samen, verwijdert dubbele opmerkingen, zoekt naar tegenstrijdigheden tussen secties en voert logische checks opnieuw uit als er twijfel is.

Hij voert ook grounding-checks uit tegen externe bronnen, waaronder Google Zoeken, om hallucinaties te vangen zoals papers of stellingen die niet bestaan.

Zonder deze stap zou de reviewer vol vertrouwen problemen kunnen markeren die niet echt zijn en je tijd verspillen.

Zo bouw je een Deep Review-achtige pijplijn in Python

Deep Review is een map-reducepatroon gebouwd met LLM-agents: verdeel het werk, controleer de stukken parallel en zet de resultaten weer in elkaar. Een eenvoudige versie bouw je in minder dan 80 regels.

Het voorbeeld hieronder gebruikt de Google Gen AI SDK met Gemini 3.1 Pro.

De thinking_level-instelling geeft ons een manier om onze eigen versie van Fase 2 te bouwen.

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()))

Maak je geen zorgen als je niet elke regel volgt. De algehele structuur is belangrijker dan de exacte code. Zo sluit het aan op de 4 fasen:

  • split_into_sections() is onze segmenter (Fase 1)
  • thinking_level_for() bepaalt de inspanning per sectie (Fase 2)
  • ThreadPoolExecutor laat de reviewers parallel draaien, en elke reviewer ziet het volledige document (Fase 3)
  • De merge_prompt aan het eind is onze eindredacteur (Fase 4)

Deze versie is veel eenvoudiger dan het echte werk. Er is geen segmenter-agent, geen check tegen Google Zoeken en geen tweede blik op onzekere bevindingen.

Hij pakt wel 2 van de 3 problemen aan die Google noemt: een tekort aan denkbudget en gemiste verbanden tussen secties.

Er zijn ook kosten om op te letten.

Elke reviewercall draagt het volledige document mee, dus het tokenverbruik groeit met het aantal secties.

De splitter ziet ook elke regel die met # begint als een kop, inclusief commentaar in codeblokken, dus test hem eerst op je eigen bestanden.

Hoe gebruik je Google Deep Review

Deep Review gebruiken kost een paar minuten instellen, daarna wacht je terwijl de agents werken.

Je eerste review instellen

Zes stappen voor het uitvoeren van een Deep Review, van inloggen tot actie op de feedback

Figuur 1: De stappen om een Deep Review uit te voeren, van inloggen tot iets doen met de feedback. Diagram door de auteur, gebaseerd op de Deep Review-pagina van Google Research.

  1. Ga naar het Google Research Portal en open Deep Review.
  2. Log in met je Google-account.
  3. Upload een pdf of plak platte tekst.
  4. Voeg optioneel aangepaste context toe om aan te geven wat het moet controleren, en stel de beoordelingsdiepte en het denkniveau in. Gratis reviews gebruiken voor beide Medium.
  5. Start de review. Google zegt dat het ongeveer 10 tot 20 minuten duurt, en langere documenten kunnen tot 30 minuten nodig hebben.

Een paar beperkingen om te weten:

  • Je krijgt 2 gratis reviews per week, en je hebt daar geen API-sleutel voor nodig.
  • Pdf's en platte tekst zijn op dit moment de enige geaccepteerde formaten.
  • Google zegt dat ondersteuning voor meerdere bestanden eraan komt, wat past bij een paper plus appendix.

Het rapport lezen

Een Deep Review-rapport naast de DeepSeek-V4.1-Flash-paper, met een overzicht en sterke punten

Figuur 2: Een voorbeeld van een Google Deep Review-rapport, getoond naast de paper die het heeft beoordeeld. Afbeelding afkomstig van: ScriptByAI, Deep Review: Google's AI Reviewer for Papers and Technical Documents.

Het rapport opent met Algemene feedback, een samenvatting, en geeft daaronder Gedetailleerde feedback.

Je kunt de gedetailleerde opmerkingen filteren op grote zorgen, kleine correcties en suggesties, en elke opmerking noemt de sectie of pagina waarnaar hij verwijst.

Er is ook een commentaarweergave en een knop Copy Report die de hele review als Markdown kopieert. Handig om in je notities te plakken en het punt voor punt af te werken.

Hoe nauwkeurig is Google Deep Review?

Google's eigen resultaten laten zien dat Deep Reviews voorganger, PAT, 89,7% van de fouten in wiskunde en informatica op de SPOT-benchmark ving, tegenover 55,2% voor Gemini 3.1 Pro op zichzelf.

De cijfers komen uit de PAT-paper, Towards Automating Scientific Review with Google's Paper Assistant Tool.

SPOT is een benchmark opgebouwd uit echte fouten in papers die later zijn ingetrokken of gecorrigeerd. Google testte PAT op de subset voor wiskunde en informatica met vergelijkings- en bewijzfouten: 26 papers met 29 fouten.

De recall van PAT lag ongeveer 34 procentpunten hoger dan de single-call-baseline.

Twee kanttekeningen zijn van toepassing.

Ten eerste gebruikten de auteurs hun eigen beoordelaar, die logisch equivalente beschrijvingen van een fout accepteert, dus je kunt deze cijfers niet direct vergelijken met de oorspronkelijke SPOT-resultaten.

Ten tweede is de paper niet consistent over het model: de tekst beschrijft PAT als aangedreven door Gemini Deep Think, terwijl de resultatentabel de 89,7% als PAT met Gemini 3.1 Pro labelt. Hoe dan ook, dit is niet de publieke Deep Review.

De pilotfeedback ziet er ook goed uit.

Google ondervroeg auteurs van de STOC- en ICML-pilots, die samen meer dan 4.700 inzendingen beoordeelden. Onder de 857 respondenten (124 bij STOC, 733 bij ICML):

  • 92,7% van STOC en 90,7% van ICML vond de feedback zeer of meestal behulpzaam
  • Ongeveer 1 op de 10 STOC-auteurs en meer dan 1 op de 3 ICML-auteurs (35,4%) zei dat er een significant theorieprobleem werd gevonden dat meer dan een uur kostte om te fixen
  • 31% van de ICML-respondenten draaide nieuwe experimenten vanwege wat PAT aangaf

Dat laatste cijfer viel me op.

Extra experimenten draaien vlak voor een deadline is een flinke stap, dus de feedback moet overtuigend zijn geweest.

Toch komen al deze cijfers van Google en van auteurs die kozen om mee te doen, en niemand heeft de publieke Deep Review nog onafhankelijk getest. Zie ze als een veelbelovend signaal, geen bewijs van hoe het op jouw documenten zal presteren.

Hoe kunnen data scientists Deep Review gebruiken?

Je hoeft geen wiskundige bewijzen te schrijven om Deep Review nuttig te vinden.

Veel van wat data scientists en analisten schrijven is een reeks beweringen onderbouwd met cijfers, en dat is precies wat Deep Review controleert.

Hier zijn een paar plekken waar het volgens mij logisch is:

DocumentWat Deep Review kan helpen controleren
AnalyserapportenOf elke conclusie wordt ondersteund door een getal in het rapport
A/B-testverslagenZwakke statistische claims, of steekproefgroottes die tussen secties veranderen
ML-ontwerpspecificatiesPlaatsen waar de architectuursectie en de evaluatiesectie niet overeenkomen
NotebookverslagenDe toelichting rond je resultaten (exporteer het notebook eerst als pdf)

Google beschrijft Deep Review als het controleren van de redenering in je document. Het zegt niets over het uitvoeren van je code, dus een bug in je pijplijn kan je nog steeds achterlaten met verkeerde cijfers die perfect consistent lijken.

Een goede workflow ziet er zo uit:

  1. Maak eerst een volledige draft af. Een halve tekst reviewen kost je één van je 2 wekelijkse reviews.
  2. Draai Deep Review en controleer elke grote zorg zelf voordat je iets verandert.
  3. Fix wat echt een probleem blijkt, en draai het opnieuw als je nog een review over hebt.

Om het in je eigen tools te gebruiken, kun je met de Deep Review API reviews vanuit code draaien, bijvoorbeeld als onderdeel van een continuous integration (CI)-pijplijn.

Je koppelt je eigen Gemini API-sleutel, dus het gebruik wordt via je Gemini API-account gefactureerd.

Kosten hangen af van documentlengte en redeneerinspanning, dus test het op één document voordat je eromheen gaat bouwen.

Beperkingen van Google Deep Review

De grootste beperking is dat Deep Review in beide richtingen fout kan zitten.

De PAT-paper zegt dat de pilots gevallen aan het licht brachten waarbij de tool een correct bewijs ten onrechte als onjuist bestempelde door een redeneerfout, en de auteurs zeggen dat ze daar nog aan werken.

Grounding is het andere cijfer om in de gaten te houden.

Slechts 55,8% van de STOC-respondenten en 64,8% van de ICML-respondenten zei dat de feedback meestal of volledig gegrond was, dus grofweg 35% tot 44% vond het niet meestal gegrond.

Check elke grote zorg tegen je document voordat je erop handelt.

Het doet ook geen waardeoordelen.

Het vertelt je niet of je idee nieuw of interessant is, en het rangschikt geen papers. Dat deel is nog steeds aan jou en je reviewers.

Dan is er nog privacy.

Google zegt dat het nooit geüploade documenten gebruikt om zijn modellen te trainen, te fine-tunen of te verbeteren, maar het bewaart ze 1 jaar zodat je ze in de interface kunt zien.

Als je aan iets werkt onder een non-disclosure agreement (NDA), zou ik twee keer nadenken voordat je het uploadt.

Een paar andere beperkingen:

  • Het is een gesloten systeem zonder open gewichten en zonder mogelijkheid om het zelf te hosten, dus je bent volledig afhankelijk van Google's modellen
  • Het accepteert vooralsnog alleen pdf's en platte tekst
  • 2 gratis reviews per week zijn zo op als je veel wijzigingen aan een draft doorvoert
  • Elke nauwkeurigheidsmeting tot nu toe kwam van Google

Tot slot

Deep Review lijkt meer op ons team van reviewers dan op de vriend met 10 minuten. Ik denk dat je het het beste gebruikt als een extra pass over je draft voordat je indient, waarbij je elke grote zorg zelf checkt.

Het markeert dingen die geen echte problemen zijn; het kan niet beoordelen of je werk vernieuwend is, en de nauwkeurigheid moet nog door mensen buiten Google worden getest.

Het ontwerp is het deel om mee te nemen. Het werk opsplitsen, de moeilijke delen meer aandacht geven, alles parallel controleren en de resultaten samenvoegen werkt in vrijwel elke agent die lange documenten moet verwerken.

Als je graag dit soort agents bouwt, raad ik je aan onze cursus Multi-Agent Systems with LangGraph te bekijken.

Google Deep Review FAQ's

Is Google Deep Review gratis?

Ja, iedereen krijgt 2 gratis reviews per week. Als je er meer nodig hebt, kun je je eigen Gemini API-sleutel koppelen.

Welke bestandstypen accepteert Deep Review?

Op dit moment alleen pdf's en platte tekst. Google zegt dat ondersteuning voor meerdere bestanden eraan komt.

Trainen Google's modellen op mijn documenten?

Nee. Google zegt dat geüploade documenten nooit worden gebruikt om zijn modellen te trainen, te fine-tunen of te verbeteren. Ze worden 1 jaar opgeslagen zodat je ze in de Deep Review-interface kunt bekijken.

Is er een Deep Review API?

Ja. De Deep Review API draait op je eigen Gemini API-sleutel, zodat je reviews vanuit je eigen code kunt uitvoeren, bijvoorbeeld in een CI-pijplijn.

Hoe lang duurt een Deep Review?

Google zegt rond 10 tot 20 minuten per document. Langere documenten met veel wiskunde krijgen meer rekenkracht, dus die kunnen tot 30 minuten duren.

Hoe nauwkeurig is Google Deep Review?

Op een subset van de SPOT-benchmark voor wiskunde en informatica ving Google's voorgangerstool PAT 89,7% van de fouten, tegenover 55,2% voor alleen Gemini 3.1 Pro. Deze resultaten komen van Google en zijn niet onafhankelijk getest op de publieke Deep Review.

Vaibhav Mehra

Auteur

Vaibhav Mehra

Onderwerpen

Gerelateerd