Synapses

A stateful, AI-powered tutoring engine that uses psychometric math and open-ended rubric grading to turn massive exam syllabi into curated, daily study playlists.

Comment

Inspiration

Students around the world—whether preparing for national exams, SATs, APs, or university courses—face the same four frustrating questions:

  1. What should I study next?
  2. Is my mistake a missing concept, a memory lapse, or a specific misconception?
  3. How much practice is enough before I can safely move on?
  4. How do I review older topics before I forget them?

Most edtech platforms offer either static, endless question banks or generic AI chat screens that act as answer-generators rather than true tutors.

We built Synapses around a single core thesis: Diagnose before you drill.

Instead of treating learners as simple test scores or throwing them into an endless feed of hard questions, Synapses combines a rigorous, syllabus-agnostic mathematical adaptive engine and orchestration policy with a Socratic OpenAI tutor. It isolates the exact root cause of a student's mistake, repairs their misconception, and schedules timely retrieval practice—giving every learner one explainable, optimal next step.

What it does

Synapses is a curriculum-aware, evidence-led adaptive learning workspace. While we initially benchmarked and launched it on the CBSE Class 9–10 curriculum, the underlying engine and orchestrator are completely syllabus-agnostic and can be mapped to any global curriculum (US K-12, AP, IB, SAT, or higher education).

Core Architecture & Key Features:

  • The Explainable Orchestrator: The brain of Synapses. Instead of a black-box AI model making random study choices, our orchestrator evaluates candidate actions across a 6-tier priority hierarchy (Diagnostic Probes $\rightarrow$ Misconception Repairs $\rightarrow$ LearnCards $\rightarrow$ Verification $\rightarrow$ Spaced Review $\rightarrow$ Practice) and returns human-readable reasons for every decision.
  • The "Actionable Frontier" Graph Search: Walks backward through directed prerequisite graphs to find the smallest blocking concept, preventing students from getting stuck in infinite prerequisite loops.
  • Diagnose Before Drilling: When a student fails a multi-skill question, Synapses refuses to arbitrarily penalize every skill. It opens a Diagnostic Investigation, serving single-skill probes to isolate the true culprit.
  • Productive Challenge Target (~68% Zone): Uses Fisher-like Information scoring to pick questions near a 68% expected success probability—maximizing learning efficiency in the zone of proximal development.
  • Misconception Tracking & Repair: Misconceptions are tracked independently from skill competence ($X_{um}$ activation strength). Active misconceptions trigger targeted AI Tutor interventions and require independent re-probes for resolution.
  • Dual-State Engine ($A = M \times R$): Separates durable long-term competence ($M$) from time-decayed recall retrievability ($R$), preventing simple time-decay forgetting from destroying a student's underlying mastery score.
  • Socratic AI Tutor & Interactive LearnCards: A streaming workspace with 4 specialized teaching modes (Socratic, Feynman, Guided Practice, Revision), multimodal vision/audio input, and a 15+ widget LearnCard catalog (Formula Explorers, Decision Trees, Process Steppers).

How we built it

Synapses is built with a clean 3-tier separation: React/Next.js UI $\rightarrow$ tRPC API Boundary $\rightarrow$ Prisma Workflows $\rightarrow$ Pure TypeScript Adaptive Engine & Orchestrator.

1. The Mathematical Engine & Response Model

The engine performs logit-space updates based on Item Response Theory (IRT) and Free Spaced Repetition Scheduler (FSRS) principles:

  • Effective Mastery Formula: $$A_{uk} = M_{uk} \times R_{uk}$$ (Durable competence $M_{uk}$ multiplied by FSRS retrievability $R_{uk}$)

  • Weighted 3PL IRT Response Prediction Model: For a question $q$ requiring skills $K_q$: $$\theta_{uk} = \text{logit}(A_{uk}), \quad z_q = 1.702 \cdot d_q \sum_{k \in K_q} \text{normalizedWeight}{qk} (\theta{uk} - b_{qk})$$ $$P_q = c_q + (1 - c_q) \cdot \sigma(z_q)$$ (Where $b_{qk}$ is difficulty, $d_q$ is discrimination, and $c_q$ is the guessing floor)

  • Logit-Space Competence Update: $$\text{residual}q = y_q - P_q$$ $$\Delta \theta = \text{baseStep} \cdot \text{topologyMultiplier} \cdot \text{reliability}_q \cdot w{\text{retrieval}} \cdot v_{qk} \cdot \text{directionMultiplier} \cdot \text{residual}q$$ $$M{\text{new}} = \sigma(\text{clamp}(\text{logit}(M_{\text{old}}) + \Delta \theta, -0.75, 0.75))$$

