The Five Elements Spine: Personal OS Architecture Guide
Every Element can be built at four levels of sophistication. Higher is not better by default, it is more capable and more expensive to keep working.
Time to read: about 11 minutes
The five Elements were named in July 2026, in a working session prompted in part by an exchange with Mike Gardon, and tested against his four-step cycle for bringing on a chief of staff: onboard, scope, review, and feedback. This guide has one tab per Element. Each tab opens with what the Element is for, then sets out the same four tiers against the same criteria, so you can compare tiers across Elements. What follows is how to decide how far to build each one.
Every Element (Memory, Boundary, Surface, Loop, and Cadence) can be built at four levels of sophistication. What follows is the tradeoffs at each tier, so the choice is informed rather than default. Four tiers run through every Element: Beginner (no new tools, pure discipline), Intermediate (a tool you probably already use, repurposed), Advanced (a tool built for this job, used deliberately), and Highly Technical (custom infrastructure, built and maintained like software, because in this tier it is software).
Higher is more capable, more durable, and more expensive in time to build and keep working, but the right tier for you is the one where the effort you are willing to sustain matches what you are trying to get out of it. Higher is not better by default.
How to use this guide
Pick a tier per Element, not one tier for all five. Most real systems are mixed: a highly technical Memory paired with a beginner-tier Cadence is common and often correct, because the two Elements do not need the same level of investment to be worth having. Jay's Advisor OS is the guide's example of the Highly Technical tier, rated against these criteria rather than assumed to be the ceiling. It is one working system, not the standard to match.
What a tier costs
Each Element's table asks the same eight questions, which is what makes the tiers comparable across Elements. Three of them describe what you get: what the tier is, what it actually does, and how far into the future it survives. Three describe what it costs: effort to build, effort to maintain, and the expertise the tier assumes. The last two are the ones people skip and then regret. Cost is usually the least interesting, because at every tier below the highest it is close to nothing, and at the highest the money is rarely the constraint. Audit trail is the one that determines whether the system can be used for defensible work.
Read the maintenance row before the build row. Almost every tier in this guide is affordable to build, so the difference between them is what happens afterward. A Beginner tier costs nothing to stand up and asks for constant vigilance forever. A Highly Technical tier costs days or weeks and then asks for very little per cycle, right up until something in the pipeline breaks and you are the only person who can fix it. The question is which tier you will still be running in six months.
Where the tiers stop being comparable
The tiers do not mean the same thing for every Element. For Memory and Surface the higher tiers mostly buy durability and reach, and the lower tiers do work for a while. For Boundary the higher tiers buy something different in kind, because the Beginner tier is you remembering to check, and a system that depends on your vigilance is not a boundary so much as an intention. For Loop the Beginner tier is the one most likely to be abandoned, which is why a low tier there tends to decay into no tier at all rather than staying where you put it.
The ladder is a way to see the tradeoffs, not a score. Two people can sit at the same tier across all five Elements and have systems that behave nothing alike, because the tier says how much machinery is involved, not how well it fits the work.
The takeaway
The point is to know which tier you are building at, per Element, on purpose, rather than by default or by accident. A Beginner-tier Memory paired with a Highly Technical Cadence is a coherent choice for someone for whom forgetting to check in is a bigger risk than losing information. Picking a low tier is reasonable, provided you know which tier you picked.
Companion to Two Memories, Not One. Current as of September 2026.
Memory
What it holds, so nothing starts from zero
Memory is whatever a system already knows without being told again: who you are, what you are working on, and what happened last time. Without it, every interaction starts from a blank page, and nothing ever accumulates. Grade your own system by asking what you had to re-explain this week that you should not have had to.
Claude Memory is not on this ladder. It is a separate, always-available layer regardless of which tier below you build, useful for light, ambient context but not a substitute for anything here. This is covered in depth in Two Memories, Not One.
| Beginner | Intermediate | Advanced | Highly Technical | |
|---|---|---|---|---|
| Example | A running note (Apple Notes, a single doc) | A structured Google Doc or set of Docs | Notion workspace | GitHub repository, markdown files, possibly a vector index |
| What it does | Holds whatever you type into it, read manually | Sections by topic, findable by search, shareable | Databases, linked pages, tagging, real structure | Versioned, git-diffable, readable by any tool with repo access, scriptable |
| Effort to build | Minutes | An afternoon to structure | A few days to set up well | Days to weeks |
| Effort to maintain | Low, but easy to let it sprawl | Low to moderate, needs occasional pruning | Moderate, structure needs upkeep as it grows | Ongoing, real engineering discipline |
| Expertise needed | Beginner | Beginner to intermediate | Intermediate | Advanced to highly technical |
| Cost | Free | Free to low | Free to $10 to 20/month | Low direct cost, high time cost |
| Future-proof | Low, ties you to nothing but also organizes nothing | Moderate, portable as text but not structured data | Good, exportable, widely integrated | Excellent, outlives any single tool by design |
| Audit trail | None | Google's own version history, coarse | Page history, moderate | Full commit history, exact and permanent |
On a narrow screen the tier tables scroll sideways
It is Highly Technical, and runs on GitHub plus a Pinecone vector index, namespaced by engagement, with a GitHub Action that auto-ingests on every push. Most of the cost at this tier is the pipeline around the documents. Standing up an embeddings pipeline and a namespace routing scheme takes more than a weekend. This is the tier where the line between "my notes" and "software I maintain" disappears.
Boundary
What it may do, versus what it only proposes
Boundary is the line between a system that suggests and a system that acts, and whether you drew that line on purpose. Without a clear boundary, either nothing happens without you in the loop, or things happen that should have waited for you. Grade your own system by asking whether you actually know, for each thing it touches, if it is allowed to act or only allowed to propose.
| Beginner | Intermediate | Advanced | Highly Technical | |
|---|---|---|---|---|
| Example | Manual review, every time | Connector permission settings | Written custom instructions or a project-level policy | A review-gate architecture: staged drafts, explicit approval before anything commits |
| What it does | You read every output before acting on it, no system enforces this | Read-only versus write-enabled access, set once per tool | A standing document telling the system what it may and may not do unprompted | A structural distinction between what a system proposes and what a human authorizes, enforced by the tooling, not just a request |
| Effort to build | None to build | An hour per tool | A few hours to write well | Days to weeks |
| Effort to maintain | Constant vigilance, which is the whole cost | Low, mostly set-and-forget | Moderate, needs revisiting as work changes | Ongoing, a real piece of infrastructure |
| Expertise needed | Beginner | Beginner to intermediate | Intermediate | Advanced to highly technical |
| Cost | Free | Usually free | Free | Low direct cost, high time cost |
| Future-proof | High, since it depends on nothing but you | Moderate, tied to each tool's own settings | Good, portable as a document even if the enforcement is not | Excellent, the discipline outlives any one tool |
| Audit trail | None, it lives in your head | Whatever the tool logs, usually thin | The instructions themselves, if versioned | Complete, since every approval is itself a recorded event |
Highly Technical here too, and this is the clearest example of that tier actually paying for itself. Unattended work stages in a drafts folder and waits for explicit sign-off, while supervised, in-session work can commit directly. An automated classifier blocks unprompted writes to shared resources. Nothing gets overwritten without a review first.
Surface
How it reports back, in a form you can review
Surface is how the work reaches you: a reply, a document, a dashboard, or another clear way to review rather than something you have to go hunting for. A system with no surface is one you cannot check on, no matter how good the work underneath it is. Grade your own system by asking whether you would notice if something went wrong.
| Beginner | Intermediate | Advanced | Highly Technical | |
|---|---|---|---|---|
| Example | Reading the chat itself | A recurring email or message digest | A living shared document | A published, access-controlled site |
| What it does | The conversation is the surface, nothing else exists | Periodic summary sent somewhere you already check | An always-current page someone can open and read the current state | A real interface, possibly with an anonymized view for sharing without exposing sensitive detail |
| Effort to build | None | An hour or two to set up | A day to structure well | Days to weeks, real design and build work |
| Effort to maintain | None | Low | Moderate, needs someone keeping it current | Ongoing, it is a small piece of software |
| Expertise needed | Beginner | Beginner to intermediate | Intermediate | Advanced to highly technical |
| Cost | Free | Free to low | Free to low | Hosting costs, usually small |
| Future-proof | Low, nothing persists past the chat | Moderate | Good | Excellent if maintained, but a dead site is worse than no site |
| Audit trail | None | Whatever your email retains | Document version history | Full deploy and edit history |
It is Highly Technical and includes gray mode, an access-controlled view that anonymizes client and contact detail so the working system can be shown to someone without exposing what is in it. That is an advanced capability, not something most people need to replicate, but it shows where the ceiling is.
Loop
How your corrections change the next cycle
Loop is whether correcting something once means it stays corrected or it resurfaces and requires constant intervention. Without a loop, a system does not get better, it just repeats itself faithfully, including its errors. Grade your own system by asking what you have corrected more than once.
| Beginner | Intermediate | Advanced | Highly Technical | |
|---|---|---|---|---|
| Example | Remembering to fix it next time | A periodic manual review, on your calendar | A structured review template you run yourself | A built, repeatable audit routine |
| What it does | No system, just intention | You sit down and reread and correct things on a schedule you set | A checklist or set of prompts that make the review consistent rather than ad hoc | A skill or script that runs the review for you and proposes the updates, rather than you doing it from scratch each time |
| Effort to build | None | An hour to set the habit | A few hours to design | Days, real design work |
| Effort to maintain | Constant, and the easiest tier to abandon | Requires doing it | Moderate, template needs occasional revision | Ongoing, but far less per cycle once built |
| Expertise needed | Beginner | Beginner to intermediate | Intermediate | Advanced to highly technical |
| Cost | Free | Free | Free | Low direct cost, high upfront time cost |
| Future-proof | Low, entirely dependent on memory and discipline | Moderate | Good, the template travels with you | Excellent, and it improves itself as you refine the routine |
| Audit trail | None | Whatever notes you take during review | The review notes themselves, if kept | Complete, since the routine's own output is the record |
It is Highly Technical. The module-audit skill exists because a fact went stale and no routine was in place to catch it. This tier was reactive here, built after a real miss, not proactively designed in advance. That is a normal way to arrive at this tier.
Cadence
How it shows up, on a rhythm rather than when summoned
Cadence is whether a system shows up on its own schedule or only when you remember to ask. Without cadence, everything is reactive. The things that matter most (a weekly check or a fact re-verified before it goes stale) are the things most likely to get skipped. Grade your own system by asking what you meant to do regularly and have not.
| Beginner | Intermediate | Advanced | Highly Technical | |
|---|---|---|---|---|
| Example | Ad hoc, whenever you think of it | A recurring task in a to-do app | A scheduled routine with real steps attached | Automated triggers on an event, not a clock |
| What it does | No rhythm, genuinely reactive | A reminder fires on schedule, you still do the work by hand | The reminder comes with the checklist or prompt attached, not just "do the thing" | Something runs automatically when a real condition is met, a push, a new document, rather than on a timer at all |
| Effort to build | None | Minutes to set up | An hour or two | Days |
| Effort to maintain | None | Low | Low to moderate | Low once built, real cost is the initial setup |
| Expertise needed | Beginner | Beginner | Intermediate | Advanced to highly technical |
| Cost | Free | Free to low | Free to low | Usually low, sometimes hosting cost |
| Future-proof | Low | Moderate | Good | Excellent |
| Audit trail | None | The app's own completion log | Whatever the task tool records | Complete, every trigger and run is logged |
Module 4 puts your brief on a scheduled task that runs on a clock with no one starting it. That falls between two columns. It goes further than Advanced, because nobody has to press go, and it is far less work than Highly Technical, because there is nothing to build or host and it runs on a clock rather than on an event. Read it as Advanced that runs itself. The fallback, a calendar event or to-do with your brief prompt attached, is Advanced as written: the steps travel with the reminder, and you still start each run.
Highly Technical for the parts that matter most: a GitHub Action fires automatically on every push touching the knowledge base, and no one has to remember to run it. The Todoist task for the Field Note is an Intermediate-tier piece of the same system: it contains a deadline and a reminder, but a human still has to do the work when it fires. Both tiers coexist inside the same practice, which is normal.