Course outline
AcademyModule 5 · Agent tasks and approvals
Organize investigation material in case files
What you'll learn
- You can create a case by pinning a conversation, from an entity page, or from scratch
- You can frame a case with a driving question and keep a running investigation log
- You can grow and prune the pinned entity set and project it onto the graph canvas or entity table
- You can use the new-evidence strip to catch up on what changed since your last visit
- You can pick between a case and a collection for the job at hand
A supplier review or a recurring bug investigation may take several weeks. The relevant evidence can be spread across chat sessions, notes, and graph entities.
A case file brings those references together so you can resume the investigation without searching for each source again.
Cases are Consilience's answer: a lasting home for one investigation. A case holds a single driving question, the knowledge-graph entities you pinned by hand, the conversations you adopted into it, and a free-text log. When you come back, it tells you which pinned entities picked up new evidence while you were gone.
What a case holds
| Field | What it is |
|---|---|
| Name | Taken from the pinned conversation's title, or "Untitled case" if there isn't one. Edit it right in place; press Enter or click away to save. |
| Driving question | Optional free text. The placeholder asks: "What is this case about?" |
| Pinned entities | Knowledge-graph entities. Each one references the real entity node in the graph and carries a display label captured the moment you pinned it. |
| Conversations | Chats you adopted into the case. The case stores pointers to them, so the chats themselves stay put in your normal chat history. |
| Investigation log | Free-text running notes. They save when you click away and stick around across sessions. |
- Case
- A durable investigation container: one driving question, pinned entities, adopted conversations, and a running log.
- Pinned entity
- A reference to the real entity node in the graph. The label is stored as it read the moment you pinned it.
- Adopted conversation
- A chat that belongs to the case. The case only points to it, so the chat stays in your normal history.
- Driving question
- The optional one-liner that frames the case: "What is this case about?"
- Investigation log
- Free-text running notes that save when you click away and build up across sessions.
- New-evidence strip
- The check that runs when you reopen a case, listing pinned entities with new graph evidence since your last visit.
Three ways to start a case
The usual way: pin a conversation
- Have the conversation
Chat about the topic like you normally would. Mention entities with
@, or let the assistant cite[[entities]]in its answers. That record is exactly what pinning reads later. - Pin it
In the sidebar session list, right-click the chat (or click its "…" button) and choose "Pin as case…".
- Check the toast
A toast reads "Pinned to a new case" and gives the number of entities pinned. The case opens with the chat already adopted, every recognized entity pinned, and its name borrowed from the chat.
- From an entity page: open the "Add to case" dropdown in the header, next to "Open on the graph". Pick "New case from this entity" for a case named after that entity, with it already pinned. Below a separator, every existing case is listed, so you can drop the entity into one instead. A toast confirms: "Added {label} to the case".
- From scratch: open Cases (⌘⇧K) and click "New case". You get a blank "Untitled case" with no entities and no conversations yet.
Pinning is deterministic, with no AI in the loop
"Pin as case…" never asks a model which entities the chat was about. It reads what the transcript already carries: the @-mention tokens you typed and the [[…]] citations the assistant embedded (plus the older [@name] form in legacy transcripts). Then it resolves each label against your live knowledge graph.
Labels that don't land on an entity node (say a [[note]] citation pointing at a plain note) are left out. Two aliases of the same entity collapse into one chip, since both land on the same node in the graph. No model is called, and nothing leaves your machine.
Update and resume a case
Cases live in one tab titled "Cases". That single tab serves both the all-cases list and any case's detail, and opening a different case retargets the same tab. The graph and entity-table tabs behave the same way. Inside a case, everything you need sits on one screen:
| Control | What it does |
|---|---|
| "Continue in this case" | Opens a fresh chat, adopts it into the case, and pre-fills the composer with every pinned entity as a real @-mention chip. Delete any chip you don't want before you send. |
| "Show on canvas" | Puts exactly the pinned set on the graph canvas, on its own and colored by type. Lights up once you have at least one pinned entity. |
| "Open as table" | Opens the entity table scoped to this case (Name/Type/Connections/Notes, with filter and sort). Also lights up once you have a pinned entity. |
| Entity chips | Click a chip to open that entity's profile page. Hover it and click ✕ ("Remove") to unpin. |
| "Investigation log" | Running notes for the case. The placeholder invites running notes and findings on what you've learned so far. It saves when the field loses focus. |
| "Remove case" | Deletes only the container, after a confirm dialog: "Your notes and conversations are kept." |
Finding Cases again
Cases has no permanent sidebar icon. From anywhere inside a workspace, press ⌘⇧K (Ctrl+Shift+K on Windows, rebindable under Settings → Shortcuts → Navigation), or find it in the global palette (⌘⇧F).
Every case is its own palette entry too. The title is the case name and the subtitle reads "N pinned", so typing a case's name is the fastest way to jump straight into it.
Turn a conversation into a case
- In a chat, talk through a topic you care about and mention at least two entities with
@(or pick an existing chat where the assistant cited[[entities]]). - Right-click that conversation in the sidebar session list and choose "Pin as case…".
- Watch for the toast "Pinned to a new case" with its entity count.
- Rename the case inline and type a driving question into "What is this case about?".
- Click "Show on canvas" to see the pinned set alone on the graph.
The "Cases" tab opens on your new case: the chat listed under "Conversations", the mentioned entities as chips under "Pinned entities", and the graph canvas showing only those entities, colored by type.
Check newly added evidence
Reopen a case after some time away, and Consilience checks the case's previous last-opened time. Then it asks the knowledge graph which pinned entities gained new facts strictly after that moment. If any did, a strip appears: "New evidence on N pinned entities since your last visit:" followed by their labels.
Click ✕ ("Dismiss") once you have caught up. The dismissal lasts for the session, and the check runs once each time you open the case.
The corkboard, upgraded
Detectives pinned photos and index cards to corkboards long before software existed, because no one's memory holds a whole investigation at once. A digital case adds what paper never had: a change feed. Every new fact arrives with its timing, so a case can answer a sharp question: what showed up after I last looked?
Cases or collections?
Cases and saved entity collections look at the graph the same way: "Show on canvas" and "Open as table" are the very same views collections use. Nothing is duplicated; both are lenses onto the one graph. So which do you reach for?
| You want… | Reach for |
|---|---|
| A reusable set of entities to browse, sort, and filter | A collection |
| One question, plus the chats, running notes, and evidence trail around it | A case |
| A "what changed since I last looked?" check on a hand-picked set | A case, via the new-evidence strip |
| A set that lives in the entity table's own source switcher | A collection, which shows up right in the table's switcher, alongside All entities and Types |
A case is a living reference set
Curate on purpose. A pin references the entity itself in the graph, so a chip keeps standing even if that entity is later renamed or reshaped. The case stays exactly the set you chose. Grow it from any entity page's "Add to case", and prune it with a chip's ✕.
Let it pile up. Keep dropping findings into the "Investigation log" and opening fresh threads with "Continue in this case". Over weeks, the case becomes the one place that remembers the whole question for you.
A case is the cheapest, safest structure in the app. Each one is stored locally, scoped to its workspace: never written into your markdown, never sent to a model. "Remove case" leaves every note, entity, and chat intact.
The moment a question outgrows a single chat, give it a case. Next comes a different kind of record: the built-in Git panel, which keeps the history of every change your files have been through.