2. OpenAI AI SDK & Tutor Authority Boundary

To protect evidence integrity, the AI Tutor never directly updates mastery, FSRS, or evidence ledgers. Questions inside the tutor session use single-use, 15-minute server presentation tokens evaluated through deterministic grading and asynchronous rubric contracts (OpenEndedGradingJob), writing to an immutable MasteryEventLedger.

3. How OpenAI Codex & ChatGPT Powered Development

OpenAI Codex and ChatGPT were fundamental co-pilots in building Synapses:

  • Orchestrator & Math Formalization: Codex helped us translate complex pedagogical principles into pure TypeScript orchestrator logic, logit-space updates, and mathematical edge-case tests.
  • Schema & Immutable Ledger: Codex co-authored our Prisma schema and designed the append-only evidence ledger pipeline to guarantee transactional safety.
  • UI & Multimodal Streams: Codex accelerated our streaming AI SDK UI components, interactive LearnCard JSON renderers, and Firebase multimodal vision/audio handlers.

Challenges we ran into

Making the whole project in 7 days

Calculating mastery is easy; calculating what to do next is hard.

Mathematical formulas for updating a student's mastery score (IRT residuals, logit steps) are well-defined. The hardest architectural challenge was building an Orchestrator that decides what action to present next.

At any given moment, the engine faces competing priorities:

  • Should it investigate a failed multi-skill item?
  • Should it repair an active misconception?
  • Should it teach a new concept via a LearnCard?
  • Should it schedule spaced review for decaying memory?
  • Should it serve practice at the 68% productive difficulty zone?
  • What if the ideal question is missing from the database?

We had to design an Orchestrator that evaluates these competing demands, computes exposure penalties so questions aren't repeated, resolves the prerequisite "Actionable Frontier", and gracefully handles content gaps (OrchestratorContentGap) without ever trapping the student on a dead end or breaking session continuity.

Accomplishments that we're proud of

  • The Explainable Orchestrator: Building a pure, deterministic policy layer in TypeScript that can explain why every single study step was chosen.
  • The "Diagnose Before Drill" Loop in Action: Watching the system catch a composite failure, spawn a single-skill probe, identify an active misconception, hand off to a Socratic tutor, and resolve the error upon re-probing.
  • Truly Syllabus-Agnostic Core: Successfully decoupling the adaptive graph engine from any specific curriculum board, laying the foundation for global scaling.
  • Safe AI Authority Boundary: Creating an ecosystem where conversational AI is constrained by, and feeds directly back into, an auditable evidence system.

What we learned

  • How to effectively combine probabilistic LLMs with deterministic psychometrics (IRT + FSRS) and orchestrator policies.
  • That calculating mastery is only 10% of adaptive learning—90% of the value lies in orchestrating an explainable, non-frustrating next action.
  • The power of OpenAI Codex as an agentic engineering partner for pure algorithmic modeling, database transactions, and schema architecture.

What's next for Synapses

  • Global Syllabus Expansion: Expanding beyond our initial CBSE Class 9–10 benchmark to US K-12 (Common Core, AP, SAT), IB Diploma, and global university entry exams.
  • Open Curriculum Graph Protocol: Allowing educators and institutions to author and publish custom skill graphs and misconception maps.
  • Oral Viva & Visual Diagram Workflows: Expanding multimodal capabilities to support full oral examination modes and detailed diagram/handwriting extraction.

Built With

Share this project:

Updates