Deep Brushes

A Deep Brush is a multi-step research workflow you run on a single memo section inside Canvas. Unlike a one-shot edit, a Deep Brush spends two to three minutes iteratively searching your deal’s source documents, cross-referencing the section’s claims against the evidence, critiquing its own coverage, and then synthesizing what it found into a structured findings panel. You watch it work in real time, and the findings persist so you don’t lose them if you close the tab.

Deep Brushes are invoked by you, on demand, in Canvas only. They never fire automatically during memo generation in the worker pipeline — the analysis the worker does to first draft the memo is a separate path. A Deep Brush is a deliberate, second-pass tool you reach for when a section matters enough to scrutinize.

The six Deep Brush types

There are exactly six Deep Brush types , each tuned to a different editorial intent:

Brush	What it does
Audit	Cross-references the section’s claims against the source documents and flags factual errors, unsupported claims, and missing data. The default.
Enrich	Weaves in additional specifics from the source documents — figures, dates, and context the section is missing.
Quantify	Hunts for hard numbers to replace vague or qualitative language.
Compliance	Checks the section for regulatory and covenant compliance gaps and missing disclosures.
Compare	Performs a side-by-side comparison against a second section you select, surfacing contradictions and numerical discrepancies between the two.
Deal Structure	Scrutinizes the structural and financial logic of the section — math errors, cross-section conflicts, and structural inconsistencies.

Note

The Compare brush is the only one that needs a second input. When you run it, you must pick a second section — Canvas sends both that section’s key and its content alongside the primary section. The other five brushes operate on a single section.

Deep Brushes vs. the quick brushes

Canvas also has a set of lighter, single-pass “brushes” that act on a text selection or a whole section and return immediately — for example, adding [SRC:n] citations to a selection, or running a quick editorial improvement pass. Those are the fast, inline tools.

Deep Brushes are different: they are full LangGraph mini-workflows with their own research budget, an iterative search loop, and a self-critique stage. When this page says “Deep Brush,” it means the multi-minute research workflow — not the quick inline brushes.

How to run one

1. Open the deal in Canvas and place your cursor in (or select) the section you want to work on.
2. Choose a Deep Brush type. For Compare, also pick the second section.
3. Canvas opens a live progress stream and the brush begins.

Running a Deep Brush requires the Editor role on the deal — viewers and commenters cannot invoke one. See roles and permissions for how deal roles work.

Caution

A Deep Brush will not run on an approved section. If the section has been approved, Canvas returns a clear message asking you to revoke approval first. Reopen the section for editing, run the brush, then re-approve. This protects approved content from being silently reworked. See the approval gate for how approval interacts with the rest of Canvas.

What you see while it runs

The brush streams its progress to you live, stage by stage, so a two-to-three-minute run never feels like a black box. Internally it moves through six stages:

1. Assembling context — loads the deal’s data, the relevant memo sections, and any findings from prior runs on this section.
2. Planning research — reads the section and decides which claims need verification, producing a prioritized set of search queries.
3. Searching — runs those queries against the source documents and gathers evidence. As soon as a finding is identified, it appears in your panel.
4. Reviewing completeness (self-critique) — the brush grades its own coverage and decides whether gaps remain.
5. Consolidating — synthesizes everything into a structured report with categorized findings and suggested fixes.
6. Saving — persists the findings.

Each progress event carries a stage label, a short message, the current search cycle, and a countdown estimate of time remaining. Findings stream in individually as they’re discovered, each with a type, a severity (high / medium / low), the claim text, the supporting detail, and — where applicable — a suggested fix.

The self-critique loop

The defining feature of a Deep Brush is that it checks its own work before it finishes. After the first search pass, the self-critique stage reviews the findings, scores how complete the research is, and lists any high-priority claims still unverified. If meaningful gaps remain, the brush loops back and runs a second, gap-targeted search round. If coverage is sufficient, it proceeds straight to synthesis.

This loop is bounded: the brush runs the initial search pass plus at most two critique loops , for a maximum of three search cycles. That ceiling keeps a run from chasing diminishing returns forever, and the cycle counter you see in the progress stream reflects exactly where it is in that budget.

The whole workflow runs under a hard time budget of 180 seconds . If it hits the budget before finishing, it stops gracefully and hands you the findings it has already collected rather than failing outright.

Where findings are saved

Findings are persisted to Redis, keyed by deal, section, and brush type, capped at 50 records per key and held for seven days . Two design choices make this resilient:

• Findings save incrementally. As each finding is discovered mid-run, it is written immediately — not held until the end. So even if a run times out or the connection drops, the findings already surfaced are still saved.
• Reconnect recovery. If your live stream drops, Canvas can fetch the most recently persisted findings for the section and render them at once, without re-running the entire brush. Duplicate findings are de-duplicated by their text, and the newest copy wins.

If a storage error prevents persistence, the completion event tells you so explicitly: the findings are still visible in your current session, but you’re warned they may not survive into a future one.

From finding to edit

Findings land in a panel attached to the section. Where a finding carries a suggested fix, you can apply it as a suggestion in the editor — the same suggestion mechanism described in editing and AI suggestions — and a finding can also be promoted into a comment for a collaborator to weigh in on. Nothing a Deep Brush surfaces is applied automatically; you remain in control of every edit.

Sources

• src/canvas/routes/deep_brush_routes.py — the /canvas/{deal_id}/deep-brush/{section_key} endpoint, the six-type _VALID_DEEP_BRUSH_TYPES set, the Editor-role gate, the approved-section block, the SSE wire contract, and the reconnect-recovery latest-findings endpoint.
• src/canvas/deep_brushes/orchestrator.py — the six-node LangGraph workflow (assemble_context → plan_research → deep_search → self_critique → synthesize → persist_findings), the DeepBrushConfig budget knobs (180 s total, max 2 critique loops, 50 findings, 7-day TTL), the per-brush prompt registry, and incremental persistence.
• src/canvas/models/plan_tier.py — the DEEP_BRUSHES feature flag.
• memory/brush_system_v2.md — context distinguishing the quick selection/section brushes from the Deep Brush mini-workflows and the Redis findings persistence model.