See Your Team Context as a Knowledge Graph
A list of memories tells you what you wrote down.
A graph tells you how it connects.
Pathrule Studio now draws the whole context layer as one map you can explore.
What this covers
- Pathrule Studio adds a Graph tab next to Overview in the Summary surface: a force-directed map of the workspace context layer.
- Nodes are path nodes plus the memories, rules, and skills attached to them. Edges are the path hierarchy, attachments, and the wikilinks written inside memories.
- Node size scales with how connected a node is, and color marks its kind, so hubs and orphaned knowledge are visible at a glance.
- Because every node carries the path it lives at, the graph shows which slice of context hangs off which part of the repo, not just a flat list of notes.
Comparison
| Aspect | A list of memories | The knowledge graph |
|---|---|---|
| What you see | Titles in a flat index | Every node, memory, rule, and skill as connected points |
| Structure | Implied by folder names | The path hierarchy drawn as edges you can follow |
| Links between notes | Invisible until you open each one | Wikilinks between memories rendered as lines |
| Importance | Every item looks equal | Node size scales with how connected each one is |
| Orphaned knowledge | Hard to spot | Shows up as a node with no edges |
A flat list stops scaling before the knowledge does
Pathrule stores team knowledge as three primitives attached to paths: memories, rules, and skills. For a young workspace, a list of them is enough. You can read the titles, remember what is there, and trust that the right slice reaches the assistant when it works in a folder.
That stops being true as the workspace grows. A few dozen memories across a real repo become a set you can no longer hold in your head. You lose track of what links to what, which folders are well documented and which are bare, and whether a note you half-remember still exists.
A list answers what did we write down. It does not answer how does it all connect, or where are the gaps. Those are the questions a team actually has once the context layer is doing real work, and they are graph questions, not list questions.
What the graph is made of
The Graph is a force-directed map of the whole workspace. Two kinds of thing become points on it. The first is the path nodes themselves: the parts of the tree that mirror your repo. The second is the memories, rules, and skills attached to those nodes.
Three kinds of relationship become lines. The path hierarchy connects a parent node to its children, so the shape of your repo is visible directly. Attachments connect a node to the memory, rule, or skill that lives there. And wikilinks connect one memory to another wherever you wrote a link in its body.
Today the graph draws the relationships you authored: the hierarchy, the attachments, and the wikilinks. Two more kinds of connection are on the way, semantic similarity between memories and co-change coupling drawn from activity, and when they arrive the map stops being only what you linked by hand and starts surfacing the connections it infers for you.
Reading the map: size, color, and distance
The layout does the first pass of the reading for you. A physics simulation pulls linked nodes together and pushes unrelated ones apart, so clusters form around the parts of the repo that carry the most context.
Size encodes connectedness. A node with many edges is drawn larger, on a log scale so a single hub does not dwarf everything else. A memory that many others link to, or a folder that owns a lot of knowledge, stands out without you searching for it.
Color encodes kind. Memories, rules, and skills each get their own hue, matching the palette used across the rest of Studio, and path nodes get the workspace accent. A node with no edges at all is the visual signal for orphaned knowledge: something written down that nothing else points to.
A substrate richer than linked notes
Graph views of notes are not new. Tools that link Markdown files have drawn them for years. The difference here is the substrate. This graph is not built over a folder of documents; it is built over the model of team knowledge that Pathrule maintains.
That means every point knows the path it belongs to. The graph is not a loose web of notes floating in space. It is anchored to the same path tree that decides what context reaches the assistant, so it shows you which slice of knowledge hangs off which part of the repo.
It also means the graph can go beyond the links you typed. Because the underlying data includes attachment relationships, injection weight, and eventually semantic and co-change signals, the map can become partly automatic: not just the notes you connected, but the ones that behave as if they are connected.
Where it lives, and what you do with it
The Graph is a tab in the Summary surface, next to Overview. Overview keeps a small preview card, a still constellation of the workspace, that opens the live graph in one click. Opening the full view drops you into a canvas you can zoom, pan, and drag.
Hovering a node highlights it and its neighbors and dims the rest, so you can trace what one memory connects to without losing it in the crowd. Labels fade in as you zoom, so the map stays readable at a distance and precise up close. A control panel lets you filter by node or edge kind and tune the forces if you want a looser or tighter layout.
Clicking a node opens a read-only preview of its content beside the canvas, so you can read a memory, rule, or skill without leaving the map. The graph becomes a way to navigate the context layer by structure instead of by search: start from a cluster, follow the links, and read what you find.
A first look worth taking
The graph is most useful the moment you suspect your context layer has drifted. Open it and look for the shape of the problem. A folder your team edits constantly with a bare, unconnected node is missing context. A dense knot of memories that all link to one stale note is a refactor waiting to happen.
It also changes onboarding. A new teammate can see the whole knowledge map at once, spot the well-documented regions, and understand how the team thinks about the repo before reading a single file.
Every signup gets three months of Pathrule PRO on the house. If you want to walk your team knowledge graph together and find the gaps, [email protected] is open.