Graph commands for queries, reports, and scenarios

Lesson 3 of 318 min

What you'll learn

Tell the command families apart: instant lookups that answer in chat, report pipelines that write documents, capture and monitoring verbs, and the what-if simulation
Interrogate the graph with /facets, /similar, /connect, and /whatchanged, and commission grounded reports with /brief, /timeline, /tensions, and /overview
Run /scenario and read its report as an exploration: individuated actors, four stages, and a self-critique at the end
Launch any graph command from an entity's profile page, with the entity already filled in

Graph commands let you look up entities, generate reports, monitor changes, and explore scenarios from the chat composer. They use the entities, relationships, statements, and sources already in your workspace.

Use a slash command for a defined task, such as checking how your view of an entity changed or finding disagreements between notes. This lesson covers the commands and the results each produces.

Two commands in the picker, Goal and Research, are general agent runs with a lesson of their own ahead. Everything else is this lesson: the graph verbs, from one-second lookups to /scenario, the deepest of the set.

Running a command

You met the composer's basics in the chat basics lesson: / at the start of a message opens the command picker, and it filters as you type, in English or your own language. One command-specific nicety: pick a command that needs an entity and the composer inserts @ and opens the entity picker right away, so autocomplete guarantees the name.

The real command picker. Goal and Research are agent runs; the rest are graph verbs: lookups, reports, capture, monitoring, and Scenario.

Instant lookup: A command that runs as a local graph query and answers in chat within seconds. No model call, no cost.
Report pipeline: A staged command: deterministic collection first, then one model call for the narrative, then a document written into your workspace.
Grounded link: The [[link]] behind a claim. Report narratives may only cite facts the collection pass actually gathered.
Actor: A person or organization from your graph that /scenario role-plays, reacting from the statements that actor left on record.
Robustness: The last scenario stage: the report criticizing itself, rating how fragile its conclusion is to a change of framing.
Entity launcher: The row of command chips on an entity's profile page. One click prefills the composer with the command and that entity.

Four groups of graph commands

The verbs split by what they cost and what they hand back. Instant lookups are pure graph queries: free, seconds, answer in the thread. Report pipelines think harder and leave you a document; capture and monitoring verbs add new material to the graph and keep watch on it. And /scenario is a family of its own: a staged simulation.

Family	Commands	What runs	What you get
Instant lookups	/facets, /similar, /connect, /whatchanged	Local graph queries, no model call	A gray tool chip while it runs, then the answer in the thread
Report pipelines	/brief, /overview, /timeline, /tensions	Staged: deterministic collection, then one model call for the narrative	A document in your workspace, deep-linked at the end of the run
Capture & monitoring	/clip, /suggest, /follow, /watch, /revisions	Local verbs over pages, tasks, feeds, and pending revisions	A new note, a standing alert rule, or a panel opened in place
What-if simulation	/scenario	A four-stage pipeline that role-plays actors from your graph	An exploratory report in scenarios/, never a forecast

Quick lookups: entities and connections

/facets: an instant census of which entity kinds dominate your graph and which themes (communities) are biggest. The fastest way to orient in a workspace, yours or one you just imported.
/similar @entity: look-alikes by meaning, using similarity the graph has already computed. It surfaces entities that live near each other conceptually even when no edge connects them yet, and marks which ones are already linked.
/connect @A @B: the shortest path between two entities, hop by hop, each hop a real relationship with its source link. "No path" is a finding in its own right: these two aren't connected in anything you've written yet.
/whatchanged: the last 30 days of graph motion. New entities, themes that grew, and decision revisions that were confirmed, with before/after quoted verbatim. Add a topic to scope it.

Instant lookups in practice

/facets
/similar @Helios Materials
/connect Kim Jiyoon -> Nimbus Robotics
/whatchanged batteries

Name entities however you think them

Commands resolve names in layers. An exact label wins first. When aliases collide, the representative label takes it: "Tesla" the company beats "Tesla (band)" for the bare word. Then comes semantic matching, so /similar 테슬라 finds Tesla even though the label is English. A near-miss returns the closest labels as suggestions instead of a dead end.

Mentioning with @ skips all of that: the autocomplete picks the exact entity. That's why entity-taking commands open the @ picker for you. Two mentions in a /connect need no arrow between them; typed names take -> as the separator.

Report pipelines: commission a document

The four report verbs answer bigger questions than a chat message can hold, so they answer with a document instead. Each runs as a staged pipeline you can watch in the thread, like a small research run, and ends with a deep link to the file it wrote.

Command	The question it answers	Lands in
/brief @entity	"Catch me up on this one thing": a dossier built from the entity's profile and the themes around it	briefs/
/timeline @entity	"How did my thinking here evolve?": dated entries on the note-date axis, superseded decisions struck through	timelines/
/tensions	"Where do my notes disagree?": opposite stances and conflicting decisions or claims, judged pair by pair (scope optional)	tensions/
/overview	"What's in this workspace, big picture?": the theme map drawn from your graph's communities (scope optional)	overviews/

Every [[link]] is checked

All four share one skeleton. A deterministic pass collects the facts: profile, dates, stances, community themes. The model gets one call, to narrate what was collected, nothing more. Then a code-side check verifies every [[link]] in the draft against the collected set, and a link the model invented is downgraded to plain text and counted, so an unsupported citation can't pass itself off as a source.

