The field guide

Unicron is a second brain built on a folder of plain markdown files — no database. Every note is a file, and every link between notes is an edge. Each note also has a type and a schema it's checked against, which is what makes the vault a small knowledge graph rather than a pile of linked notes: typed things, with defined relationships the app can read and reason over.

What you actually do is capture — paste a meeting transcript, jot a thought, drop something in the inbox. Claude Code is the engine that turns that into structure: running locally, it reads your messy input, writes it into a typed note, and works out where the note belongs — its area, its project, the people it involves. From that the app infers the graph's edges, and you skim and confirm. You never assemble the graph by hand. You capture, Claude Code structures it, and the relationships fall out.

The fastest way in is Add — the + in the top bar, or ⌘N. Pick what you're capturing (a Meeting, Project, Person, Area, Decision, Journal, or a quick Task), paste or jot what you've got, and Claude Code writes it into a properly-typed note in the right folder. For a meeting you can paste the whole transcript. It pulls out who was there, updates those people, and files the note under its area.

Anything you drop in raw — a paste, a note from your phone, a Shortcut — lands in the inbox, untyped and waiting. Run Triage and Claude reads each capture, works out its type and where it belongs, and files it as a real note. You review the result. The top bar flags the inbox whenever something's waiting.

Five places across the top: Today (your daily brief), Tasks, Library (every note, filtered by type in the left rail), Graph, and Ask. In the Library rail, click a type to isolate it (⌘-click to combine a few), and drill into an area or project to see what lives under it. Press ⇧⌘J to jump to any note by name, or / to filter the current list.

Ask is a read-only chat: it reads your notes to answer, and sends you to the terminal for anything that would change them.

A note opens in preview. Hit ⌘E (or the pencil) to edit. In edit mode, type @ and a name to drop in a person link — the path is worked out for you — and / for a menu of formatting and blocks. Tables edit cell by cell, with row and column controls. Save, and the app re-reads the note so the graph stays current.

Any - [ ] line in any note is a task, and the Tasks view gathers them all — no separate to-do app. But not every checkbox is yours to act on, so the view splits them by who owns the item:

• Mine — your actual to-do list, and the only bucket that counts as load. Check things off, defer one to a later date, or hit Select to mark a whole batch done at once. Checking a task writes straight back to the note it came from.
• Waiting on — things other people owe you. Put a name in front of the task (Jane — send the contract), or write it in that person's note, and it lands here instead of Mine. These are read-only: no checkbox, no count. You scan them to see who owes you what; you don't maintain them. When someone finally delivers, whatever you do next is a fresh task of your own.
• Threads — ambient context in a client area that was never a to-do. Same passive treatment as Waiting on.

That split runs everywhere tasks show up. A project's Open tasks count is yours alone, with a quiet "Waiting on" list beneath it, and inside a note someone else's - [ ] reads as a plain bullet instead of a checkbox you'd check off.

Filter the whole view to one area or project with the scope control up top.

The Graph view draws the whole vault. Every note is a node, sized by how many links it has; every link is an edge. Two layouts:

• Force — physics pulls connected notes together. The relationship view.
• Tree — a top-down hierarchy rooted at you. The structure view.

Edges come in two kinds, and the Edges toggle in the graph toolbar switches between them:

• Solid — written. A link you actually typed in a note.
• Dashed — inferred. A relationship the app worked out from frontmatter and folders, like a project belonging to its area. Nobody wrote it as a link; Unicron figured it out.

Flip to Written to see only what you wrote by hand. Flip to All to add back everything the app inferred. Hover any edge to see where it came from.

You never have to draw the dashed connections yourself. When you tell a note where it lives — its area:, its project:, or just the folder you keep it in — the app reads that and makes the connection. A project joins its area; a meeting joins its project and its area. You fill in the note, and the relationships appear.

The links worth writing by hand are the ones the app can't guess: a person who matters to a project, a meeting that reaches into another area's work, a reference that crosses the usual lines. Those are your solid edges. Write about what's connected and the links follow; you're never gardening the graph to keep it whole.

A decision is a choice you're tracking. Create one with ⌘N ▸ Decision — it lives in its area, like a project. Its steps are just task lines (- [ ]), so they roll into your Tasks, and you can note who made the call with a decidedBy field.

Move it through its lifecycle from the status control, no YAML editing: open while you're still deciding, made once you've called it, revisited if you come back to it.

When you know how it turned out, hit Record outcome. That writes the outcome note and points the decision's leadsTo at it for you. The graph draws that link dotted — a proposal — because the app won't claim one thing caused another on your say-so alone. Find the decision and hit Confirm, and the dotted line becomes solid: now it's your assertion, not the app's guess.

Once you think of the vault as a knowledge graph, four words show up everywhere:

• T-Box (terminological) — the schema. The kinds of note that exist and the links allowed between them. It lives in ontology.md.
• A-Box (assertional) — the assertions. Your actual notes, and the links between them.
• Predicate — a typed edge. Not just "A links to B" but how: belongsTo, involves, mentions.
• Provenance — where a fact came from and how sure we are. A link you wrote by hand, or one the app inferred.

There are really two graphs hiding in a vault.

The one you started with is an entity graph: it describes what exists and how things sit together — areas, projects, people, and meetings, joined by containment and mention.

The second is a process graph: what happens, and what leads to what. A decision, the steps it sets off, the outcome it produces. That's the decision module. The web standardized this shape long ago as PROV-O, the Provenance Ontology (Agent, Activity, Entity), which is a good sign it holds well beyond a personal vault. Nearly every edge below the app can assert for free — an agent performed a step, a step produced a result. The one it can't is the causal leadsTo, so that edge stays dotted and proposed until you sign off.

The graph stays true as it grows by running a loop between two halves that fail in opposite ways.

• Neuro — Claude reads your messy notes and proposes structure. High recall, but it can guess wrong.
• Symbolic — the ontology and its rules check each proposal, store it with its provenance, and never invent anything. High precision.
• You — view and confirm. Confirmed facts ground the next pass.

You already run this loop every day. It's called triage: Claude proposes where a capture belongs, you confirm. One rule keeps it from rotting — inferred and proposed facts stay re-derivable and never get hand-edited. The moment you edit a guessed edge as if you wrote it, the system can't tell truth from guess anymore.