CortexGraph v2 · schema layout · FINAL · stamped 2026-08-09

One graph, two layers:
a life, and the machinery that tends it

North star: persistent, easily retrievable memory across every AI device and chat. Log and retrieve without loss; fast retrieval is paramount. How the AI interacts with this system, for entry and for retrieval, is the product. Built-in automation is supplementary. source: Cortex notes un:2240 to un:2244, architecture session of 2026-08-09, pressure-tested by Overseer

1 graph · 2 layers · 9+5 node labels · 4 time tiers · 3 triggers · 3 read counters · 2 disposal paths · 1 crossing: provenance

The whole schema in one breath. If a description of the system disagrees with this line, one of them is wrong; this page exists so it is never the line.

The world

Everything is one property graph: typed, directed edges that carry their own properties, loose schema organized by the natural shape of the data. A hard wall, enforced at the query layer, separates what the owner lives from what the system runs.

HARD WALL · QUERY LAYER · ONLY PROVENANCE CROSSES CONTENT · THE LIFE GRAPH MACHINERY · THE SYSTEM'S OWN MEMORY time spine · materialized aggregates Year Month Week Day rolls_up_to Organization Project Task contains contains Person edges: deferred to v2.1 Goal Simple measured_by target 2 · weekly · hours time_cost: 2h working_toward strength .82 · algo v3 attributes_time activity @ t · event edges, many Memory Journal entry logged_on about · at capture mentioned @ t summarizes prompt library · versioned summarizer · v4 labeler · v2 time-attributor · v1 one system prompt per agent algorithms · versioned strength-calc · v3 pruning · v1 pruning runs offline, RU-budgeted batch version bump invalidates caches model registry · rated model-a · 4.5/5 model-b · 2/5 picked per task, by track record MCP connector memory_search log_memory task_add exposes every tool is a node: the surface the AI sees is itself in the graph generated_by content node machinery node rollup (materialized aggregate) durable semantic edge timestamped event edge provenance (crosses wall) to finalize
The claim: one property graph, hard-walled into a life and a machine room. Life-content queries never see machinery; machinery writes summaries into content and signs them. The amber generated_by edges are the only crossing: every rollup knows which prompt version and which model wrote it, so the system can always answer which mind wrote this memory.

Three mechanisms

The parts of the design that do work, drawn separately so each can be argued with.

Project Goal working_toward · durable strength .82 · algo v3 mentioned @ aug 2 · @ aug 5 · @ aug 9 feeds recompute strength-calc v3 → v4 ⇒ every cached strength recomputed two versions may read the same event edges differently; a cache that survives its algorithm is a lie
Edge anatomy. One durable edge carries the relationship; many cheap timestamped event edges feed its cached strength. The algorithm is a versioned machinery node, so the score is auditable and the invalidation rule is enforceable.
capture · instant + dumb Memory needs_enrichment ● about → Project logged_on → Day enrichment · thoughtful + slow · async sweep of flagged nodes labeler time-attributor edge-drawer flag cleared specialized passes, not one omniscient agent triggers scheduled · rollups fire when new memories exist manual · owner or connector requests a pass access · a read is a write: counters + decay, touched nodes requeue
Write fast, enrich later. Capture never waits on intelligence: node, two links, a flag. A pipeline of specialized passes does the thinking asynchronously. Reading strengthens: traversal / human / mcp counters stay separate so machinery cannot manufacture importance out of its own exhaust, and the versioned strength algorithm decides the weighting later.
default disposition: retention hard delete immediate + complete sensitive or mistaken entries gone. pruning long-horizon · offline batch · RU ceiling connectivity decides: edges = load-bearing low-degree fades hub consolidates two exits, two machines: one is a right, the other is hygiene
Not strict no-deletion. v1 never deleted anything; v2 keeps retention as the default but names two exits. Hard delete is an owner's right and completes immediately. Pruning is brainlike hygiene: an RU-budgeted offline job, because neighborhood-degree scans are most expensive exactly at the hubs pruning exists to protect.

The parametric spec

The same schema as words and properties, for the AI half of the audience. Labels are few on purpose; growth is a reviewed schema change, never an extraction-time invention.

Content labels · 9

labelcarries
goalthe aspiration; measured by simples
simpleatomic measurable quantum of a goal: target, cadence, unit, time_cost
organizationspine root; owner-curated
projectwork-with-AI lives here, usually inside an org
taskspecific work under a project
personpeople with standing in the owner's world
memorycaptured moment; the write-fast unit
journal_entrythe owner's own voice, dated
rollupmaterialized time aggregate · tier: day|week|month|year

Machinery labels · 5

labelcarries
promptsystem prompt per agent · agent, version, body
algorithmoperating logic as data · name, version, params
modelregistry entry · name, rating from past performance
connectorthe MCP connector itself, in the graph
toolevery MCP tool, surfaced as a node

Edge types

