Document detail

In one line. The single-document page where a person reads one document and reviews, corrects, and signs off on what the agent extracted. You’ll be able to. Open any document, navigate its pages, read every extracted field next to its source, fix a wrong value, and advance the document through its review stage. Where this lives. Consumer app — open any document from the list; route /{subscription}/{project}/:docId.

Why it matters

The document table (Document workspace) is the list. This page is the work. It is where the human-in-the-loop part of “AI recommends, two humans confirm” actually happens: a person opens a document, sees the agent’s extracted fields side-by-side with the original, corrects anything wrong, and pushes the document forward in its lifecycle. Every correction you make here is also a teaching signal — it is the raw material the trained models under Studio ▸ Agents ▸ Classic ML later learn from. Get comfortable here; it is the page your reviewers will live in.

The route

You navigate to…	URL shape	Opens at…
A document	`/{subscription}/{project}/:docId`	the document, first page
A specific page	`/{subscription}/{project}/:docId/:pn`	page `:pn`
A specific segment	`/{subscription}/{project}/:docId/:pn/:segId`	page `:pn`, scrolled to segment `:segId`

The deeper forms are how deep-links work. When chat cites a source (Chat & search) or you click an extracted field, the platform builds one of these URLs so the document opens exactly on the relevant page or segment — not just “the document somewhere”.

Watch out. If a document has been deactivated, or your access does not include it, the page refuses to open rather than showing you a blank viewer. That is expected.

The layout

The page is a split view: the document itself on one side, everything the agent produced on the other. A draggable divider (the resizer) sets the balance; you can collapse either side to focus.

DOCUMENT DETAIL — split view  (/{subscription}/{project}/:docId)
+--------------------------------------------------------------------------+
| Back  [Invoice_001 v][Invoice_002]  find  < Page 3 of 12 >  ...  more     |  <- doc header
+---------------------------------------+----------------------------------+
| DOCUMENT PANE  (viewer / annotator)   | SUMMARY PANE                     |
|  +---------------------------------+  |  [Summary][Training][Page Prev]  |  <- tabs
|  | PDF / HTML / docx / xlsx / image|  |  filter v                        |
|  | ## highlighted extraction ##    |<-+-> Vendor     : Acme Corp  ->seg  |  <- click field
|  | (click a field -> it scrolls &  |  |   Invoice No : INV-001    ->seg  |     jumps the
|  |  highlights its source here)    |  |   Total      : $1,240.00  (edit) |     viewer
|  |                                 |  |   Date       : 2026-06-11        |
|  +---------------------------------+  |  > per-doc dashboard widgets     |
|  [workflow stepper / action pane]     |                                  |  <- stage advance
+---------------------------------------+----------------------------------+

Tip. Some projects show the summary on the left and the document on the right. The panes do the same job either way — only the side changes. Some projects swap them in the list view too; both are intentional.

Around the split you may also see, when the project enables them:

A thin document info bar across the top with title and metadata.
A Doc-Set sidebar when this document is part of a Doc Set — a group of documents treated as one (see Document workspace).
An in-page chat pane and a collapsible doc-search results strip (covered under the Summary tabs and Chat & search).
For “generated content” collections, a rich-text editor instead of a read-only viewer.
For documents whose collection renders a dashboard, that dashboard appears in place of the viewer.

This page teaches the common case — a real document in a Processing collection. The specialised renderers are called out where they appear.

Tip. A solution can also compose its own document page from document workbench cards on an experience page — including a native summary-pane card with the same review loop (inline edit, comments, formula fields) and a per-card skin. See Pages & cards. Same values, same save paths; only the layout is yours.

Document pane — the viewer

What every control does

The pane has a header row of controls and a viewer body that changes with the file type.

Control	What it does	Notes
Back / Close	Return to the document list, or close an embedded view
Document tabs	Pinned documents as tabs, with an overflow menu of the rest	Lets you flip between several open documents without going back to the list
Copy DocId / Title	Copies the document’s id or title to the clipboard	Handy for support tickets and deep-links
In-doc search	Find text inside this document	Can be switched off for a project
Audit trail (clock icon)	Opens the document’s timeline side-sheet — everything that ever happened to this document	Also in each row’s ⋮ menu on the list; see “Advancing the lifecycle” below
Prev / Next	Move to the previous/next document in the list	Can be locked until you complete the current one — a deliberate “finish before you move on” guard
Page selector	A “Page X of N” dropdown you can type into to jump	The fastest way around a long PDF
Page up / down	Step a page at a time	Used in image/annotation mode
Add Document	Upload another document into the collection without leaving
Similar Documents	Shows documents like this one	Can be switched off for a project
Document Chat toggle	Opens the in-page chat about this document	See Chat & search
Workflow collapse/expand	Show or hide the stage/action stepper	See “Advancing the lifecycle” below
Highlight-Copy toggle	Lets you select-and-copy highlighted regions
Training Mode toggle	Switches into the correct-and-teach annotation mode	Feeds the trained models under `Studio ▸ Agents ▸ Classic ML`
More Options (tune)	Annotation-mode and viewer options
Expand / Minimize	Give the viewer the whole width, or shrink it back

