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 /<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 AI Builder later trains on. Get comfortable here; it is the page your reviewers will live in.

Under the hood. The code calls this the Campaign page (modules/documents/pages/campaign-page/). You will never see that word in the UI — we call it the Document Detail.

The route

You navigate to…	URL shape	Opens at…
A document	`/<project>/:docId`	the document, first page
A specific page	`/<project>/:docId/:pn`	page `:pn`
A specific segment	`/<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. Access is guarded (DocumentAccessActiveGuard). If a document has been deactivated or you lack the role to see it, the page refuses to load rather than showing a blank viewer. That is expected, not a bug.

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  (/<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. If the panes feel backwards (summary on the left), your project has the SwapSummaryAndDocumentPane option set. The function of each pane is unchanged — only the side. Some projects also swap them in the list view; both are intentional.

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

A thin document info bar across the top (document-info-bar) with title/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 entity-dashboard documents, a dashboard renders in place of the viewer.

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

Under the hood. A solution can also compose its own document page from document workbench cards on an experience page — including a native summary-pane card (no iframes, per-card skins, and the same review loop: inline edit, comments, formula fields) — 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	Appears when the DocumentSearch action is enabled
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 (`documentCompletionLock`) — 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	Only with `EnableSimilarDocuments`
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 trainable model — AI Builder
More Options (tune)	Annotation-mode and viewer options
Expand / Minimize	Give the viewer the whole width, or shrink it back

Flag-gated. Similar Documents (EnableSimilarDocuments), in-doc search (DocumentSearch), and the floating agent-chat widget (ShowFloatingChat) each appear only when their option is set on the project. If you don’t see one, your project hasn’t enabled it.

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, structured-row	The annotator (`html-panel`)	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 (a segment-colour pipe drives it). 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 URL 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 an “app store” to pick or create a dashboard, and edit/delete (admin only).

The extracted-field list (Summary tab)

At the top is a filter box (search-filter) 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.

Under the hood. Every extracted value carries a confidence score (0..1, stored in document_attributes). That number is what marks a field “needs review” and what routes a whole document to the Inbox queue. You don’t set it — the extractor does — but 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 LLM) 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 AI Builder.

Role-gated. A subscription-viewer role gets a read-only summary — they can read every field but cannot edit, correct, or advance. Editing requires a reviewer/annotator role. If your fields won’t edit, check your role before assuming a bug.

Below the field list, per-document dashboard widgets (widgets-pane) 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 (left-action-pane / right-action-pane), 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).
Your role (each transition is role-gated — this is the “two humans confirm” rule made real).

Every transition is written to the document’s audit trail; a “decision” is simply read back from that trail (there is no separate decision object). 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.

You can read that whole story yourself: 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 — grouped by phase (ingestion, automated processing, human review), each event attributed to its actor (human / agent / system / API key) with expandable before/after detail and filters. 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 disabled per project (`Enable/Disable Download`)
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	Flag-gated

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 selectedBot.* flags and your role. “I don’t have that button” usually means “not enabled / not my role”, not “broken”.
Empty / processing states. Each pane shows a skeleton until selectedDoc loads; Training Mode shows a create-taxonomy empty state when the collection has no schema yet.
Guided tour. Some projects attach a walkthrough (<app-tour>) 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 /<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 workflow action pane and read — don’t necessarily click — the available stage transitions for your role. Notice they match the document’s current stage.
(Optional, if you have a reviewer role on a test document) advance the document one stage and confirm it leaves your Inbox.

Recap

The Document Detail (/<project>/:docId, code name Campaign page) 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 re-derive dependents.
Corrections feed the trainable model — Training Mode here, the full loop in AI Builder.
The action pane performs stage transitions (role- and stage-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 — phase-grouped, actor-attributed, with before/after detail.
Almost everything is flag- and role-gated and 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.
AI Builder — where your corrections become a better model.