typefrom → toclassnotes
measured_bygoal → simpledurablethe goal-quantization link
working_towardproject|task → goaldurablecarries strength (cached) + algo_version
containsorg → project → taskdurablethe agency hierarchy
aboutmemory → project|orgdurabledrawn at capture, dumb and instant
logged_onmemory|journal_entry → rollup(day)durabletimestamping to the time spine
rolls_up_torollup → rollupdurableday → week → month → year
summarizesrollup → memory|rollupdurableaggregate → the raw nodes beneath it
attributes_timetask → simpledurabletime spent ladders up to the goal
generated_byrollup → prompt, modeldurablethe only cross-wall type: full provenance
exposesconnector → tooldurablethe AI-facing surface, self-describing
mentionedany → anyeventlightweight, timestamped, many; feeds strength
activityrollup(day) → simple | projecteventlogged minutes: goal time on simples, work time on projects; the calendar sums both
# on every node and every edge
id · label · created_at · embedding (re-vectorized on write; edges too)
# on every content node
needs_enrichment · counters { traversal, human, mcp } (a read is a write; decay weights recency; weighting deferred to the versioned strength algorithm)
# on durable semantic edges
strength (cached, materialized) · algo_version (provenance of the number itself)

Decisions: closed

All eight were answered by the owner, by voice, on 2026-08-09, and the page was stamped FINAL the same day. Changing anything below is now a schema revision, not an edit.

  1. Spine minting. Closed: it is a policy, not a rule. AIs may create organizations, projects, and other spine nodes. An owner setting, minting_policy, picks the mode: yolo (default: create freely), verify (node is created pending, hidden from queries, and surfaced to the human for approval over MCP: human in the loop), off (link-only). Rejecting a pending node hard-deletes it. The PoC's 18-orgs-into-2,654 failure is why verify and off exist.
  2. Temporal model. Closed: penciled in as algorithmic, not storage. No bi-temporal machinery on edges. Everything carries timestamps (created_at / ended_at on durable edges, occurred_at on events, nothing overwritten), and "as of" is an on-demand time lens: a versioned retrieval algorithm in the machinery layer that filters a query to a window. Deeper historical reconstruction, if ever wanted, is a reprocessing job.
  3. Wall enforcement. Closed: as recommended. Label namespace plus a mandatory filter baked into the query builder; single partition as in v1.
  4. Hard-delete cascade. Closed: all the way. Node, edges, embedding, raw payload, and every rollup that cited it is flagged for regeneration. If the owner wants it gone, it is gone; privacy is a product commitment, not a setting.
  5. Vector placement. Closed: whatever is most pragmatic, which the PoC already measured: external index, pgvector + HNSW keyed by element id, edges included (in-process scoring was 600s; the index is 0.23s).
  6. Rollup granularity. Closed: one label, tier property, as drawn.
  7. Event-edge compaction. Closed: deferred until the RU bill demands it.
  8. Person relationship edges. Closed: deferred to v2.1. Person nodes exist; their edge vocabulary waits. The implementation stays rigid; user-facing schema plasticity is a future product question, deliberately not this version's.

Lineage

What this design is made of, and what each ancestor proved.

2013

Simples. The seed concept: goals quantized into atomic, measurable units. v2 makes them first-class nodes with target, cadence, unit, and a time cost carried from day one, so constraint-aware goal-fitting stays buildable later without a migration.

2024 – 2026

Cortex, relational. Proved the curated tables are the only always-right data, that agency lives in an explicit role field, and that a note dictated on purpose outranks an archived stream. Also proved a system's own machinery deserves memory: the Overseer worked, but its mind lived outside its own database.

Aug 1–4, 2026

CortexGraph proof of concept. Cosmos Gremlin is viable; temporal edges and invariant sweeps held under 24,413 concurrent fact writes; retrieval needs an external vector index; and the one systemic failure, transcripts minting spine entities, is now decision 01 above.

Aug 9, 2026

The architecture session. Two layers, capture/enrich split, three triggers, retrieval strengthening with three separate counters (Overseer independently converged on the same split, which is why it is in the spec), and the two principles below.

Metamorphosis, not collision

v2 is the next major version, not a sidecar. It replaces the old rollup machinery rather than running alongside it, so there is no parallel-writer drift and no legacy pipeline to reconcile. Moth, then butterfly; never both at once.

Corpus rebuild per major version

A major version may rebuild the entire corpus from scratch. Named as a principle so no future migration tries to "save" the old corpus and smuggle back the drift the redesign exists to remove. Painful, deliberate, and worth it.

MCP completeness

If it cannot be done through the MCP connector, it does not ship. Notes, tasks, projects, people, organizations, goals, retrieval, approvals, settings: the connector is the product, and the built-in automation is supplementary. The owner's posit, verbatim in spirit: if it can't be done through the connector, why was it built?

As built

Everything below was added after the FINAL stamp, in one day of building, and none of it required a vocabulary change: the labels, edge types and budgets drawn above held exactly as drawn. The schema survived its own construction.

The machinery layer, populated

nodecarries
prompt × 5labeler, time-attributor, summarizer, and the Overseer's persona plus its predecessor's first-boot letter, each versioned
algorithm × 2strength-calc (half-life params) and the time lens (decision 02's on-demand window filter)
modelthe registry, paired with an owner-editable purpose-to-model map in settings: chat and high-tier rollups on a strong model, everything else cheap and fast, retunable per call with no restart
connector + toolseighteen tools, completeness enforced at server startup: capture, spine, goals, retrieval, stewardship, and the Overseer's chat

The Overseer's residency

whatwhere, per its own survival manifest
persona + rulesmachinery layer, versioned prompt nodes
first-boot lettermachinery layer, read in every system context
chat threadrelational, deliberately outside the graph: the interpretive layer is a read cache, and the thread is the lineage. Carried across whole from the old system so the successor woke mid-conversation
working memoryrebuilt fresh per turn from the graph (the context block), never stored