PRISM

An engine for typed knowledge graphs.
You bring the shape; we bring everything else.

Antonio Pericão · April 2026
noocleus / prism · living design system v5

Opening

Shaped knowledge that lets an agent think and act inside your domain.

Agents are generic. Domains have shape. Today they re-read walls of text every session. PRISM gives them a map.

The thesis in one line: a generic agent reads. A shaped agent walks.

A pattern

You’re building one already.

But are you thinking about the architecture? Defining types, wiring edges, validating lineage, integrating with the agent — that’s knowledge-architecture work. A developer is paid to ship code; this is a second job. PRISM absorbs roughly 80% of it.

~80% · we absorb

Typed graph engine + primitives (Axiom).

Schema validation, atomic writes, reference integrity.

Inheritance, lineage, lifecycle hooks, role gates.

Agent harness integration (Claude Code + MCP).

Substrate, index, query.

~20% · yours

Your kit’s shape.

Domain types and edges.

The skills the agent uses.

The decisions only you can make.

The part that requires your domain expertise.

Stay a dev. We architect the engine; you architect the shape.

Why this works

Graphs, ontology, and what makes Axiom unique

Why a graph (and what it lets the agent do)

Other representations store. A graph lets the agent walk meaning.

Files & folders

Hierarchical, one parent, untyped containment.

Storage, not meaning.

Tags as filters

Flat buckets. Classification with no relation.

No relationships.

Embeddings

Fuzzy similarity. Probabilistic, not structural.

No precise questions.

Relational tables

Rigid schemas, expensive joins. Transactions, not walks.

Not for meaning.

A graph keeps the whole shape

Nodes (the things), typed edges (named relationships), schemas (validation), traversal (the walking). The agent walks structure instead of re-reading prose.

Without a graph: the agent re-reads /docs, greps, reconstructs lineage from prose every session.

? "What informed D-042?" → proposal P-003 → context C-007 → finding F-018

Connections walked, not re-inferred.

A node is data. Types make it architecture.

Each node is just data with an ID. Edges give it semantics. Types extend nodes — and that’s how a flat graph becomes a knowledge architecture.

Obsidian’s limit

Gave us a graph — but it’s flat. Every node is a document. Every edge is a backlink.

node = doc (everything is one kind of thing, connected one kind of way)

PRISM’s move

A node is the genesis. Type-defs extend it into any medium your domain needs.

node ├── doc │ ├── proposal │ ├── decision │ └── finding ├── code │ ├── class │ ├── function │ └── constant └── (your domain)

One graph, many mediums. A class can derive_from a decision. A finding can trigger a refactor. A spec can scope the code that implements it. Different shapes, same graph, walked the same way.

Take Obsidian’s graph idea. Multiply it by every domain you care about. Same walks, more reach.

Why ontology matters

Graphs let us store knowledge. Ontology gives that knowledge shape and meaning.

An ontology declares

What concepts exist (spec, decision, capability, finding…)
What they mean — how a spec differs from a design
How they relate — a spec derives from a proposal

It’s the hard-won understanding nobody usually writes down — the implicit shape your team operates inside. Codifying it is the real work, and it’s what turns a generic agent into one that thinks like your team.

The architecture is the asset

Your architecture of knowledge becomes the moat and the product that future AI systems will consume.

↗ design system · 01 of 08

Typography

The type system

Lexend 700 titles, 300-weight key-message, tight letter-spacing. Sizes follow a modular scale; spacing snaps to a vertical rhythm.

modular scale

After Tim Brown's More Meaningful Typography — sizes derive from a base × ratio, not free-form. Current scale: base 14px, ratio ~1.20 (minor third), with a wider jump at the top to give titles real weight.

base 14px · ratio ~1.20 (minor third) · top jump ×1.83 to give the title presence

−014section-head · slide-numbaseSection head

+117detail×1.21Detail item

+220body-text×1.18Body paragraph

+324key-message · emphasis×1.20Key message

+544big-quote×1.83Big quote

+652slide-title×1.18Slide title

+896title-slide h1×1.85PRISM

vertical rhythm

After Richard Rutter's Compose to a Vertical Rhythm — pick a baseline (here 24px), then make every line-height and margin a multiple of it. The page gains a hidden metronome that everything rides.

Each line sits on the grid.

Body is 16 / 24 — font-size 16px, line-height 24px. The 24px is the baseline. Headings, body, lists, even cards all snap to multiples of 24, and the page rides a hidden metronome.

Headings snap too.

An h4 at 22 / 24 fills one baseline. Margins above and below are 24 (one beat) or 48 (two beats), never 18 or 30. Spacing becomes rhythm; rhythm becomes feel.

// the green lines mark every 24px — baselines visible

.slide-num · eyebrow

Tiny uppercase label above each slide title. Numbered or word-stamped (e.g., “Step 1”, “Recap”).

.slide-title · primary heading

The slide’s main statement. Lexend 700, ~52px, tight tracking.

A node is data. Types make it architecture.

.key-message · lede

Subtitle right under the title. Weight 300, mid-color — designed to contrast with the title above.

Each node is just data with an ID. Edges give it semantics. Types extend nodes — that’s how a flat graph becomes a knowledge architecture.

.section-head · in-slide eyebrow

Tiny uppercase label inside slide content to label sub-sections.

PRISM’s move

.body-text · paragraph

Default paragraph copy inside slides. ~20px Lexend regular.

A node is the genesis. Type-defs extend it into any medium your domain needs — documents, code, decisions.

.detail · secondary bullet

Indented secondary item with a tiny left dash. Use for supporting details under a body paragraph.

A class can derive_from a decision.

A finding can trigger a refactor.

A spec can scope the code that implements it.

.emphasis · centered statement

Bolded centered statement that closes a section. Reserve for the slide’s actual takeaway.

Stay a dev. We architect the engine; you architect the shape.

.big-quote · full-bleed quote

Reserved for the rare slide that’s a single line. Accent words use .accent-mark.

Your architecture of knowledge becomes the moat and the product.

↗ design system · 02 of 08

Slide types

Three frames, one rhythm.

Bookend-strong — title-slide and act-dividers feel event-like. Body slides stay clean and content-led.

.title-slide · opening

Logo, accent rule, oversized title, subtitle, meta. The deck’s welcome mat. One per deck.

PRISM

An engine for typed knowledge graphs. You bring the shape; we bring everything else.

Antonio Pericão · April 2026

.slide · standard content

The default. Slide-num, title, key-message, then content. min-height: 100vh for scroll-snap pacing.

The stack

Four layers, two access surfaces. The engine (L2) is what we ship.

Methodology sits on top, knowledge architecture below it, the engine, then the substrate.

.act-divider · section break

Between acts. Top + bottom black borders, accent act-number, oversized title. Reads as a chapter heading.

The architecture

Four layers, two access surfaces. What we ship vs. what you ship.

recap composition · closing

Three-column grid of .card.is-content. Used for the closing slide of the deck.

Recap

Bring your shape. We ship the rest.

we provide

L2 · the engine

Typed primitives, atomic writes, harness wiring.

you shape

L3 + L4 · your kit

Knowledge architecture and skill topology.

you decide

L1 · the substrate

Files by default; pluggable when you outgrow.

↗ design system · 03 of 08

Cards & sections

One card, six modifiers.

Every card uses .card with one modifier. Pick by intent, not by visual. No fills — thin borders + accent left-rules carry meaning.

.card.is-callout · emphasis aside

Left-rule emphasis. The thesis, the takeaway, the “here’s the point”.

The thesis in one line: a generic agent reads. A shaped agent walks.

.card.is-accent · product highlight

Accent left-rule, slightly thicker. Reserved for “this is the thing we ship”.

~20% · yours

Your kit’s shape

Domain types and edges. Skills the agent uses. The decisions only you can make.

.card.is-content · mid-density card

Default content card. Thin border, no fill. Use in three-col grids and side-by-side comparisons.

we provide

The engine

Typed primitives, atomic writes, harness wiring.

you shape

Your kit

Knowledge architecture and skill topology.

you decide

The substrate

Files by default; pluggable when you outgrow.