Watch out. Similar Documents, in-doc search and the floating agent-chat widget can each be switched off for a project. If you don’t see one, ask your administrator — it is a choice someone made, not a fault.

File-type dispatch

The viewer picks a renderer from the file type — you don’t choose it:

File type	Renderer	What you get
PDF, HTML, or a structured record	The annotator	Page view with highlightable, clickable segments
`.docx`	Docx viewer	Rendered document
`.xlsx`	Spreadsheet viewer	Rendered sheet
Image (png/jpg/…)	Image viewer, plus a thumbnail rail in annotation mode	Zoomable image with page thumbnails
Unsupported	Not-found message plus Download	Always at least downloadable

The PDF/HTML annotator is the one to know. Its page is divided into segments — the highlightable blocks the platform parses the document into. Each extracted field is anchored to one of these segments, which is what makes the next part work.

Deep-link highlight — the field-to-source link

This is the single most important interaction on the page:

In the Summary pane, click an extracted value — say Total : $1,240.00.
The viewer scrolls to the exact segment that value came from and highlights it.

The highlight is colour-matched to the field. The reverse is also wired: opening the page at /:docId/:pn/:segId lands you on that segment directly. This is how a reviewer verifies an extraction in one click instead of hunting through twelve pages — the agent shows its work.

Tip. Always click through a few fields to their source before approving a document. The highlight tells you where the agent read the value, which is the fastest way to catch a mis-read (e.g. it grabbed a subtotal instead of the grand total).

Behaviours to know (viewer)

Loading skeleton. The viewer shows a skeleton until the file is ready; large files take a moment.
Completion lock. When Next is locked, finish the current document’s required action first — the lock releases when the stage advances.
Live updates. If you open a document while it is still Processing…, the viewer and fields fill in as the agent finishes — you do not need to refresh.

Summary pane — reading and correcting extracted data

This is where the agent’s output lives, in a tabbed pane. The fields you see here are defined by the collection’s schema — Collections & schema.

Tab	What it shows	When it appears
Summary	The extracted-field list — every label key → value, each anchored to a source segment	Always
Training	The correct-and-teach annotation surface (with a “create taxonomy” empty state if no schema exists yet)	In Training Mode
Page Preview	The document’s pages grouped by the labels found on them	When enabled
Custom dashboard tab(s)	Per-document dashboard widgets you (or an admin) pin in	When the project defines per-doc dashboards

Custom dashboard tabs are pinnable and, for admins, editable — rename, set auto-refresh, add a widget, save. The tab’s overflow menu offers a picker to choose or create a dashboard, and edit/delete (admin only).

The extracted-field list (Summary tab)

At the top is a filter box to narrow a long field list. Below it, each field is one row showing the field name, its value, and a link back to its source segment. Where the platform reports a value as low-confidence or mismatched, it is flagged so your eye goes straight to the fields that need a human.

Every extracted value carries a confidence score. That score is what marks a field “needs review” and what routes a whole document to the Inbox queue — the extractor sets it, you don’t. It is why some fields shout for attention and others don’t. See Core concepts.

The review-and-correct loop

This is the core task of the page:

Read the flagged (low-confidence) fields first — they’re the ones the agent is unsure of.
Verify each by clicking its value to highlight the source in the viewer.
Correct a wrong value by editing it in place; your edit saves back to the label.
Re-derive dependent values when needed: Update Lookup Values recomputes lookup-driven fields, and Rescore re-runs scoring against the corrected data. (These also live in the list-view overflow menu for bulk use — see Document workspace.)
Advance the document once you’re satisfied (next section).

Every correction is captured. Beyond fixing this document, those corrections are the labelled examples the trainable extraction model (the “AI Model”, distinct from the language model) learns from — so the agent extracts that field better next time. Training Mode (the viewer toggle and the Training tab) is the dedicated surface for doing this deliberately. The full training loop — how corrections become a better model, and how to read prediction reports — is Studio ▸ Agents ▸ Classic ML.

Watch out. A Viewer gets a read-only summary — they can read every field but cannot edit, correct or advance. Editing requires a Reviewer (or a role above it). If your fields won’t edit, check the access you hold before assuming a fault.

Below the field list, per-document dashboard widgets render any collection-defined metrics for this one document.

Advancing the lifecycle — the action pane

A Processing document doesn’t just get read — it gets moved through its review stages (Intake → AI Processing → AI Recommendation → L1 Review → L2 Approval → Approved/Declined; see Taxonomy & lifecycle). The page surfaces this as a workflow action pane — a stepper down one side, shown in full-focus mode or whenever the document’s stage is configured for it.

