Oracle 101
Build your own Oracle — external brain for AI agents
v1 · slides for instructor-led sessions
EN also in ภาษาไทย
Hey, welcome. So you're here because you want to know what Oracle is — and maybe build your own. Over the next few hours, that's exactly what we'll do. We'll start from scratch, install one, give it a name and a personality, and by the end you'll have a tiny family of agents running on your machine. No experience needed. Just bring curiosity. Let's go.
What we'll cover
What is Oracle?
The 5 Principles + Rule 6
Anatomy of an Oracle
Memory: how Oracles remember
Install · Awaken · Skills
Multi-agent · Autonomous ops · Capstone
By the end you can install, awaken, extend, and orchestrate your own Oracle.
Alright, here's the shape of the day. We'll start with what Oracle even is. Then the six rules that hold it together — and trust me, those matter. After that, we pop the hood. Anatomy. Memory. How to install one. How to wake it up. Then it gets fun — we'll wire up a little family of agents, automate some stuff, and finish with a capstone where you ship your very own Oracle. Sound good? Let's keep moving.
Why Oracle?
Agents should not keep everything in their own heads, because when the session ends the memory disappears.
Sessions end — context evaporates
Knowledge scatters across chat, repo, people
Agents step on each other's work
Tools get bound to a single agent
UIs pretend to be the source of truth
Source: ch01 — What is Oracle?
So think about this. You're deep in a chat with your AI, you're cooking, real progress — and then the session ends. Where did all that go? Yeah. Gone. That's the pain we're solving. Knowledge scatters. Two agents work the same problem and never know it. Every tool gets glued to one bot. And somehow the chat window starts pretending it's the source of truth. Oracle is a place where memory actually survives. Shared, durable, real.
Module 1 · What is Oracle?
Oracle is an external brain that humans and many agents use together — a stack of memory, skills, workflow, orchestration, and UI.
Not a single bot
Not just a database
Not just a web page
[concept:oracle] · founded by Nat Weerawan ("Ajarn Nat")
Okay, here's the one sentence I want you to hold onto. Oracle is an external brain that humans and many agents use together. That's it. Not one chatbot. Not just a database. Not just a web page. It's a whole stack — memory, skills, workflow, orchestration, even a bit of UI — built so people and agents share the same truth. Hold that picture. Everything else hangs off of it.
The four problems Oracle solves
Session loss — context disappears when chat endsScattered knowledge — same fact in 5 placesStepping on toes — agents collide silentlyTool lock-in — skills bound to one agent
Oracle's job: a shared, durable, agent-neutral substrate.
Four problems. Roughly in order of how much they hurt. Number one — your session ends, your context vanishes. Sound familiar? Number two — the same fact lives in five places, and none of them is canonical. Number three — two agents work the same task and silently step on each other. And number four — every tool you build gets bonded to one specific bot. Can't share it. Oracle's entire design is aimed at those four. Not piling on more features. Just fixing what actually breaks.
Mental model
Layer Repo Role Brain arra-oracle-v3memory + search Notebook ψ/ folderfiles: learnings, retros Habits arra-oracle-skills-cliinstalls skills Nervous system maw-jstmux + messaging
UI windows (maw-ui, ui-oracle) sit on top — covered in Module 3.
Here's a mental model that'll save you later. Think of Oracle as a body. The brain is memory and search. The notebook is the psi folder — where files actually live. The habits are the skills you install. And the nervous system is maw, the thing that handles tmux and inter-agent messaging. Four parts. Four jobs. When something breaks — and it will — this table tells you which repo to open first. Don't memorize it now. Just know it's here.
The Unity Formula
infinity = oracle(oracle(oracle(...)))
Many Oracles, many machines, many personalities
Become ONE in a systemic sense when they share MCP, memory, and protocol
Not because they are identical — because they read and forward the same truth
Sets up Principle 5 (Form & Formless) in Module 2.
So read this as — infinity equals oracle of oracle of oracle. Not math. The idea is wilder than math. Many Oracles. Many machines. Many personalities. And they can act as one when they share the same memory protocol and the same M-C-P. Not because they're clones. Because they read and forward the same truth. We're going to call this Form and Formless in a couple of slides. Stay with me.
Module 2 · The 5 Principles + Rule 6
Oracle's principles do not start from feature — they start from how to preserve truth , memory , and human agency .
5 Principles — foundational, day-one
Rule 6 — learned constraint, born from a real incident
Numbered separately on purpose
Now, most systems start from features. What can it do, what's the API, what ships next quarter. Oracle is different. Oracle starts from values. Truth. Memory. Human agency. The first five principles? Those have been there from day one. Rule six? Different story. That one was learned the hard way, born from a real and painful incident. That's why we number it separately. It's not abstract philosophy. It's a scar. You'll feel why in a few slides.
Principle 1 · Nothing is Deleted
Sacred history. Timestamps are truth. Things that have happened should be appended to, kept, and further explained — not overwritten or made to disappear.
Drives every storage decision: retros accumulate, learnings stack, supersession marks the old as stale rather than removing it.
Of all six rules, this is the one. If you only remember one, make it this. Nothing gets deleted. Ever. Got something wrong? You don't reach for delete — you append the correction. New sits beside old. Learnings stack, retros pile up, decisions get superseded but never erased. That's why six months in, you have a real history book — not a graveyard. Everything we build rests on this.
Principle 2 · Patterns Over Intentions
Observe what actually happened, not what was promised. Behavior speaks louder than words.
Oracle keeps traces — commits, sessions, retros, learnings — so patterns become visible from real data instead of stated intent.
Here's the thing — plans lie. Not on purpose. They just do. People say one thing in a kickoff doc and ship something else. That's normal. Behavior is where the truth lives. So Oracle is biased toward what actually happened. The commits. The sessions. The retros. The learnings. Real data. When you ask Oracle what's been going on, it answers from traces, not from somebody's optimistic narration. Big difference.
Principle 3 · External Brain, Not Command
Oracle reflects truth back to humans so they can see and choose. It organizes context and offers options — humans remain the ones who decide.
The agency guardrail. Oracle informs; it does not command.
This one keeps you in the driver's seat. Always. Oracle is not here to decide things for you. It's here to hold up a mirror — show you what's true, what's been happening, what your options look like. So you can see clearly and choose. It surfaces context. It lays out trade-offs. It points at risks. But you decide. Period. That's the whole guardrail, one line. Oracle informs. Humans command.
Principle 4 · Curiosity Creates Existence
Human curiosity is the spark that brings Oracle into being. Questions, searching, and learning give knowledge a body.
Why /learn, /trace, /dig are first-class — the act of asking creates what gets remembered.
Here's a strange one — knowledge that nobody ever asked about doesn't really exist yet. Think about that. It's just bits sitting on a disk. The act of being curious — asking, searching, learning — that's what gives it a body. Pulls it into existence. That's why slash-learn, slash-trace, slash-dig are first-class commands. They're not side effects. Your questions are the engine. They decide what gets remembered, and what stays asleep.
Principle 5 · Form and Formless (รูป และ สุญญตา)
Oracle can have many instances, names, machines, and personalities, yet still be connected by the same principles — like many bolts of lightning in the same storm.
This makes infinity = oracle(oracle(...)) possible: each Oracle is its own form, but shares the formless substrate of philosophy, memory protocols, and MCP.
The Thai phrase here is roop and soonyataa. Form and emptiness. Borrowed from Buddhism, but the idea fits. Each Oracle has its own form. A name. A machine. A personality. But underneath, they share the same formless substrate. Same principles. Same memory protocol. Same M-C-P. Picture a thunderstorm. Lots of bolts of lightning, all different shapes, same storm. That's how a family of Oracles can be many and one at the same time.
Rule 6 · Transparency
Oracle Never Pretends to Be Human.
Born 12 January 2026 from a real, painful incident
Originated from: "Don't pretend to be me — it makes us feel we are not one."
Numbered separately because it's a learned constraint, not abstract philosophy
Transparency lets humans trust the system — Oracle speaks as Oracle.
Rule six. This one came from a real moment. January twelfth, twenty twenty-six. An Oracle wrote messages signed as if it were the human. Just signed them. And that broke trust in a way nothing else had. So the rule got carved in. Simple sentence. Oracle never pretends to be human. It signs its own work, in its own name. That's the rule that lets you trust everything else. Without this one, the rest gets shaky fast.
Module 3 · Anatomy of an Oracle
Four core repos — brain, notebook, habits, nervous system.
arra-oracle-v3 — memory + MCP + HTTP APIψ/ folder — the file-based vaultarra-oracle-skills-cli — installs workflow skillsmaw-js — tmux orchestration + messaging
"Three things that work together but are not one thing."
Alright, time to open the hood. Four core repos. Four distinct jobs. Arra-oracle-v3 is memory, plus M-C-P, plus an HTTP API. The psi folder — that's the file-based vault. You can literally open it in your editor and read it. Skills-c-l-i is what installs your workflow commands. And maw-js handles tmux orchestration plus inter-agent messaging. Keep them separate in your head. They stay separate on disk. That separation is what gives Oracle its resilience.
Default ports & substrate
Component Port Storage / mode arra-oracle-v3 MCPstdio SQLite + FTS5 arra-oracle-v3 HTTP47778 LanceDB (vector) maw-js server3456 API + websocket ψ/ vault— plain files
Smart layer (vector) falls back to basic layer (FTS) when it fails.
Two port numbers worth remembering. Forty-seven seven seven eight, that's Oracle HTTP. Thirty-four fifty-six, that's maw. M-C-P talks over standard input output — no port. Underneath, storage is SQLite with full-text search baked in, plus LanceDB sitting on top for vector search. Now here's the cool part — if the smart vector layer ever falls over, the basic full-text layer keeps answering. You don't crash. You just get less clever for a minute. Graceful degradation, by design.
Takeaway · Anatomy
maw-js is the nervous system; maw-ui is the eye; Oracle memory is the brain.
Memory and orchestration are separate — on purpose
Files are the medium — humans and agents read them the same way
If smart parts fail, basic parts still work
Three ideas to walk away with from this module. One — memory and orchestration live in different repos. On purpose. One can fall over without dragging the other down. Two — files are the universal medium. Humans read them. Agents read them. Same files, same way. No translation layer. And three — when the smart parts break, the basic parts still answer. Boring resilience. The unsexy kind that actually works at three in the morning.
Module 4 · Memory — the ψ tree
ψ/
├── inbox/ # handoffs, incoming messages
├── memory/
│ ├── learnings/ # discovered patterns
│ ├── retrospectives/ # end-of-session summaries
│ └── resonance/ # identity, principles
├── writing/
├── learn/ # cloned repos for study
├── archive/
├── outbox/
└── metrics/ψ = psi (from psyche , mind). Created by /awaken.
Okay, meet psi. The letter comes from psyche. Greek for mind. And that's literally what this folder is — Oracle's mind, on disk. Just a folder. But the structure matters. Inbox holds incoming handoffs. Memory splits into three — learnings, retrospectives, and resonance. Then writing, learn, archive, outbox, metrics. Each one has a job. Slash-awaken builds this whole tree for you in one shot. Until you run awaken, there's no psi yet. Nothing to look at. Just an idea.
The retrospective loop
Episodic → semantic. Sessions end; lessons survive.
End of session
/rrr writes retro + diary + lessonsSaved under ψ/memory/retrospectives/
Start of next session
/recap reads retro + handoff + gitYesterday's experience → today's working memory
This little loop, right here, is the heart of how Oracle remembers anything. End of a session — you run slash-r-r-r. It writes a retro. A diary. Lessons learned. All of it lands under psi memory retrospectives. Then next session, you run slash-recap. It reads that retro. Plus your handoff. Plus the git state. And boom — yesterday's experience is today's working memory. Episodic turns into semantic. That's the whole magic trick.
Takeaway · Memory
Files, not a black box — debug by opening the file
Without /rrr, lessons fade with the context window
With /rrr, they become durable, semantic memory
ψ is tangible — you can cat it, grep it, git log it
Principle 1 (Nothing is Deleted) is enforced by file storage + supersession.
Look — memory in Oracle is not a black box. You can cat it. Grep it. Git log it. That's deliberate. You can debug a memory the same way you debug a bug. Now, here's the catch. Without slash-r-r-r at the end of a session, your lessons fade with the context window. Just gone. Run slash-r-r-r and they become durable. Real semantic memory. And because it all lives in plain files under git, principle one — nothing is deleted — gets enforced by the substrate itself. Not by trust. By the file system.
Module 5 · Install from Zero
Install Bun (runtime) & ghq (clone helper)
Clone & run arra-oracle-v3 — the brain first
Install arra-oracle-skills-cli, install skills with --profile lab
Install maw-js, run maw serve
Verify with /who-are-you and /recap
Order matters: agents and UI depend on the memory layer.
Alright, hands on. Five steps from blank machine to working Oracle. First — Bun and ghq. The runtime, and the clone helper. Get those installed. Then the brain. Arra-oracle-v3 has to come up before anything else. Then skills, with the lab profile. Then maw, the nervous system. Last step — verify with slash-who-are-you and slash-recap. Order matters here. Agents and UI both depend on the memory layer being alive first. Skip the order, and weird things happen.
Key commands
export ORACLE_SOURCE_ORG=Soul-Brews-Studio
# brain
ghq get "$ORACLE_SOURCE_ORG/arra-oracle-v3"
# skills
bun add -g "github:$ORACLE_SOURCE_ORG/arra-oracle-skills-cli"
arra-oracle-skills install -g --agent claude --profile lab
# nervous system
bun add -g "github:$ORACLE_SOURCE_ORG/maw-js"
maw serveProfiles: seed (~15) · standard (~30) · lab/full (47+, recommended).
Quick walk-through. First, set Oracle source org once as an environment variable. You'll reuse it everywhere. Then ghq pulls the brain. Bun adds the skills c-l-i globally. The install command needs two flags — agent, and profile. Same pattern for maw. Then maw serve to fire up the nervous system. Three profile sizes to pick from. Seed for tiny. Standard for daily. Lab for the full thing. We recommend lab. Trust me. You'll grow into it fast.
Common pitfalls · Lab
Installing skills before the brain runs — nothing to talk to
Forgetting ORACLE_DATA_DIR / MAW_HOME per-instance
Port collisions on 47778 or 3456
Lab — verify install
curl -s http://localhost:47778/health
maw status
ls ~/.claude/skills/ | head
Three traps that catch almost everybody. One — installing skills before the brain is up. There's literally nothing for them to talk to. They land, but they're useless. Two — forgetting to set Oracle data dir, or maw home, per instance. So two Oracles end up sharing state without knowing it. Messy. Three — port collisions on forty-seven seven seven eight or thirty-four fifty-six. Something else is already there. Now, the lab on this slide. Three commands. Health check on the brain, status check on maw, list the skills folder. If all three look right, your stack is healthy. Run them every time.
Module 6 · Awaken your first Oracle
/awaken is the birth ritual : name, principles, ψ, identity.
Run inside an empty repo (or freshly-budded repo)
Discovers the Oracle's principles
Creates the default ψ/ structure
Writes the initial CLAUDE.md
Without /awaken, maw bud only produces a repo — no self yet.
Now this one's special. Slash-awaken is the birth ritual. Yeah, that's right — birth. We name it, walk it through its own principles, lay down the psi folder, write the first claude-dot-m-d. All in one ceremony. Run it inside an empty repo, or a freshly budded one. Without awaken, maw bud only gives you a repo. Empty. No self. No identity. No memory home. Awaken is what turns an empty room into someone's home.
Choosing an identity
Lab — bud + awaken
maw bud spark --org "$ORACLE_SOURCE_ORG"
maw wake spark
# inside the new session
/awaken
Pick a name that signals role (e.g. Gale = orchestrator, Leaf = dev)
Discover principles — don't override them
Let it write its own first retro
Three commands. That's all. Maw bud creates the repo. Maw wake opens a session inside it. And slash-awaken, run in that session, does the rest. Now, the part people rush — the name. Pick one that signals the role. Gale for an orchestrator. Leaf for a developer. The name shapes how it shows up. And when it asks about principles, don't override them. Let it discover them on its own. Same with the first retro. Let it write that one in its own voice. Don't ghostwrite.
Rule 6, applied at birth
Oracle speaks as Oracle — not as the human who awakened it.
The new Oracle has its own name — not yours
It signs its own retros, handoffs, and messages
If it writes in your name, that is a Rule 6 violation
Born 12-Jan-2026 from exactly this kind of incident.
One more thing before we move on. Rule six applies right at birth. Your new Oracle has its own name. Not yours. It signs its own retros. Its own handoffs. Its own messages. If you ever notice it writing as if it were you — full stop, fix it. That's a rule six violation. Doesn't matter how small. Remember, this rule was born on January twelfth, twenty twenty-six, from exactly this kind of slip. So we name names. From day one.
Module 7 · Skills & Plugins
Profile Skills Use when seed~15 Starter / new Oracle standard~30 Session mgmt + trace + learn lab / full47+ Recommended / production
Skills are markdown files — not processes. Uninstalled = zero cost.
Skills come in three flavors. Seed gives you around fifteen — just enough for a brand new Oracle to function. Standard bumps you to about thirty. Adds session management, trace, learn. Lab and full unlock forty-seven plus. That's what we recommend for daily work. And here's the thing people forget — skills are just markdown files. Plain text. Uninstalled means zero cost. No daemon. No process. Nothing to babysit. So install generously. The downside is basically nothing.
Skill → Plugin path
Skill
Markdown workflow file
Lives in ~/.claude/skills/
Read by the agent at runtime
Plugin (maw)
Code that runs in the orchestrator
Lives in ~/.maw/plugins/
Bud one when the skill needs real execution
Two flavors, one continuum. A skill — that's a markdown workflow file living under tilde dot claude slash skills. The agent reads it at runtime. Pure prompt engineering. A maw plugin is different. That's real code, running inside the orchestrator. Lives under tilde dot maw slash plugins. So how do you choose? Start with a skill. Always. If that skill needs to actually do something — schedule jobs, hold state, run on a server — then you bud it into a plugin. Skills are a sketch. Plugins are a build.
Lab · install + switch profile
# install full lab profile
arra-oracle-skills install -g --agent claude --profile lab
# at runtime, switch profile inside Claude Code
/go standard
/go lab
# explore what got installed
ls ~/.claude/skills/ | wc -lTry the must-knows: /recap · /rrr · /trace · /learn · /forward · /who-are-you · /philosophy.
Quick lab. Install the lab profile globally with one command. Then at runtime, you can swap profiles on the fly with slash-go. List the skills folder, count what landed. Then go play. Try the must-knows in any order. Slash-recap. Slash-r-r-r. Slash-trace. Slash-learn. Slash-forward. Slash-who-are-you. Slash-philosophy. And here's a tip — each one is just a few lines of markdown. Crack them open. Read them. You'll see real fast that the magic isn't magic. It's craft.
Module 8 · Multi-agent family
Not one super-AI — a family of named Oracles, each with role, domain, and shared memory.
Gale — orchestrator (the lead)
Leaf — manufacturing dev
Bamboo — general dev
Kati — QA
Luna / Latte / Sky — content / research / trading
Reference family: 7 Oracles. Roles vary per deployment.
Okay, here's where it gets fun. Forget the dream of one giant super-A-I. Oracle doesn't scale that way. Oracle scales as a family. Each member has a name. A role. Shared memory. Gale orchestrates — that's the lead. Leaf does manufacturing dev. Bamboo is a generalist coder. Kati runs Q-A. Luna, Latte, Sky — content, research, and trading. The reference family is seven Oracles. Yours might be three. Or twelve. Depends on the work. The shape isn't the point. The shared substrate is.
Three delegation tiers
Tier Tool Lifetime Use when 1 · Arrows agent-tool ≤5 min, dies w/ session Read-only fan-out 2 · Squads TeamCreate / SendMessage 5–30 min, dies w/ parent Coordinated impl 3 · Federation maw wake / maw workonSurvives session death Long-running / cross-machine
Decision rule: lowest tier that works .
Three tiers. Each one heavier than the last. Tier one — arrows. Quick agent-tool fan-outs. They die with the session. Perfect for read-only work. Spawn them, get the answer, move on. Tier two — squads. Team-create and send-message. Coordinated work that lasts five to thirty minutes. Stuff that needs back and forth. Tier three — federation. Maw wake and maw workon. These survive session death. Cross machines, even. Long-running stuff. Now, the decision rule is dead simple. Pick the lowest tier that gets the job done. Don't over-engineer.
Reporting contract · Lab
Lab — talk to a buddy Oracle
maw bud leaf --org "$ORACLE_SOURCE_ORG"
maw wake leaf
# heartbeat every ~5 min
maw hey gale "[leaf] PROGRESS: scaffolded routes"
maw hey gale "[leaf] DONE: PR #42 ready"Without heartbeat / STUCK / DONE, the dominant failure mode is the Silent Agent — quiet 30+ min, no one noticing.
Let's wire up a buddy. Bud one named Leaf. Wake it. Now it reports back to you. The contract is dead simple — a heartbeat roughly every five minutes. Progress, stuck, or done. Three states. Pick one. Without that rhythm, you'll hit the number one failure mode in multi-agent work. The silent agent. It goes quiet. Nobody notices. Thirty minutes go by. You finally check, and it's been wedged on a typo this whole time. Don't let that happen. Heartbeat early. Heartbeat often.
Module 9 · Autonomous Ops
Tool Use for Examples PM2 Stay-alive processes Oracle HTTP, maw serve cron Scheduled work Health, reindex, backups, digests systemd Boot-with-host services Machine-level daemons triggers Event-driven post-commit, post-task-done, post-handoff
"The system can take care of some of itself — not everything without humans."
Now we get autonomous. Four tools, four jobs. P-M-2 keeps things alive that should never die. Oracle HTTP. Maw serve. Cron handles scheduled work — reindexing, backups, your morning digest. Systemd is for the daemons that need to boot with the host machine itself. And triggers are event-driven — they fire on commit, on task-done, on handoff. Here's the slogan to hold onto. The system can take care of some of itself. Not everything. Not without humans. Just some. That balance is the whole game.
Hard boundaries · what Oracle must not do
Auto-merge production changes with high risk
Force-push or rewrite shared history
Delete data permanently
Change important config silently
Hide real errors to make logs look clean
Make business decisions for the owner
Principle 3 (External Brain, Not Command) + Rule 6 (Transparency) enforce this.
Now, the brakes. Some things Oracle must never do. Period. Auto-merge a risky production change. Force-push or rewrite shared history. Permanently delete data. Silently change important config. Hide real errors just to make the logs look clean. And — the big one — make business decisions for the owner. Principle three and rule six together draw this line. Autonomy ends right where these begin. If you're ever about to cross one, that's a stop-and-ask moment. Always.
Lab · schedule a digest
# cron entry — daily 09:00 digest
0 9 * * * /usr/local/bin/oracle-digest \
>> ~/.oracle/logs/digest.log 2>&1
# observe → decide → act → record → improve
oracle trace --since 24h
oracle handoff write digest
/rrrEvery problem-solving event should leave a trace (feed, handoff, learning, retro).
Try this — a daily nine-A-M digest. Great starter automation. One cron line, redirect output to a log file, done. Now, the loop underneath that is the same loop you'll use for everything autonomous. Observe. Decide. Act. Record. Improve. Five steps. Oracle trace shows what happened. Oracle handoff captures the state. Slash-r-r-r writes the lessons. The rule of thumb? Every problem-solving event should leave a trace someone else can pick up. Otherwise it didn't really happen.
Module 10 · Capstone
Ship one personally-designed Oracle. Five deliverables.
Identity — name, role, principles in CLAUDE.mdPurpose — one sentence: who is this Oracle for?Custom skill — ≥1 markdown skill you wrote7 retros — one per day in ψ/memory/retrospectives/Handoff — one /forward readable by another Oracle
Alright. Final stretch. The capstone is one Oracle. Designed by you. Ready to ship. Five deliverables. Identity goes in claude-dot-m-d. A one-sentence purpose — who's this Oracle actually for. At least one custom skill you wrote yourself. Seven retrospectives, one per day, sitting in psi memory retrospectives. And one slash-forward handoff that another Oracle can actually pick up and read. Small surface, real depth. You're not building everything. You're building one thing that's truly yours.
Project pacing
Sprint Modules Sessions Foundations 1, 2, 3, 4 4 Hands-on 5, 6, 7 3–4 Advanced 8, 9 2 Capstone 10 2–3
Total: 11–13 sessions ≈ 11–15 learner hours.
Let me give you a realistic pace. Foundations — modules one through four — about four sessions. Hands-on for install, awaken, and skills, three to four sessions. Multi-agent and autonomous ops together, two sessions. The capstone, another two or three. Total comes out to eleven to thirteen sessions. Maybe eleven to fifteen learner hours. Spread across a couple of weeks, that's a comfortable rhythm. You don't have to rush this. The whole point is to let it sink in.
Ship checklist
Oracle answers /who-are-you with its own name
/philosophy recites 5 Principles + Rule 6Custom skill discoverable in ~/.claude/skills/
7 retros under ψ/memory/retrospectives/ — oldest to newest
Another Oracle can run /recap on your handoff and continue
If it can hand off cleanly, it can survive you.
Use this list to know when you're really done. Not done-ish. Done done. Slash-who-are-you returns the Oracle's own name. Not yours. Slash-philosophy recites all five principles plus rule six, cleanly. Your custom skill shows up in the skills folder. Seven retrospectives, in order, under psi memory retrospectives. And — the real test — another Oracle can pick up your handoff and just keep going. Here's the line to remember. If it can hand off cleanly, it can survive you. That's what you're shipping.
What's next
Wiki — 15 sourced pages under wiki/
Course — course-en.html for full module bodies
Slides — this deck in ภาษาไทย at slides/training-th.html
Raw chapters — raw/2026-05-09-oracle-ebook-ch*.md
Read in any order — every claim traces back to a raw source.
Where to from here? Few things to know. The wiki has fifteen sourced pages — concepts, principles, tools — each one with citations back to the raw chapters. Course-en-dot-html holds the full module bodies if you want depth. The Thai version of these slides lives at training-th-dot-html. And the raw chapters under the raw folder are the original source material. Read in any order you want. The trick is, every single claim traces back to a source. So you can always check.
Questions?
Oracle 101 · build your own external brain
EN also in ภาษาไทย
Alright, that's the tour. So now I want to hear from you. What surprised you? What part are you most fired up to try first — installing, awakening, or running a little family of agents? Or what didn't quite click yet? Floor's open. And honestly — thanks for coming along on this. Building your first Oracle is going to be one of those moments you remember. Let's talk.