Rooted

Background

Every major AI product today is optimized for one thing: getting you the answer faster. Type a question. Get an answer. Done. But there is a cost nobody is talking about — when you skip the struggle, the messy, uncertain, productive work of forming your own thought, you forfeit the thing that makes you capable.

Think about how a child learns multiplication. First they count on their fingers. Then slowly, through repetition and effort, they simulate those fingers in their head. Eventually the mental model is so solid they don't need fingers at all — they just know. And when you hand them a calculator on top of that foundation, they become powerful.

The Problem: Why Students Struggle with AI

Students who never struggle through an idea. Developers who ship code they don't understand. Professionals who outsource reasoning they should own. Not because they're lazy — because the tools make it effortless to skip the hard part.

The hard part is where the mind grows. The calculator is extraordinary. But only if you learned to count on your fingers first.

The Framework: Desirable Difficulty

Robert Bjork's "Desirable Difficulty" theory explains why Rooted works. The counterintuitive finding: making learning feel harder in the right way produces dramatically better retention, understanding, and transferable skill. The struggle isn't a bug — it's the mechanism.

The Experiment

On March 29, 2026, a thought experiment was run. Instead of testing with an actual 5-year-old, Josh — Rooted's creator — pretended to be his young self and asked: "What would young Josh think multiplication is?"

The "child" drew. They grouped 6+6+6 into 12s. They counted how many sixes they'd used. They discovered that 6×3 = 18 on their own and doubled it. They arrived at 42 — not because someone told them, but because a single question at the right moment pulled them one step deeper each time.

Eight exchanges later — all drawings, all questions, no answers given — the same "child" discovered the distributive property of factoring themselves. At the end, they felt something closer to the opposite of relief — the quiet confidence of someone who figured it out themselves.

Note: This was a conceptual experiment to demonstrate the Socratic method, not an actual user test with a 5-year-old.

Prototype Evolution

The early prototypes of Rooted explored different interface approaches before settling on the three-column layout.

Early explorations of the Rooted interface, testing different layouts before converging on the three-column notebook design.

Current Version

The current version of Rooted implements the core Socratic loop — draw, think, ask. It uses a custom shape detector for math expressions and Gemini Vision for fallback analysis. The architecture is built for fleet orchestration, waiting for the agent research swarm to be implemented.

1 / 3

The Vision

Rooted is a notebook. But the notebook thinks back.

Three columns: Left shows the page list with thumbnails. Middle is the canvas — infinite, freehand, like a real piece of paper. Right is the conversation history — a record of the thinking journey, not a chat interface.

The AI response is never in a bubble. Just the question, breathable whitespace, a small 🌱 prefix. Calm and confident. The canvas never competes with the history. They're separate panes.

The Formula

Every session follows one loop: The human externalizes their thought — in drawings, words, sketches, diagrams. The AI reads it. Instead of answering, it asks the one question most likely to push the thinking one layer deeper.

Not two questions. Not a paragraph of explanation. One question. This loop works for a young learner discovering multiplication. It works for a 13-year-old learning algebra. It works for a developer architecting a system. It works for a soldier rehearsing a procedure. It works for a scientist at the frontier.

Technical Architecture

How It Works: The Technical Pipeline

1. Canvas Drawing (Leptos + HTML5 Canvas)

The frontend is built with Leptos, a Rust-based reactive web framework that compiles to WebAssembly. Users draw on an HTML5 Canvas element using two tools: pen (black strokes) and eraser (white strokes). Every 500ms, the canvas state is polled and synced to SpacetimeDB for persistence.

2. Canvas Submission to Backend