From the action pane a reviewer performs the stage transition — the platform’s word for “approve and send to the next stage”, “send back / Needs Info”, or “reject”. Which actions you see depends on:

The stage the document is in (an L1 reviewer sees different choices than an L2 approver).
The access you hold (each transition is gated — this is the “two humans confirm” rule made real).

Every transition is written to the document’s audit trail, so the decision history is always readable there. Advancing a document is exactly how it leaves your Inbox review queue (Dashboards & inbox) — the Inbox is a collection of documents waiting at a stage, and acting here removes it from that queue.

Reading the audit trail

The Audit trail button (clock icon in the document header; also in a row’s ⋮ menu on the list) opens a side-sheet timeline of everything that happened to this document — uploads, agent runs, human edits, stage moves, downloads.

Events are grouped into five phases, in lifecycle order: Ingestion, Automated processing, Human review, Output and Error. The phases appear as pills across the top, and a phase with no events simply isn’t shown — a short pill row means a short story, not a broken filter. Each event is attributed to its actor (human / agent / system / API key) and expands to show before/after detail.

The two filters are those phase pills and the actor toggles (Human, Agent, System, API key). Both change what is visible; neither changes the total the sheet loaded.

If you are leaning on this sheet as evidence, two honesty points:

The sheet loads up to 500 events. When you export it to CSV and the trail was longer than that, the export says so.
If one of the systems of record could not be reached, a banner reads “Timeline may be partial — source unavailable: …”. Treat the trail as incomplete while that banner is up. When everything was reachable, the footer reads “All sources healthy”.

External systems can pull the same trail over the Runtime API.

Watch out. Stage transitions are the consequential clicks on this page. Reject and Approve are usually irreversible by you (they hand the document to the next stage or close it out). Verify your corrected fields before you advance, not after.

Action	What it does	Notes
Download	Download the original file	Can be switched off for a project
Export	Export this document’s extracted data	Bulk export is in the list overflow menu
Reprocess / Rescore	Re-run extraction / re-score against the current schema	Use after a schema change or a correction
Document Chat	Ask questions about this document	Chat & search
Similar Documents	Find look-alikes	Can be switched off for a project

Behaviours to know

Live as it processes. Open a still-processing document and watch fields appear and the progress settle without a refresh — the page streams updates.
Everything is gated. Tabs, action buttons and even editability depend on what the project enables and on the access you hold. “I don’t have that button” usually means “not enabled, or not mine to use”, not “broken”.
Empty / processing states. Each pane shows a skeleton until the document loads; Training Mode shows a create-taxonomy empty state when the collection has no schema yet.
Guided tour. Some projects attach a walkthrough that points out these controls the first time you arrive.

Try it yourself

On a Processing collection with at least one extracted document:

From the document list, click any row to open it at /{subscription}/{project}/:docId.
In the Summary tab, find a field and click its value — confirm the viewer scrolls and highlights the source segment.
Use the page selector to jump to “Page X of N”, then come back.
Pick a low-confidence (flagged) field, click through to verify it against the source, then edit the value and watch it save.
Run Rescore (or Update Lookup Values) and note any dependent fields change.
Open the Audit trail side-sheet: read the phase pills, toggle Agent off and on, and check the footer for the source-health line.
Open the workflow action pane and read — don’t necessarily click — the available stage transitions. Notice they match the document’s current stage.
(Optional, if you review on a test document) advance the document one stage and confirm it leaves your Inbox.

Recap

The Document Detail is a split view: the document pane (viewer/annotator) and the summary pane (extracted data).
The viewer dispatches by file type (PDF/HTML annotator, docx, xlsx, image, or download-only) and supports page navigation, segments, and deep-link highlights.
Clicking an extracted field highlights its source segment — the agent shows its work; the reverse /:docId/:pn/:segId deep-link lands you on a segment directly.
The Summary tab lists every extracted field with its value, source link, and confidence flag; you edit in place to correct, and Rescore / Update Lookup Values re-derive dependents.
Corrections feed the trainable model — Training Mode here, the full loop under Studio ▸ Agents ▸ Classic ML.
The action pane performs stage transitions (stage- and access-gated, audit-logged), which is how a document advances its lifecycle and leaves the Inbox.
The Audit trail button opens a per-document timeline side-sheet — five phases, actor-attributed, before/after detail, up to 500 events, with a banner when a source could not be reached.
Almost everything depends on what the project enables and the access you hold, and the page updates live as processing finishes.

Where to go next

Chat & search — ask questions over documents and follow the citations that deep-link straight back to this page.
Dashboards & inbox — the review queue that feeds this page.
Taxonomy & lifecycle — design the stages the action pane advances through.
Trained models — Studio ▸ Agents ▸ Classic ML, where your corrections become a better model.