ChatGPT taught you something last week. Do you remember what it was?
Neither does it.
Rabbithole is a memory-native learning OS — an AI education companion that actually remembers you. It builds a persistent cognitive model of how you think, what you know, and where you struggle — across sessions, across weeks, across months. It doesn't just answer questions. It teaches you, tests you, and makes sure you don't forget.
Learn any subject in depth. Go down the rabbit hole. Come back smarter.
Every AI learning session starts from zero. You spend 45 minutes getting ChatGPT to explain number theory, close the tab, come back tomorrow, and it has no idea who you are. There's no structure, no mastery tracking, no mechanism to reinforce what you learned.
Worse — ChatGPT gives you a five-paragraph essay on a topic, and buried in paragraph three is a term you don't understand. You have two options: ignore it and keep reading (you won't retain anything), or ask about it and lose your entire conversation context. Either way, the learning session is broken.
You get the illusion of learning without the retention.
Rabbithole is guided by two AI characters, each inspired by a foundational learning science principle:
Mr. Feynman — The Teacher. Named after Richard Feynman and the Feynman Technique. He believes that if you can't explain something simply, you don't understand it yet. He conducts your learning sessions, interviews you to understand your background, builds personalized study plans, and — when it's time — asks you to teach concepts back to him.
Ms. Ebbinghaus — The Reminder. Named after Hermann Ebbinghaus and the forgetting curve. She tracks every concept you've learned and knows exactly when you're about to forget it. She shows up with reminders, schedules reviews at scientifically optimal intervals, and makes sure nothing falls through the cracks.
Together, they form a complete learning system: learn deeply, then retain permanently.
This is the core idea. When you're learning about number theory and hit the phrase "optimization problems" — you don't have to ignore it, you don't have to abandon your current thread, and you don't have to waste context asking "wait, what's that?"
You branch. Right there. Mid-conversation. A new thread opens, focused entirely on optimization problems. You go deep — as deep as you want. And when you're done, you jump back to the parent thread, right where you left off. Your context is preserved. Your curiosity is rewarded.
Branches can nest. A rabbit hole inside a rabbit hole inside a rabbit hole. Each one is a focused conversation with its own memory context. The thread tree tracks exactly where you've been and where you're going.
No more wasting context. No more reading five paragraphs just to get confused by one term and giving up. No more ignoring things you don't understand.
You don't just start chatting. Mr. Feynman conducts an interactive interview first — what do you already know? How deep do you want to go? What's your goal? Based on your answers, he generates a structured study plan: phases, concepts, dependencies, all laid out.
You review it. Adjust it. Approve it. Then he teaches you through it, one concept at a time — conversationally, not walls of text.
After each phase of your study plan, Mr. Feynman flips the script. Instead of teaching you, he asks you to teach him. Write down what you just learned in your own words — in a rich text editor with auto-saving drafts and hints available if you're stuck.
This is the Feynman Technique in action. If you can explain it simply, you understand it. If you can't, you know exactly where your gaps are.
Your Feynman explanations aren't just read — they're scored across four dimensions:
- Clarity — Can you explain it simply?
- Accuracy — Is it factually correct?
- Depth — How thoroughly did you explore it?
- Transferability — Can you apply it to new situations?
This isn't binary pass/fail. It pinpoints exactly where your understanding breaks down. "Great clarity and accuracy, but your depth on edge cases is weak" is infinitely more useful than "7/10." Gaps are identified, and spaced repetition schedules are automatically created to fill them.
Ms. Ebbinghaus tracks every concept you've learned and generates targeted practice tests — multiple choice, fill-in-the-blank, and open-ended questions tailored to your mastery level.
Stopped caring about a topic? She notices. And she reminds you. Scheduled reviews appear automatically when it's time — no discipline required on your part.
Ms. Ebbinghaus calculates optimal review intervals based on your mastery scores and shows up when it's time:
| Mastery | Tier | Next Review |
|---|---|---|
| 0.0 – 0.4 | Weak | 1–2 days |
| 0.4 – 0.7 | Medium | 5–7 days |
| 0.7 – 0.9 | Strong | 2–3 weeks |
| 0.9 – 1.0 | Mastered | Occasional |
She lists your topics for review with current mastery scores, weak areas, and exact review dates. No concept is left behind.
Rabbithole doesn't start from zero. Ever. Built on EverMemOS, the system maintains a constantly evolving learner profile — your preferences, your strengths, your struggles, facts about how you learn best.
Every conversation extracts memories. Every session refines the model. Mr. Feynman remembers that you're a visual learner who struggles with abstract math but thrives with concrete examples. He adapts. Across sessions. Across weeks. Across months.
This is what makes Rabbithole fundamentally different from ChatGPT: your knowledge compounds.
Every concept you've learned, every connection between them, every mastery score — visualized as an interactive graph. Topics are clusters. Concepts are nodes colored by mastery tier. Edges show prerequisites, relationships, and exploration paths.
Click any concept to see your mastery percentage, trend, weak areas, and the threads where you explored it.
A separate graph powered by EverMemOS showing the memories extracted about you as a learner — your profile, facts, learning events, and how they connect. This is the cognitive model, made visible.
You say: "Teach me number theory for quant finance"
1. Mr. Feynman interviews you — what do you know? how deep?
2. He generates a structured study plan — phases, concepts, dependencies
3. You approve the plan (or adjust it)
4. He teaches you concept by concept — conversationally, not walls of text
5. Hit a confusing term? Branch into a rabbit hole. Go deep. Come back.
6. After each phase → Feynman Mode: explain what you learned
7. Scored on clarity, accuracy, depth, transferability
8. Weak concepts scheduled for spaced repetition review
9. Next session: Ms. Ebbinghaus is waiting — "You learned X 3 days ago. Review?"
10. Your knowledge compounds. Your gaps get filled. Nothing is forgotten.
Next.js Frontend ───SSE/REST───► FastAPI Backend ───HTTP───► EverMemOS Cloud
(Chat + Trees) (Agent Loop) (Long-term Memory)
│
├── Mr. Feynman (teaching agent)
├── Ms. Ebbinghaus (review agent)
├── MongoDB Atlas (app data)
└── OpenRouter (LLM provider)
The backend runs a phase-based agent loop using the OpenAI Agents SDK: receive message → build phase-specific agent (interview / planning / teaching) → Runner.run_streamed() handles the LLM + tool-calling loop → stream SSE events to the client → persist to MongoDB and EverMemOS.
| Layer | Stack |
|---|---|
| Frontend | Next.js 14+ (App Router), TypeScript, Tailwind CSS v4, React Flow, BlockNote |
| Backend | Python 3.12, FastAPI, OpenAI Agents SDK, Pydantic v2 |
| Database | MongoDB Atlas |
| Memory | EverMemOS Cloud (api.evermind.ai) |
| LLM | OpenRouter (model-agnostic) |
| Tooling | Ruff, Basedpyright, pytest, pnpm |
curl -fsSL https://rabbitholeai.xyz/install.sh | shThis downloads the latest release, prompts for your credentials, installs dependencies, builds the frontend, and creates a rabbithole launcher in ~/.local/bin. See Prerequisites for what you need before running.
Hackathon build (March 2026). The core learning loop is fully functional — agent phases, branching conversations, study plans, Feynman testing, spaced repetition, knowledge graphs, and persistent memory all work end to end.
Go down the rabbit hole. Come back smarter.