Two more honesty rules. A report is only ever a document; no command silently writes into your graph. And when the graph is too thin to say anything, the report says that: /timeline wants at least two dated notes, /tensions reports an empty result as a result. No padding.

Capture and monitoring

/clip URL: save a web page as a note in your workspace. It takes its title from the page and flows into extraction like anything you wrote yourself.
/suggest: grounded task ideas mined from your graph. Open questions, recorded follow-ups, work you left unfinished.
/follow @entity: follow news about an entity, and matching items from your live feeds raise alerts. /watch keyword does the same, keyed to a keyword instead of an entity. Both create standing rules that the live feeds lesson shows you how to manage.
/revisions: open the pending decision-revision proposals for review (the Revisions section of the Knowledge graph tab). Nothing pending? It says so instead of opening an empty panel.

/scenario: explore changes in assumptions

Every verb so far reads the graph as it is. /scenario asks the question your notes can't answer directly: *what if a rival cuts prices? what if a key supplier walks?* Give it a situation and it role-plays a small cast of actors pulled from your graph, each reacting in character. Then it synthesizes how things might unfold and stress-tests its own reading for weakness. Write it in whatever language you think in: actors are found by meaning, so a situation phrased in Korean still anchors onto English-labelled entities.

A scenario

/scenario what if Nimbus cuts Drift's price 25%, how does Helios respond?

Scenarios are exploratory tools

A scenario is exploratory, not a prediction, and not validated. It is one pass over a partial graph, sensitive to how you phrase the situation, role-played by a language model. Every report opens with this banner on purpose.

Read it the way a good analyst reads a war-game. The point is to surface assumptions, disagreements, and fragile points. If you take a scenario as a forecast, you're misusing it.

Anchor → voices → synthesis → robustness

Anchor
"Finding relevant people & relationships." It searches your graph by meaning, not just keywords, for a small cast of actors the situation touches, plus the web of relationships around them. No actors found means the situation isn't in your graph yet; add a few notes about the players and try again.
Voices
"Asking each actor how they'd react." Each actor in the cast is role-played independently, in character, against the situation. They don't see each other's answers, and that independence is what lets them genuinely disagree.
Synthesis
"Synthesizing the exploratory scenario." The independent reactions are woven into branches, the distinct ways things could unfold, plus where the actors agree, where they diverge, and the assumptions the whole thing rests on.
Robustness
"Stress-testing the reading for fragility." A final pass attacks the report: which single assumption is it leaning on, and does the headline flip if you reframe the situation? It ends with a verdict: robust, mixed, or fragile.

The quality lever that makes a scenario worth reading is that each actor is individuated. The model gets more than a name and a job title. It gets that actor's own statements on record in your graph, the decisions, claims, questions, and stances extracted from your notes, and role-plays from those. An actor on record opposing price wars argues against a price cut; a board member who pushed a bridge round pushes it again.

Branches come from recorded statements

This is why /scenario needs a real graph to work, and why richer notes produce sharper scenarios. The branches come from your actors' actual positions, and the report says so: it distinguishes a path grounded in a recorded stance from one an actor merely speculated about. When a claim isn't backed by anything in your graph, the report marks it as weakly grounded rather than dressing it up as fact.

It's the difference between a role-play built from interview transcripts and one built from a census: the same cast, but only one of them tells you anything you didn't already know.

Reading a scenario report

The scenarios/ document opens with the exploratory banner, then walks through a consistent shape:

Section	What it gives you
How it could unfold	The branches: the distinct paths, each tied to the actors who argued for it
Where the actors agree / diverge	The consensus and the real disagreements, often the most useful part
Key assumptions	What the whole reading rests on, stated plainly so you can challenge it
What would most change the outcome	The variables to watch, where new information would move the result
Robustness	The self-critique and the robust / mixed / fragile verdict
Cast	Exactly which entities from your graph were role-played

That Robustness section is the honest heart of it, the same verification-first spirit as the report pipelines. A fragile verdict is the tool telling you the reading stands on one shaky assumption and is a single reframe away from reversing. Reach for /scenario when a decision involves human actors whose positions you've captured: a competitive move, a negotiation, a strategy call. Leave it alone when you need a real forecast. And when a scenario earns follow-up, the cases lesson shows you how to pin the conversation so the exploration becomes a lasting record.

One click from an entity page

Every graph verb is also one click from where you already are. An entity's profile page carries a launcher row: Scenario, Brief, Timeline, Tensions, What changed, Connect, Follow, Similar. Click a chip and the composer fills in the command plus that entity as a mention chip, ready to send or edit. The profile page tells you what an entity *is*; the launcher row is how you ask what it *means*.

Interrogate your graph

Type /facets and send. Read the census: which kinds dominate, which themes are biggest?
Run /similar on an entity you know well, picking it from the @ picker that opens. Any look-alikes you never connected?
Run /brief on the same entity, follow the deep link into briefs/, and skim the dossier. Notice which claims carry [[links]], and where it abstains instead of padding.
Feeling bold? Ask /scenario a what-if about the same corner of your graph, and read the Robustness section first.

Four verbs, four shapes of answer: an instant census, an instant similarity list, a checked dossier in briefs/, and an exploratory scenario that critiques itself.

That's the command layer: four lookups that answer in seconds, four reports with checked citations, five verbs that capture and watch, and one simulator that stress-tests the future. All of it runs against the vocabulary you taught it and the statements you left on record, one / away. Next you hand that same graph bigger jobs, starting with the agent's tools, its approvals, and how to undo what it does.

← Previous lesson