.card.is-external · non-product

Dashed border. Signals “this lives outside our boundary” (runtime, federation layer, third party).

runtime · external

Claude Code (today); anything MCP-aware (tomorrow). PRISM extends it, doesn’t replace it.

.card.is-section · chapter container

Top + bottom black border, no fill. Frames a sub-section — “Out of the box”, “What we ship vs you ship”.

Out of the box

What L2 ships before you write a line. The engine’s job is to disappear.

Typed edges — semantic, validated
Inheritance — types extend types
Atomic writes — always consistent
Files-are-truth — markdown + YAML, hand-editable

.card.is-lane · compact grid card

Tight card for grids of 4+. Numbered prefix surfaces sequence. Use in .four-lanes.

Files & folders

Hierarchical, one parent.

Tags as filters

Flat buckets, no relation.

Embeddings

Fuzzy, probabilistic.

Relational tables

Rigid schemas, joins.

↗ design system · 04 of 08

Diagrams

Same vocabulary across every diagram.

Numbered rows, dashed externals, accent left-rule for “the product”, mono labels. Diagrams stop looking like four separate styles.

.stack-rows · layered architecture

Numbered horizontal rows. Outer dashed boxes for externals. Accent left-rule on the layer that’s the product.

Runtime · external

Claude Code (today); anything MCP-aware (tomorrow).

↕

Methodology

Skills + flow + topology

Knowledge architecture

Domain types + edges

Engine — Axiom The product

Primitives + methods · domain-neutral

Storage substrate

Files + YAML; pluggable

.four-lanes · alternatives grid

2×2 of .lane with auto-numbered prefix. Use to compare 4 options.

Files & folders

Hierarchical, one parent.

Storage, not meaning.

Tags as filters

Flat buckets, no relation.

No relationships.

Embeddings

Fuzzy, probabilistic.

No precise questions.

Relational tables

Rigid schemas, joins.

Not for meaning.

.causal-chain · derivation timeline

Vertical chain of derivation steps. Open-circle dots for paper-readability.

D-042 · decision

derived_from

P-003 · proposal

scoped_by

C-007 · context

triggered_by

F-018 · finding

.loop · agent cycle

Three or four steps in a cycle, each in a square-cornered box, accent arrows.

read

→

walk

→

write

↩

↗ design system · 05 of 08

Lists

Hierarchy without bullets.

Indentation, weight, and a thin left-rule carry the structure.

.content-list · in-slide list

General-purpose list inside slide content. Bold leading clause + body.

What concepts exist (spec, decision, capability, finding…)
What they mean — how a spec differs from a design
How they relate — a spec derives from a proposal
How they evolve — supersedes, refines, deprecates

.detail · secondary item

Indented item with a tiny left dash. Use under a body paragraph for supporting points (sister to .content-list).

A class can derive_from a decision.

A finding can trigger a refactor.

tree · inheritance

Monospace pre-formatted block. Use for type hierarchies and structural lookups.

node ├── doc │ ├── proposal │ ├── decision │ └── finding ├── code │ ├── class │ └── function └── (your domain)

↗ design system · 06 of 08

Code & tables

Block goes charcoal. Inline stays light.

