Thinketh
HackGT 13 · Oracle of the Deep, AI/ML · September 2026
Built by Stefen Ewers and Nadani Dixon
Thinketh models what is changing in the world alongside what a person has demonstrated they understand, then turns the difference into a personalized learning path.
- Build
- HackGT 13
- Track
- AI/ML
- Team
- 2 builders
- Window
- 36 hours
- Platform
- React Native
- Status
- Working hackathon prototype
Engineering brief
- Architecture
- An Expo and React Native app talking to a Hono API over shared Zod contracts. A plain TypeScript engine owns the delta, grading and the update rule, and seven external services sit behind adapters with timeouts and deterministic fallbacks.
- The hard part
- Keeping a model out of the numbers. Claude phrases, extracts and generates, but mastery changes only through a fixed rule, and every change stores the previous state, the evidence, the reason and the result.
- Testing
- More than 270 Vitest tests across the engine and API contracts, the Mindprint layout package and the mobile app, plus a golden-loop check that walks from Today to the Mind against a running API.
- Known limitation
- A 36-hour prototype on a seeded, illustrative corpus with demo identities and no public deployment. It runs end to end with or without provider keys, which is what the fallbacks are for.
The problem
Reading something is not the same as understanding it
People take in articles, videos, summaries and conversations all day. Saving a link, or even reading it, does not establish that anything was understood, and most information products are built to deliver more of it: a longer feed, a faster summary.
Thinketh starts from a narrower question. What changed relative to what this person already understands? If the answer is nothing, there is no card.
Thinketh isn’t tracking what you read. It is tracking what you understand.
The product model
Two states, kept side by side
World state
What is changing in a field
Developments, the claims they make, their sources, the concepts they touch and how those concepts relate. It changes when the field does.
Mind
What you have demonstrated
For each concept: mastery, uncertainty, the evidence behind it, any flagged misconception, and the full history of how it got there. It changes when you show something new.
The delta, not a feed
For each development the engine computes the difference itself. What you already knew is the baseline for concepts where your mastery is already high. What changed is the development’s new claims. The concept to focus on is the one that scores highest on importance, your interest, and how much you have left to learn.
Claude then rephrases that result so it reads well. It does not decide it. Two people reading the same development get different deltas, because they started in different places.
The learning loop
Today, development, check, update, Mind
The loop the repository tests end to end. Each step either shows you the delta or asks you to demonstrate it, and only the second kind can move your Mind very far.
- 01
Review a development
Today ranks what changed in the fields you follow. A development with nothing new for you is dropped from the brief.
- 02
See what you already knew
The development names the understanding it builds on, drawn from concepts your Mind already holds with good evidence.
- 03
See what changed
The change in a minute, the catch, and why it matters to you in particular.
- 04
Learn the missing delta
Visualize the old and new model side by side, make it stick with an analogy, or ask for a deeper explanation grounded in what you know.
- 05
Check your understanding
One question that tests the idea, not the wording. Multiple choice is scored directly. For a written answer, Claude reports which rubric ideas it covered and the score is computed from that.
- 06
Update the Mind
The engine applies its rule and stores the previous state, the evidence, the reason and the result. Tapping “Got it” counts a little, within a cap. A check is what moves it further.
Demo
The recorded walkthrough
A walkthrough of the working build on an iPhone, recorded for HackGT 13.
The Mind
A knowledge state you can inspect
Every concept is inspectable: its evidence, its sources, what it relates to, and every change that touched it. The Mind tab draws each concept as a book. The darker the book, the stronger the evidence, a dashed outline means the engine is still uncertain, and a bookmark flags what just changed. Opening it shows why.
The numbers come from rules, not from a model. A check produces an observation, and the update rule moves mastery toward the score it earned, scaled by how uncertain the engine was and how strong the evidence is. The change spreads one step along the concept graph at reduced strength, and only for demonstrated evidence.
Δm = 0.35 × U × w × (target − m)
U′ = max(0.05, U × (1 − information))
Ask and source ingestion
Retrieving an answer is not demonstrating one
Save an article, a PDF or a YouTube link and Thinketh reads it for you: text, extracted PDF pages, or the video’s captions. It connects what it finds to concepts you already hold and skips what you already understand. A point only counts as understood if your Mind supports it, and saving the source changes nothing.
Ask answers from the stored source corpus in labelled layers: what the sources say, quoted and cited; what Thinketh infers from them; what you already understand; and what is still uncertain. “Why this answer?” shows the sources it searched and the concepts it compared against.
Playground
Two Minds in one room
The Playground asks what can usefully move between two people. Thinketh finds the asymmetry, their agents do the first pass of teaching, and the person still has to show they learned it.
- Two Minds, one room
- People join by code. The room sees a permissioned snapshot of each Mind: level, mastery, uncertainty, evidence count, and whether a misconception is flagged, but not which one. Never Ask history, memories or reading.
- Asymmetric knowledge
- Thinketh compares the two by fixed rules. Someone can teach a concept only with mastery of at least 0.7, low uncertainty, three or more pieces of evidence, no flagged misconception, and a lead of 0.3. Anything short of that is a conflict, a shared strength or a shared gap, each with its rule and reason.
- A teaching opportunity
- The strongest candidate becomes the room’s focus. With the seeded Minds, Stefen can teach Nadani when an AI should use a tool, and Nadani can teach Stefen evaluator design.
- The agents exchange
- A teacher agent and a learner agent, each in its own context, question each other and keep a sourced takeaway. Muse runs both agents; a deterministic planner orders their turns.
- The takeaway is checked
- Before it is saved, Thinketh checks the takeaway statement by statement against the passages it cites, with Claude or a lexical fallback.
- A visiting challenger
- Grokbot, an optional agent on xAI’s Grok, examines a saved takeaway, the material it cites and the recent exchange, then raises one challenge or reports that it found no clear issue. The agent that wrote the takeaway defends it, revises it or concedes, Thinketh checks the result against the cited material, and a supported revision is saved as a new version. It is off unless its keys are set on the server.
- Understanding stays human
- An agent’s takeaway never counts as anyone understanding it. The learner’s Mind moves only when they demonstrate the idea themselves, in a check.
Architecture
A mobile client, a deterministic engine, and adapters around everything else
A monorepo with four workspaces: the app, the shared contracts, the API and intelligence engine, and the Mindprint layout package. Every external service can fail without taking the product down, because each one has a deterministic stand-in.
- Mobile client
- Expo and React Native with Expo Router, in TypeScript, with Reanimated and Gesture Handler. Four tabs, Today, Learn, Mind and Ask, plus Catch me up and the Playground.
- API
- Hono on Node. The same app also packages as a Supabase Edge Function.
- Shared contracts
- Zod schemas shared by the app and the API. Claude’s structured output is parsed against wire schemas, then validated again against the contracts before anything uses it.
- Intelligence engine
- Plain TypeScript: the delta, brief filtering, evaluation, the update rule and the collaborative delta. Claude phrases, extracts and generates. It never assigns mastery.
- Mindprint layout engine
- A separate package that lays a Mind out as a spatial map. Deterministic clustering, a fixed number of relaxation steps, label placement and edge routing, so the same Mind always draws the same way. Tested on its own.
- Adapters and fallbacks
- Every external service sits behind one guard: the live call races a timeout, any failure falls back to a deterministic implementation, and a failed service is skipped for 30 seconds. Claude gets 20 seconds, or 12 when a request is waiting; Tiger Data gets 2.5.
- Secrets
- Provider keys live on the server. The voice client receives a short-lived conversation token, and nothing in the app bundle is a credential.
- Knowledge history
- Each change stores the previous state, the observation, the reason, the result and a timestamp. Observations and transitions are appended, never rewritten.
- Realtime Playground
- Supabase Realtime Broadcast and Presence over a small hand-written socket client, with polling underneath so a dropped connection never stalls a room.
Services and what each one does
- Claude
- Reasons across the personalized delta: normalizes developments, phrases what changed for you, writes diagnostics, reports which rubric ideas an answer covered, analyzes saved sources and checks agent takeaways.
- MongoDB Atlas
- The world state: developments, sources, claims, concepts, storylines and the edges between concepts, with Atlas Search behind Ask.
- Tiger Data
- Append-only knowledge observations and state transitions, with a daily mastery aggregate.
- Backboard
- Qualitative learner memory, such as preferences and misconceptions. Never the source of a mastery number.
- Supabase
- Profiles, feature flags and sign-in, and Realtime for the Playground.
- ElevenLabs
- The voice companion behind Catch me up, a conversational agent the app joins with a token the server mints.
- Muse
- The teacher and learner agents in the Playground exchange.
- Grok
- Grokbot, the optional visiting challenger. If xAI fails or times out, the challenge ends as unavailable, the takeaway is untouched, and no other model stands in.
Built in 36 hours
HackGT 13, Georgia Tech
- Team
- Two builders, Stefen Ewers and Nadani Dixon.
- Window
- About 36 hours at HackGT 13, Georgia Tech, in the Oracle of the Deep AI/ML track.
- Mobile app
- Today, Learn, Mind, Ask, a voice catch-up and the Playground, running on an iPhone.
- Engine and API
- The delta, grading, the update rule and the collaborative delta, behind a Hono API with shared Zod contracts.
- Integrations
- Seven live services across four persistence layers, each with a deterministic fallback.
- Tests
- More than 270 Vitest tests across the engine, the Mindprint package and the app.
- Demo
- A working recorded walkthrough, embedded above.
What comes next
From a hackathon prototype to a product
The HackGT build proves the loop on a seeded, illustrative corpus with demo identities. The app talks to a mock API unless it is pointed at a running server, and several shortcuts taken for the demo are written down in the repository to be undone.
- Stronger ingestion and retrieval: scheduled discovery, vector search, and Ask over your own saved sources.
- Calibrating the knowledge-state rules against weeks of real use rather than a seeded Mind.
- A rigorous evaluation of whether learning actually transfers between people.
- Better collaborative learning environments than one room and one exchange.
- Production authentication and privacy controls, and hardened infrastructure.
- Continued work on latency and reliability.
Working hackathon prototype with a recorded demo. No public deployment. Built for HackGT 13 by Stefen Ewers and Nadani Dixon.