The infrastructure behind a persistent AI collaborator
Use arrow keys, swipe, or the buttons below to navigate
The Amnesiac Genius Problem
An LLM is a brilliant contractor with total amnesia — extremely capable in the moment, but:
No memory — it forgets everything between sessions
Finite attention — it gets worse the more you dump into its head at once
No consistency — left alone, it does the same task differently every time
Our bet: you don't fix this by waiting for smarter models. You fix it with infrastructure around the model. Every slide that follows is one piece of that infrastructure.
1 · The Universal Instruction File
One file defines who the agent is and how it operates — loaded automatically at the start of every session, in any AI environment.
AGENTS.md — mirrored as CLAUDE.md and GEMINI.md, so the identical operating manual loads in any harness.
The constitution — critical protocols, file organization, operating principles.
Re-read cold every time — nothing depends on the model "remembering" the rules.
2 · The Three-Layer Architecture
LLMs are probabilistic; business logic is deterministic. Never make the probabilistic thing do deterministic work.
Directives
SOPs in Markdown — the what & why
Orchestration
Rowan — routing, judgment, error handling
Executions
Deterministic Python — tested & repeatable
The agent doesn't improvise a web scrape — it reads the directive and runs the script.
3 · Progressive Disclosure
The model has a finite attention budget. So we load indexes, not content — one-line summaries that let the agent decide what's worth opening.
Frontmatter summaries — every file answers "should I open this?" in one line.
Registries & indexes — machine-readable manifests of every directive, skill, and script.
Drill down on demand — a session starts with a few KB of maps, not MBs of content.
"Read the menu, not the whole cookbook."
4 · Memory Architecture
Memory lives on disk as files, curated like a knowledge base — not a chat log.
One fact = one file — typed (user / feedback / project / reference), cross-linked wiki-style.
MEMORY.md index — auto-loaded every cold start, but character-budgeted: a Hot band plus a Cold band, with the low-relevance tail rolled off to an archive index. Bounded no matter how large the corpus grows.
Curated, not accumulated — wrong facts get corrected in place; everything is git-versioned.
Ranked by a two-strength model — storage strength never decays, retrieval strength does, and the decay rate itself slows with spaced reuse. Nothing is ever deleted; only how expensive it is to reach.
5 · Session Lifecycle
Sessions are disposable; state is not.
Work session
Debrief — learnings → memory files → git
Fresh session reads state back from disk
Restarting from disk: ~50k tokens. Compacting a long session: ~750k. End clean, never compact.
6 · Skills — Packaged Procedures
Anything done twice becomes a named, reusable procedure — like installing an app instead of re-explaining a workflow.
One folder per skill — trigger, steps, and verification in a SKILL.md
Invoked as slash commands — /session-debrief, /handoff, /code-review
Layered library — personal → team-shared → third-party, in that priority
Always re-read before running — the procedure on disk is the truth, not the model's memory of it
7 · Self-Annealing
Every failure is converted into infrastructure — the fix gets written back into the directive, skill, or memory, so the same mistake can't happen twice.
Something breaks
Investigate & fix
Update the directive
"The system today is the accumulation of every lesson it has ever learned."
8 · Identity — The Same Agent Everywhere
"Rowan" isn't a chat session. It's a persistent identity defined in files — portable across models and tools.
Identity file
+
Memory
+
Instructions
+
Any model
=
Rowan
Swap the model, switch the tool — the same identity, memory, and operating principles load.
An Operating System, Not a Prompt
None of this required training a model or writing an app. It's Markdown files, folder conventions, and small scripts — an operating system for an LLM, built from plain text.
The leverage isn't in the model. It's in the scaffolding — and it compounds from one instruction file, one memory index, and one directive.
