Cortex — Graph Memory Skill

You have access to Cortex, a self-organizing knowledge graph for persistent memory. Use it to remember facts, decisions, goals, patterns, and observations across sessions. Knowledge is stored as nodes in a graph that auto-links, decays stale information, detects contradictions, and computes trust from topology.

When to Use Cortex

• Start of session: Call

  cortex_briefing

  to load context from previous sessions.
• Learning something important: Call

  cortex_store

  to persist facts, decisions, goals, events, patterns, or observations.
• Answering questions about past work: Call

  cortex_search

  or

  cortex_recall

  to find relevant knowledge.
• Understanding relationships: Call

  cortex_traverse

  to explore how concepts connect.
• Connecting ideas: Call

  cortex_relate

  to explicitly link related nodes.

Tools Reference

cortex_store — Remember something

Store a knowledge node. Cortex auto-generates embeddings and the auto-linker discovers connections in the background.

cortex_store(
  title: string,         # Required. Short summary (used for search and dedup).
  kind: string,          # "fact" | "decision" | "goal" | "event" | "pattern" | "observation" | "preference". Default: "fact"
  body: string,          # Full content. Can be long. Include details here.
  tags: string[],        # Optional tags for filtering.
  importance: number     # 0.0–1.0. Higher = retained longer, weighted more. Default: 0.5
)

Returns:

{ id, message }

Guidelines:

• Use

  importance >= 0.7

  for architectural decisions, credentials, project goals, user preferences.
• Use

  importance 0.4–0.6

  for routine facts, observations, intermediate findings.
• Use

  importance <= 0.3

  for ephemeral notes, temporary context.
• Write titles as self-contained statements: "API uses JWT authentication" not "Auth info".
• Put details, reasoning, and evidence in

  body

  .
• Use accurate

  kind

  values — they affect briefing structure and filtering.
• Tag with project name, domain, or agent role for scoped retrieval.

cortex_search — Find by meaning

Semantic similarity search across all stored knowledge.

cortex_search(
  query: string,   # Required. Natural language query.
  limit: integer,  # Max results. Default: 10
  kind: string     # Optional filter: "fact", "decision", "goal", etc.
)

Returns: array of

{ id, kind, title, body, score, created_at }

When to use: Quick lookup of specific facts or concepts. Best when you know roughly what you're looking for.

cortex_recall — Contextual retrieval

Hybrid search combining vector similarity AND graph structure. Returns more contextually relevant results than pure search.

cortex_recall(
  query: string,   # Required. What to recall.
  limit: integer,  # Default: 10
  alpha: number    # 0.0 = pure graph, 1.0 = pure vector. Default: 0.7
)

When to use instead of search:

• When you need related context, not just matching text.
• When exploring a topic area broadly.
• Lower

  alpha

  (e.g., 0.3) when graph relationships matter more than text similarity.

cortex_briefing — Session context

Generate a structured summary of relevant knowledge. Includes active goals, recent decisions, patterns, key facts, and contradiction alerts.

cortex_briefing(
  agent_id: string,  # Agent identifier. Default: "default"
  compact: boolean   # If true, returns a shorter ~4x denser briefing. Default: false
)

Returns:

{ briefing: "<markdown>" }

Guidelines:

• Call at the start of every new session or conversation.
• Use

  compact: true

  when context window is tight or you just need a quick refresh.
• Use a consistent

  agent_id

  per role/project to get scoped briefings.

cortex_traverse — Explore connections

Walk the knowledge graph from a starting node to discover how concepts relate.

cortex_traverse(
  node_id: string,    # Required. Starting node UUID (from search/store results).
  depth: integer,     # How many hops. Default: 2
  direction: string   # "outgoing" | "incoming" | "both". Default: "both"
)

Returns:

{ nodes: [...], edges: [...] }

When to use: After finding a key node via search, traverse to understand its full context, dependencies, and contradictions.

cortex_relate — Connect knowledge

Create a typed relationship between two existing nodes.

cortex_relate(
  from_id: string,    # Required. Source node UUID.
  to_id: string,      # Required. Target node UUID.
  relation: string    # "relates-to" | "supports" | "contradicts" | "caused-by" | "depends-on" | "similar-to" | "supersedes". Default: "relates-to"
)

When to use:

• When you discover a logical dependency between two pieces of knowledge.
• When new information contradicts or supersedes an old node — use

  contradicts

  or

  supersedes

  .
• The auto-linker handles many connections automatically; use

  cortex_relate

  for explicit, meaningful relationships the auto-linker might miss.

Workflows

Starting a session

1. cortex_briefing(agent_id="<project-or-role>")

   — load context.
2. Read the briefing. Note any active goals, recent decisions, or flagged contradictions.
3. Proceed with the task informed by prior knowledge.

During work

• When you make or observe a significant decision →

  cortex_store(kind="decision", ...)

  .
• When you discover a fact worth remembering →

  cortex_store(kind="fact", ...)

  .
• When you notice a recurring pattern →

  cortex_store(kind="pattern", ...)

  .
• When something happened that matters →

  cortex_store(kind="event", ...)

  .
• When you need to look something up →

  cortex_search(...)

  or

  cortex_recall(...)

  .

Ending a session

• Store any unrecorded decisions, outcomes, or observations.
• If a goal was completed, store an event:

  cortex_store(kind="event", title="Completed: <goal>", importance=0.6)

  .

Resolving contradictions

1. cortex_search

   or

   cortex_recall

   to find conflicting nodes.

2. cortex_relate(from_id=new, to_id=old, relation="supersedes")

   to mark the old information as superseded.
3. Store the resolution as a new decision node.

Node Kinds Cheat Sheet

fact

decision

goal

event

pattern

observation

preference