The investigation recipe: from sources to a cited case

Your company is about to sign a three-year contract with a supplier, Taeyang Components, and someone has to answer one question: can we rely on this partner? The material is already scattered around you: an audit PDF, two years of meeting notes, a few news articles, a factory address in Ulsan, and a rumor about who really owns their upstream supplier. This is an investigation, and most people run it out of browser tabs and memory.

This lesson pulls everything you've learned into one repeatable recipe: the ontology-agent-workspace workflow. Sources go in, entities emerge, a case gives the question a home, and the network grows one verified connection at a time. Places land on a map. Your claims and evidence become first-class statements, and the write-up cites its way back to your own notes. None of this is new machinery. The recipe is the order you do things in, and the habits.

Stage 1: flood the workspace, let entities emerge

Every investigation starts as a document dump. Resist the urge to organize first. Drop the material into your workspace and let extraction do the sorting. As each note is saved, background extraction reads it, and the people, organizations, and places inside become entities in the knowledge graph. No tagging, no folder taxonomy. If you've got a pile of untouched documents, the activity center offers the bulk route: "Build this workspace's knowledge graph?" with a "Build" button.

• Files you already have. Drop them in the workspace and let per-note extraction (or the bulk offer) build the graph from them.
• The open web. Type /research followed by your topic, or press ⌘⇧R. Deep research scopes the question, fans out searches, and writes one document per source into a research/ folder, where they get extracted into the graph like any other note.
• One-off context. Chat attachments (paperclip, drag-drop, paste) feed a single conversation, but the graph only grows from what lives in the workspace. If a document matters to the investigation, it belongs inside.

Stage 2: interrogate, then pin the chat as a case

Open the first interrogation. Start a "New chat" (⌘⇧C), ask broad questions, and @-mention the key entities so their live profiles ride along. Watch the answers as they come. Every workspace search draws the mini graph "Where this came from in your notes", and [[bracketed]] references are clickable doors into the underlying notes and entity pages. Once the conversation has touched the right people and organizations, it has quietly built your starting entity set. Now freeze it.

Pin-time extraction is deterministic, with no AI involved. The app reads what the transcript already carries: your @-mention tokens and the assistant's [[…]] citations. It resolves each label against the live knowledge graph and drops anything that isn't an entity node (a citation to a plain note, say). Aliases then collapse onto one chip by identity.

Case

The investigation container: one driving question, pinned entities, adopted conversations, and a log.

Driving question

Free text under "What is this case about?". Everything else falls out of it.

Pinned entity

A graph entity frozen into the case by identity, labelled as it read at pin time.

Adopted conversation

A chat that belongs to the case. Adoption is a pointer, so the chat stays in your history.

Investigation log

The case's running notes. Saves when you click away, accumulates across sessions.

New-evidence delta

The reopen check listing which pinned entities gained evidence since your last visit.

Stage 3: grow the network, one connection at a time

Now work the network: click any pinned chip to open that entity's page. Its connections arrive ranked, with direction arrows and plain-language relations, and hovering any neighbor shows the exact sentence in your notes that states the fact. A wrong edge dies here too. A hidden unlink button ("This connection is wrong") writes a permanent retraction that re-extraction can't resurrect.

When a neighbor turns out to matter, say the audit firm or the rival bidder, its own page has "Add to case" in the header (toast: "Added {label} to the case"). Investigations grow exactly like this: hop a link, check the source sentence, pin what survives.

Stage 4: put the places on a map

Geography is evidence. There's no map button anywhere. You ask: "map every facility connected to this case". The agent geocodes each place (the "Geocoding places" card), authors the map (the "Authored map" card), and a live, interactive map appears right in the transcript. Click "View large" to open it as a full tab, with a legend and basemap styles. The chat docks into the left sidebar so you can keep directing: "add the ports", "color facilities by owner".