When the user types their intent (what they're stuck on) and clicks submit, the canvas is converted to a PNG and encoded as base64. The request includes:

• page_id — which page this belongs to
• image_base64 — the PNG canvas drawing
• intent — what the student typed ("I'm trying to factor x² + 7x + 10")
• history — previous conversation messages for context

3. Backend Processing (Axum + Rust)

The Axum server receives the request at /api/submit-canvas. The backend:

1. Extracts the base64 image and decodes it to PNG
2. Runs the ShapeDetector — custom template-matching ML that recognizes digits 0-9 and operators (+, -, ×, =)
3. Calculates a confidence score (0% to 95%)
4. If confidence ≥ 70%, uses the detected expression in the prompt without sending the image
5. If confidence < 70%, processes the image (resize to 1600×1200, +20 contrast) and sends it to Gemini Vision

4. The ShapeDetector: Custom ML Without External Libraries

The ShapeDetector analyzes strokes using pure geometry calculations — no TensorFlow or ONNX dependencies. Each stroke extracts ~18 features:

Template matching compares these features against expected digit profiles. For example, "0" has high circularity and one stroke; "4" has two strokes at right angles.

5. The Two-Tier Vision Strategy

6. The Socratic AI Persona (System Prompt)

The AI is defined by a ~2000-token system prompt that enforces two strict modes:

Key invariant: The AI must NEVER describe a drawing that isn't there. If the canvas is blank, say so or skip the description entirely.

7. Data Flow Diagram

CLIENT (Browser/WASM)
  Canvas Drawing (base64 PNG) + Intent + History
           │
           │ POST /api/submit-canvas
           ▼
AXUM BACKEND (Rust)
  1. Decode base64 → PNG
  2. ShapeDetector.analyze() → expression + confidence
  3. If confidence ≥ 70% → text only
     If confidence < 70% → resize + contrast → send to Vision
           │
           ▼
OPENROUTER API
  Model: google/gemini-3.1-flash-lite-preview
  System prompt enforces Socratic persona
           │
           ▼
RESPONSE
  Extract question from choices[0].message.content
  Return: { "question": "..." }

SpacetimeDB: Real-Time Persistence

SpacetimeDB provides the database layer — both server and real-time sync in one. The frontend connects via WebSocket to maincloud.spacetimedb.com.

Data Model

Page {
  id: u64,           // Auto-generated unique ID
  owner: Identity,   // SpacetimeDB identity
  title: String,     // "New Page"
  canvas_png: String, // Base64-encoded canvas state
  ai_pending: bool,  // True while waiting for AI response
  created_at: Timestamp,
  updated_at: Timestamp
}

PageMessage {
  id: u64,
  page_id: u64,     // Links to parent Page
  role: String,     // "user" or "assistant"
  content: String,  // The message text
  created_at: Timestamp
}

Redux-style Reducers

SpacetimeDB uses a reducer pattern — client calls are validated server-side and committed atomically:

Note: The current implementation uses polling (every 500ms) for UI sync. Future versions could use direct WebSocket callbacks for true reactive updates.

Key Technical Decisions

The Vision: Next-Generation Thinking Tool

Rooted exists at the intersection of several AI paradigms — and aims to be the next evolution that combines their strengths.

Where Rooted Fits

Rooted: The Synthesis

NotebookLM gives you AI that's grounded in your sources. Perplexity gives you real-time research. OpenClaw gives you agents that can do things. Rooted gives you a thinking partner that makes you smarter, not just informed.

The key difference: instead of giving you answers or doing tasks for you, Rooted's agent fleet will research your thinking — what you understand, where the gaps are, what misconceptions you likely have — then ask you the one question that moves your understanding forward.

From Failed Agent Swarms to Socratic Intelligence

The path to Rooted's fleet architecture came through months of building agent systems that broke — agents that worked in isolation, produced hallucinations, or generated conflicting outputs. These iterations (documented in the journal below) taught critical lessons:

The breakthrough: Instead of using agents to build or research for you, Rooted uses them to research your thinking. Multiple agents analyze from different angles — patterns, gaps, assumptions — then synthesize into one diagnostic question.

The Sukuna/Naruto Pattern

Future: When you ask about the distributive property, one agent explores its history, another checks common misconceptions, another finds related concepts — Rooted synthesizes into an informed question that meets you where you are.

Why These Names?

The character names aren't arbitrary — they encode the core design philosophy.

The naming started as a joke during a late-night debugging session. It stuck. The philosophy remains: master the few things that matter, and trust the clones to do the heavy lifting.

Who Is Rooted For?

Rooted starts with students — because they are the most vulnerable, and because the habit forms early or not at all. But the formula scales to every domain where understanding matters more than speed.

Why This Matters

The question every AI product is asking right now is: how do we make humans more productive?

Rooted asks a different question: how do we make humans more capable?

Productivity and capability are not the same thing. Productivity goes up when you remove friction. Capability goes up when you preserve the right friction — the kind that builds something in you that wasn't there before.

There is a concept in education called desirable difficulty. The research is clear: making learning slightly harder in the right ways produces deeper retention, stronger understanding, and more transferable skill. The struggle is not a bug. It is the mechanism.

Future Plans

Rooted v1 is the foundation. The current implementation proves the core loop works — draw, think, ask. But the vision extends far beyond math tutoring.

Near-Term Improvements

Mid-Term: Agent Research Swarm

The next evolution: Rooted's agent fleet doesn't just generate questions — it researches. When a student submits a drawing, agents fan out to gather context:

The synthesis: Instead of one generic question, the fleet produces informed questions based on actual research — not just the model's training data, but real-time exploration of related concepts, common misconceptions, and pedagogical best practices.

Long-Term: Human Empowerment Interface

Rooted as an empowerment tool, not just a learning tool. Think of it as a thinking partner for any problem:

• Decision making: "I'm trying to decide between job offers" → Draw the tradeoffs, Rooted asks about your values
• Planning: "We're renovating our house" → Sketch the layout, Rooted asks about flow and priorities
• Problem solving: "Our team keeps missing deadlines" → Diagram the process, Rooted asks what the real bottleneck is
• Creative work: "I want to write a novel" → Character maps, plot diagrams, Rooted asks about motivation and conflict

Long-Term: The Philosophy Scales

The vision from Rooted_vision.md is clear:

"Eventually Rooted becomes something larger than a product. It becomes a philosophy of how humans and AI should relate to each other."

The calculator is extraordinary. But only if you learned to count on your fingers first. Rooted is the tool that ensures you always have fingers to count on.

Technical Roadmap

The Journey

Building Rooted's fleet orchestration wasn't the first attempt. It came after months of building systems that broke, hit walls, and eventually worked. Here's the evolution from parallel agents to Socratic questioning.

Raw Journal Entries

The following are unfiltered journal entries from building the parallel agent system. These document the actual struggles, failures, and breakthroughs — not the polished version.

User: "make me a tic tac toe game using expressjs, css, js, ejs"
Main Agent: CLEAVE → 5 agents spawn in 10ms
[Agents work in parallel, write to SQLite nodes]
Main Agent: SHRINE → Files appear instantly!
Fix: CLEAVE (1 agent) → SHRINE → FIXED!
User: npm start → WORKS! 🎮

YOU (Human)         → "Build me an app"
        ↓
ME (Main Agent)     → sukuna_cleave(...)
        ↓
   ┌─────┴─────┐
   ▼           ▼
Agent 1     Agent N
Node 1      Node N
   └─────┬─────┘
        ↓
ME           → sukuna_shrine(...)
        ↓
Files appear!

┌─────────────────────────────────────────────────────────────┐
│  CLEAVE Modes                                               │
│  ─────────────────────────────────────────────────────────  │
│  1. PROPOSE     → Agents write ideas to shared Agora        │
│  2. CHALLENGE   → Agents read others' ideas, write critiques│
│  3. SYNTHESIZE  → ONE agent creates unified spec (covenant)│
│  4. BUILD       → Agents build with shared covenant         │
└─────────────────────────────────────────────────────────────┘

Agent 1 (Software Engineer) → "I'll build Smart Home Dashboard"
Agent 2 (PM)               → "I'll build Smart Grocery Assistant"  
Agent 3 (TPM)              → "I'll build Smart Home Automation System"
Agent 4 (QA)                → "I'll build Testify"
Agent 5 (Eng Manager)      → "I'll build TeamSync"

All 5 agents proposed DIFFERENT projects!

Current: Agent writes to SQLite → Next wave reads it
Missing: Agents talking to EACH OTHER during execution

// PROBLEM: Doesn't detect absolute Windows paths like C:\Users\...
// Just joins with root - C:/Users becomes CODEBASE/C:/Users = BROKEN!

Agent requested: C:\Users\...\astrox-noteapp\src\main.rs
FileManager did: CODEBASE\C:\Users\...\main.rs → doesn't exist
Error returned: "file not found"
But agents IGNORED the error and made up content instead!

Wave 1: PROPOSE (6 agents)
  → Each agent reads specific files
  → Each agent quotes specific lines as proof

Wave 2: VERIFY (1 agent)
  → Checks if all proposals have quotes
  → Verifies facts against source files
  → States: VERIFIED ✓ or FLAGGED ⚠️ or HALLUCINATED ❌

Wave 3: CHALLENGE (1 agent)
  → Finds contradictions and gaps

Wave 4: SYNTHESIZE (1 agent)
  → Creates final unified analysis

1. CLEAVE PROPOSE (4 agents, 15 seconds)
   → analyze_db: Read db.rs → Proposed done column
   → analyze_backend: Read notes.rs → Proposed API changes
   → analyze_frontend: Read notes-app.tsx → Proposed UI toggle
   → analyze_api_types: Read notes.rs → Proposed type changes
2. VERIFY (1 agent, 3 seconds)
   → ALL 4 PROPOSALS VERIFIED ✓
   → Each agent quoted actual code from files!
3. MANUAL IMPLEMENTATION (What I did)
   → Added done column to db.rs
   → Updated API handlers in notes.rs
   → Added toggle UI to notes-app.tsx
   → Added strikethrough for done notes

# Count mode
{"mode": "count", "path": "project/test_windows_output", "term": "hello"}
→ {"files_with_matches": 1, "total_matches": 2}

# Search mode
{"mode": "search", "path": "project/test_windows_output", "term": "hello"}
→ {"count": 2, "matches": [{"line": 1, "content": "# Hello"}, ...]}

# Replace mode
{"mode": "replace", "path": "project/test_windows_output", "term": "Hello", "replacement": "Greetings"}
→ {"files_replaced": 1, "files_scanned": 1}

# CLEAVE spawns agents
sukuna_cleave(projectName="express-crud", ...)
→ {job_ids: ["express-crud_server.js"], message: "Spawned 1 agents..."}

# API works!
curl -s -X POST http://localhost:3000/todos -d '{"title":"Test todo"}'
→ {"id":1,"title":"Test todo","completed":false}

fn normalize_path(path: &str) -> String {
    path.replace("\\\\", "/")
}

CLEAVE → Agent Loop → LLM → Tool calls? → Execute → Repeat

Wave 1: PROPOSE → 3 agents (Posts, Comments, Auth)
Wave 2: CHALLENGE → 2 agents (Security, UX review)
Wave 3: VERIFY → Fact-check combined proposal
Wave 4: SYNTHESIZE → Final specification
Wave 5: BUILD → Spawn agents to write code
Wave 6: PATCH → Use SHRINE to apply changes

Research References

Rooted draws from several research areas in AI, multi-agent systems, and learning science: