Answers that hold up when someone checks them
Most document AI answers a question by searching once and writing from whatever came back. docAnalyzer searches, reads what it found, and searches again as many times as the question needs, then attaches every claim it makes to the exact place in your document it came from.
That difference is the whole product. If you are being asked to sign off on the output, here is what is happening underneath it.
Why one search is not enough
Search quality is not the weak link. Document search now matches on meaning rather than on exact wording, so asking how much notice you need to walk away will surface the termination clause even though you never used that phrase. When a question names its own target and the answer sits in one place, one search finds it, and everything after that is just the model writing.
The limit is elsewhere. A single search has to decide what to look for before it has read anything, and it gets one set of results to work with.
That falls apart on the questions practitioners actually get paid for. "Which of these agreements deviate from our standard indemnity language" means reading the standard first, because until you have, you do not know what to look for. "Does the risk section contradict management's own discussion of results" means holding two parts of a filing side by side. "What changed between the 2023 and 2024 filing" means finding the same clause twice and comparing it.
None of those are search problems. They are read-then-search-again problems, and no improvement to the ranking fixes them, because the second query was never issued. The failure is quiet: you get a fluent answer built on whatever the one query happened to reach.
The search runs until the question is answered
Focus chat is the mode where you point the assistant at a chosen set of documents and work inside them. It is one of three ways to chat in docAnalyzer, and it is the one built for digging.
Ask it a question and it does not run one search. The assistant searches, reads what came back, works out what is still missing, and searches again, carrying its reasoning from each round into the next instead of starting clean. It can build files while it goes, so a long piece of analysis accumulates work rather than arriving as one block of prose at the end.
This is what agentic means in practice: the assistant chooses its own next step instead of following a fixed script. The consequence that matters is that it is not stuck with whatever the first search happened to return.
| Retrieve then generate | docAnalyzer | |
|---|---|---|
| Searches per turn | One | As many as the question needs |
| Sees its own results before deciding what to look for next | No | Yes |
| Reasoning between steps | Discarded | Preserved across rounds |
| Can read a section in full after finding it | No, only the retrieved excerpt | Yes |
| Produces files during the turn | No | Yes, and reusable in later turns |
Every claim points back to where it came from
When docAnalyzer states something, it attaches a reference to the location that supports it, and the interface turns that reference into a link. Click it and the viewer opens the source at that spot: the page of a PDF, the section of a report, the row in a spreadsheet.
Underneath, that reference is a plain-text token in the answer body rather than prose. A PDF gets PAGE!12, and so does a Word file, a slide deck, or an EPUB. A Note or a plain text file gets SECTION!3, and a spreadsheet PATH!sheet[0]. When you are working across several documents at once, the reference also says which one: SOURCE_2_PAGE!12. The chat hides all of this and shows you a link. Through the API you get the tokens verbatim, which means a citation can be checked by a machine and not only by eye.
That is the distinction worth understanding. The model is not writing "see page 12" into a sentence and hoping. It emits a token the application resolves, so the link lands somewhere real rather than somewhere plausible. Models are good at sounding certain about page numbers. This design does not ask them to be.
Making that land reliably is mostly unglamorous work done at upload. Each document is indexed along whatever structure it already has: page-based documents, which is most of what people upload, by page; plain text and Notes by heading; spreadsheets and data files by location in the sheet. That map is worked out once and kept as the single record used for both searching and citing, so the thing the assistant searched and the thing your link opens are the same piece. Your original file is kept exactly as you sent it and is never altered.
The edge cases are where it gets real. Regulatory filings repeat their headings: a 10-K annual report can carry several sections all headed "Item 7". Number those in the obvious way and your citations start pointing at the wrong one, which nobody notices until an auditor does. Repeated headings are told apart before the document is cut, so the numbering stays stable between what was filed away and what your link opens.
Changing the model does not change the grounding
docAnalyzer is not tied to one AI vendor. You pick which model answers, and you can change it in the middle of a conversation, say from Anthropic's Claude Opus to OpenAI's GPT to Google's Gemini. The chat does not restart and the work already done in that answer is not thrown away. If the model you picked is busy or unavailable partway through, another one takes over and the answer keeps going rather than failing in front of you.
What matters for trust is what does not move. Retrieval, the indexing, the tools, and the citation discipline run on our infrastructure regardless of which model answers. Changing the model changes the writing. It does not change what the answer is allowed to be grounded in.
Structured output is checked before you see it
When an answer has to come out as a file with a fixed shape, a spreadsheet, a PDF, a web page, the file is checked against that shape before it reaches you. One that does not hold up gets rebuilt, and if it keeps failing the job moves to a different model rather than handing you something broken.
This is a deliberate choice about where to put the guarantee. Telling a model in its instructions to produce valid output is a request. Checking the file afterwards and rejecting it if it is malformed is a rule. The rule holds on the days the request does not.
The conversation gets the same treatment. Any AI model can only hold so much text at once, so a long thread eventually has to shed some of it. docAnalyzer sheds by a fixed rule, oldest and least useful material first, rather than pausing to have a model summarize your conversation back to itself while you are still working in it.
Where this does not help
Worth knowing before you commit a corpus to it.
Scanned quality sets the ceiling. Reading text off scans happens free on upload, covers 40+ languages, and handles clean typed scans well. Handwriting, low-resolution scans, and dense multi-column layouts are harder, and no amount of search quality makes up for text that was read wrong at the start. When that first pass falls short you can run a higher-accuracy one on the document yourself, which is what it is there for. It costs a credit per page and is charged whether or not the result comes out better, which is the honest trade on pages that were difficult to begin with. A citation that opens on nothing, or quotes something that is not there, is usually the sign you need it.
Files built in a chat live with that chat. They stay available for as long as that chat does, up to a limit per chat. Download anything you want to keep.
Reading images is capped per question and needs a model that can look at pictures, not only read text. It is there for figures and diagrams inside your documents, not for processing images in bulk.
Documents are read-only once uploaded. Editing happens in Notes, which are your own writable documents in the workspace, not in the file you uploaded. The source stays as filed, which is the point when the output has to be defensible, and it means docAnalyzer is not a PDF editor.
The short version
Retrieval that runs as many times as the question needs. Citations that resolve to a location instead of asserting one. A check on structured output that runs whether or not the model cooperated. Named limits where they exist.
That covers whether the answer holds. What you walk away with is the other half: any turn can build a spreadsheet, a PDF, a chart, or a bundle, and those files accumulate across a session. What docAnalyzer produces covers that side.
If you want to see it against your own documents, the Community plan does not need a card.