The map talks back. Click a mark and a pill reads "Selected: {label}" while an @label mention chip lands in the composer. Your next message carries that exact feature's data, so "why is this one isolated?" works out of the box. Marks tied to your entities offer "View in graph", jumping from map to graph in one click. Best of all, entity coordinates live in a dedicated geo layer of the knowledge graph that survives re-extraction. Weeks later, with no map open, you can ask "what's within 2 km of the Ulsan plant?" and get a real answer, or have the agent compute actual routes and travel-time areas.

Stage 5: record claims and evidence in your own words

Findings that stay in your head, or in the plain-text log, never become evidence. Write them as notes. With "Capture your decisions and questions" on (it's the default), extraction lifts your unhedged sentences verbatim as statements: decisions, open questions, claims, and quotes, plus standing preferences, values, and stances.

When your text explicitly connects two statements, the extraction records that link too. Sentences like "this supports the decision above" or "this rebuts the capacity claim" do it. Rationale links are author-explicit: only the connections you write get captured, so your reasoning stays exactly as you put it.

# Taeyang assessment, 2026-03-02

Decision: we will shortlist Taeyang Components
for the three-year contract.

The 2025 audit's 98% on-time delivery rate
supports this decision.

Claim: the Ulsan plant is running near capacity.

Open question: who owns Pacific Alloys,
Taeyang's main upstream supplier?

Each statement shows up under "In your words" on the entity pages it concerns, and its status is derived, never stored. When a later note revises an earlier decision ("2026-05-10: we are dropping Taeyang from the shortlist"), cross-note supersession proposes the link. High-confidence proposals auto-apply (always reversible); the rest wait in the Revisions panel for your "Confirm" or "Reject". Once confirmed, the earlier decision renders struck through everywhere with a "Superseded by {note}" link. Ordering uses the date the note itself states, so date your analysis notes and they slot into the revision timeline on their own.

Stage 6: the cited write-up, and coming back

Time to deliver: in the case, click "Continue in this case". A fresh chat opens, already adopted, with every pinned entity pre-seeded as a real @-mention chip (delete any that don't belong). Ask for the deliverable: "Write a one-page assessment answering the driving question. Cite every fact to its source note." The draft arrives with [[citations]] you can click.

In the default "Ask" permission mode, the note the agent writes shows its full diff with an approval card before a single byte lands in your workspace. Verify the load-bearing claims the way you verified the network: hover the connection, read the source sentence.

Then comes the part scattered chats can never give you: the return. Weeks later, press ⌘⇧K and open the case. If any pinned entity gained new graph evidence while you were away, a strip announces it: "New evidence on {count} pinned entities since your last visit:" followed by exactly which ones. That's your catch-up list. Dismiss it with ✕ when you're caught up (dismissal lasts for the session), add a line to the log, and the investigation keeps compounding.

When git and the terminal join the case

Some investigations touch code or data, and the chat composer already has the bridges. Everything below is one @ away:

• "Terminals" in the @-picker captures an open terminal's recent scrollback as a context chip. Crunch a CSV in the dock, then hand the output to the agent as evidence.
• "Branch (Diff with Main)" captures your working branch's diff as a chip. It's the move for "what actually changed?" questions in a code-adjacent investigation.
• The agent can also run commands itself: you'll see "Running command" chips (and "Running in background" for long jobs) with the captured output inline.
• The agent can drive a real terminal. Its commands act on your actual system, so approve them as carefully as you'd run them yourself.

Recap: the whole recipe in one breath

The full recipe in one breath: dump the sources → interrogate in chat → pin the chat as a case → frame the driving question → grow the pins, source sentence in hand → map the places → write dated notes so claims become statements → ask for the cited write-up → come back to the new-evidence strip. And remember the shape of the thing: a case is a viewpoint over the one graph. "Remove case" deletes only the container, and "Your notes and conversations are kept."

That's the course. Everything you learned has a place in this one recipe: sources in, entities out, a question with a home, a network you grew one source sentence at a time, and a write-up that can prove where every fact came from. The next investigation is the same order, run again on a question that matters to you.