Cade

A personal agentic operating system that connects Claude Code to a structured Obsidian memory vault, retrieves the context each task needs, and carries useful outcomes from one session to the next.

Private system · public case-study site · Jul 2026 – Present

My role

Designed and built the operating system, its memory architecture and Jobs, and the public case-study website.

Case-study website GitHub showcase

Illuminated orange architecture of rooms and pathways, representing Cade's memory structure.

The problem

Modern models can analyze, write, and build at a high level, but their usefulness drops when the context behind the work disappears between sessions. My projects carry decisions, constraints, corrections, and open tasks that cannot be rebuilt reliably from a short prompt, and re-explaining them wastes time and makes the output less consistent.

Chat history preserves conversations. It does not give you a structured, task-aware memory across many projects and recurring workflows.

My contribution

I designed the operating loop, the vault structure, and the Job format, and I use and maintain the system across my own analytics, development, business, and writing work. I also built the public website that explains the system without exposing its private contents.

What I built

Cade runs every session through a five-stage loop: Orient, Retrieve, Prime, Execute, and Persist. Short operating rules load at the start of each session, while deeper project knowledge stays in a plain-Markdown Obsidian vault and is retrieved only when relevant.

Recurring work is organized as Jobs. A Job names the procedure to follow, the quality bar to meet, the references to load, and the lessons from earlier attempts, so repeated work improves instead of starting over.

Orient: load identity, operating rules, active priorities, and the system map.
Retrieve: follow indexes and links to the smallest useful set of notes for the task.
Prime: attach the matching Job's procedure, standard, and lessons.
Execute: do the work with focused context and verify the result.
Persist: write verified outcomes, corrections, and open work back to the vault.

How it works

Two boot layers keep always-on rules small, and everything else is retrieved through a connected memory system.

Boot config (CLAUDE.md)
Vault index
Job
Linked context
Work + verification
Persisted outcome

Boot layer

A concise configuration defines identity, operating rules, permission boundaries, and the connection to the vault.

System map

A vault index explains how the vault is organized and points to active projects, priorities, and the next relevant source.

Memory layer

Obsidian Markdown: project folders, priorities, daily notes, Jobs, a living profile, indexes, and wikilinks.

Public interface

A Next.js, TypeScript, GSAP, and Three.js website documents the architecture while keeping vault content private.

Cade architecture diagram: two boot layers, CLAUDE.md and VAULT-INDEX.md, above the path from boot config to persisted outcome. — From Cade's own documentation: two boot layers feeding one memory system.

Key decisions

Separate always-on rules from searchable memory.

Only the instructions needed for safe, consistent operation load automatically. Larger project knowledge stays searchable, so the system stays focused.

Retrieve the smallest useful context.

Cade follows indexes and links to what the task needs instead of loading or summarizing the whole vault.

Turn recurring work into Jobs.

A Job carries procedure, quality expectations, references, and lessons together, so repeated work gets better over time.

Keep the human in control.

Persistent context does not grant more authority. External communication, deployments, commits, and sensitive edits stay behind explicit approval.

Tradeoffs

Continuity vs. stale context: Memory is only useful while it is accurate, so completed priorities leave the active queue and verified outcomes replace assumptions.

Public explanation vs. privacy: The website shows enough depth to demonstrate the design while keeping personal memory, employer information, and credentials out of view.

Outcomes & evidence

Cade gives my work one consistent operating model across analytics, development, operations, education, content, and career preparation, replacing context that used to be rebuilt by hand in every conversation. The public case-study site at cade.davishiggins.com explains the loop, the memory architecture, the Jobs, and the human-control model.

Scope & limits

Cade is a private working system built on Claude Code; it does not train a model or act autonomously outside approved boundaries. This portfolio's assistant is a separate public tool and cannot reach Cade's memory.