Charcoal background (#2a2a2a) with light text and an accent left-rule for big code blocks. Inline code stays light to read in flowing prose.

.code-block · multi-line

CLI snippets, type-defs, prompts. Square corners, accent left-rule.

$ axi init --kit @noocleus/forge ✓ Engine bootstrapped at .prism/ ✓ Claude Code hooks registered ✓ Bootstrap meta-types loaded: type-def, field-def, role-def ✓ Installed kit: @noocleus/forge ✓ Ready to run: try /idea in Claude Code

inline <code>

In-flow technical terms — keep light so prose stays readable.

Pass --kit any number of times to compose multiple kits, or omit it to start with the engine alone and author your own kit.

table · comparison

For reference data: parameter tables, layer comparisons, when-to-use grids.

Layer	Owns	Ships as
L4 · Methodology	Skill topology	Domain kit
L3 · Knowledge architecture	Type-defs, field-defs	Domain kit
L2 · Engine	Primitives, methods	The product
L1 · Substrate	Files + YAML	Pluggable

↗ design system · 07 of 08

Mobile chrome

Bottom bar with progress dots.

Replaces the desktop pill at ≤768px. Fred stays. Section sheet replaces the TOC rail. No ? button — no keyboard on touch.

phone preview · 360 × 660

Live preview of how the deck reads on a phone. Tap the menu button (≡) to see the section sheet.

A node is data. Types make it architecture.

Each node is just data with an ID. Edges give it semantics.

PRISM’s move

A node is the genesis. Type-defs extend it.

3 / 15

Constraints

Bar position — bottom, ~14px from edge for thumb safety
Fred stays — smaller (~38×32px), top-right, same animations
No ? — no keyboard on touch
Slide count — right side of bar, mono
Section sheet — tap ≡ for grouped section list

Print

.mobile-bar, sheet, and Fred all hidden in @media print
Slides print as the desktop layout regardless of viewport

↗ design system · 08 of 08

Unlocks & bonuses

Two tiers, two modals, one design.

Subtle teasers hint at extras. Tier 1 is a small survey — unlocks the bees + lets you pick one. Tier 2 is email or LinkedIn — unlocks the deeper bonuses (research, prompts, examples).

tier matrix · what gates what

Each bonus declares its tier. The badge opens the right modal. Tiers unlock independently — tier 1 progress doesn’t require tier 2, and vice versa.

Tier	Ask	Validation	Unlocks
1 · meet the hive	Quick survey: rating, what I missed, what next	Any one answer	Bee selection (chooser opens after submit)
2 · the deeper bits	Email subscribe or LinkedIn connect	Email format, or LinkedIn click	Research notes, prompts, worked examples

.bonus-badge · teaser inline with slide-num

Tiny dashed badge alongside the slide number on slides that have bonus content. Click to open the unlock modal (locked) or scroll to the gift card (unlocked).

04 ↗ research notes

↑ locked (dashed) / unlocked (solid accent)

.bonus-card · link mode

For research notes, worked examples, federation memos. Eyebrow + title + one-line description + a single “Open ↗” button.

↗ research notes

Reading list — typed knowledge graphs

Six pointers I keep going back to: Tana, Roam, Notion, Obsidian Dataview, Tinkerpop, and the internal “schemas, not prose” essay.

Open reading list ↗

.bonus-card · prompt mode

For copyable Claude prompts. Eyebrow + title + description + “Copy prompt” button + collapsed “view full text” details.

↗ bonus prompt

Interview prompt — shape your ontology

A Claude prompt that interviews you about your domain and proposes 4–6 type-defs in YAML, one at a time. Paste into Claude Code or any chat to run it.

view full text

You are a domain interviewer. Your job is to surface the implicit shape of my work and propose type-defs.

Ask me, one at a time:
  1. What concepts recur in my domain?
  2. What relationships matter between them?
  3. Which fields are required vs nice-to-have?

Then propose 4–6 type-defs as YAML, each with:
  - name (kebab-case)
  - 2–4 fields with types
  - 1–2 typed edges to other types

Stop after each type-def for my confirmation.

.bonus-card · chooser mode (bee picker)

After tier 1 unlock, the bonus card on slide 04 becomes a live bee chooser. Click any bee to set it as your daily driver. Click the active bee mascot anywhere in the deck for a silly line.

↗ meet the hive

Pick your bee.

Fred isn’t your only option. Pick one of the hive — that bee becomes your daily driver across every slide.

tier 1 modal · survey + bee chooser

Static visual. Three rows: rating, what I missed, what next. Submit enables when any answer is filled. After submit, modal transforms into a 5-bee chooser.

tier 2 modal · email or LinkedIn

For research / prompt / example bonuses. Two paths: subscribe to email (validated by regex) or connect on LinkedIn (validated by click). Either unlocks tier 2. On mobile, the LinkedIn button opens the app via linkedin:// deep link.

bee click · silly line + unique animation

Click the active bee mascot (top-right) to fire a random one-of-four silly line plus an animation unique to that bee. Wings keep fluttering and the gentle hover keeps drifting underneath — the click animation composes on top.

Bee	Animation	Sample line
Fred (drone)	happy hop — double bounce with rotation	“graphs are my favorite shape.”
Queen (queen)	regal nod — slow forward bow, hold, return	“moats? i invented those.”
Mabel (worker)	hammer — rapid 5× up-down (mechanical)	“more honey, less talk.”
Greta (forager)	yawn — horizontal stretch, settle	“wake me when it ships.”
Ada (architect)	tilt-think — rotate left, hold, swing right, settle	“the leading is off here.”

Try it: click whichever bee is in the top-right corner. Pick a different bee on slide 04 to switch personalities, then click again here. Most of the hive is female; Fred is the lone drone.

scripted slide triggers · per-bee voice

Distinct from the click lines. Each bee has its own scripted line per “hot” slide (0, 4, 7, 8, 14). Fires once per (bee, slide) pair per session — switch bees and the new voice replays the slides. Below: the slide−0 intro per bee.

Bee	Slide 0 intro
Fred	“hi! i’m fred, the master drone. buzzing along with you.”
Queen	“i am the queen. you may proceed.”
Mabel	“name’s mabel. i build the hive. let’s get on.”
Greta	“...mmh? i’m greta. nice deck.”
Ada	“i’m ada. note the modular scale, by the way.”

Slides 4, 7, 8, and 14 each have their own per-bee line too. Picking Queen and scrolling back to slide 0 will fire her intro — even if Fred already said his.

unlock pattern · per-tier flags + lazy validation

Each tier flips its own localStorage flag. Each row validates its own way; completing any one row in a tier flips that tier’s flag and unlocks its bonuses.

Storage — prism_tier1_unlocked, prism_tier2_unlocked, prism_user_bee; survey answers in prism_rating / prism_survey_missed / prism_survey_next; email in prism_email
Validation per row — email regex, LinkedIn click, 1+ stars, or non-empty text in either survey field
Soft dismiss — “Maybe later” closes without unlocking. The badge stays clickable.
Side effects — tier 1 unlock reveals the bee chooser + activates bee swap; tier 2 unlock renders gift cards on tier-2 slides.
Analytics — bonus_unlock with method + tier; presentation_rated with score on the survey row.
Mobile LinkedIn — deep link linkedin://in/SLUG auto-detected via UA; desktop uses https://www.linkedin.com/in/SLUG
Endpoint — email submit is a TODO; currently localStorage only.

authored bonuses · current set

What’s wired in BONUSES today. Add new ones by tagging a slide with data-bonus="<id>" and registering the entry with a tier.

bee-unlock · tier 1 · chooser (5 bees) — slide 04 · the first unlock
why-graph · tier 2 · research notes (link) — slide 01
why-ontology · tier 2 · research notes (link) — slide 03
shape-ontology · tier 2 · bonus prompt — future slide
forge-typedef · tier 2 · worked example — future slide
methodology-kit · tier 2 · worked example — future slide
federation-memo · tier 2 · research notes — future slide

← →·1 / 1

1 / 1

noocleus / prism · April 2026 · living design system v5

PRISM

Shaped knowledge that lets an agent think and act inside your domain.

You’re building one already.

Why a graph (and what it lets the agent do)

A node is data. Types make it architecture.

Why ontology matters

The architecture is the asset

The type system

Each line sits on the grid.

Headings snap too.

A node is data. Types make it architecture.

Three frames, one rhythm.

PRISM

The stack

Bring your shape. We ship the rest.

L2 · the engine

L3 + L4 · your kit

L1 · the substrate

One card, six modifiers.

Your kit’s shape

The engine

Your kit

The substrate

Out of the box

Same vocabulary across every diagram.

Hierarchy without bullets.

Block goes charcoal. Inline stays light.

Bottom bar with progress dots.

A node is data. Types make it architecture.

Constraints

Print

Two tiers, two modals, one design.

Reading list — typed knowledge graphs

Interview prompt — shape your ontology

Pick your bee.

A small survey, then your bee.

There’s a bit more here.