EduAgent

Eduagent - Personalized AI Tutor that remembers everything.

Inspiration

Every AI tutor I've tried has the same bug: amnesia. You spend an hour going deep on a topic, close the tab, and tomorrow you're a stranger again. Real tutors are valuable precisely because of what they remember - what you struggle with, what finally clicked, what you're about to forget.

But even personal tutors do not have the capacity to attend each and every individual personally on a 1-on-1 basis. That's where AI Agents can come in with personalized memory for each student for each topic that they want to learn.

The idea that unlocked this project: a learner model is just files that change over time. Mastery scores, misconceptions, a study plan. And we already have a perfect, battle-tested tool for "files changing over time, with an audit trail" - git. When I saw that Codex app-server gives the agent a real filesystem, real command execution, and real git, the whole product fell out of one sentence: a tutor whose memory of you is a git repository, where every lesson ends in a commit.

What it does

EduAgent is an AI tutor for technical interview prep (SQL and Python DS&A in the demo), and extendable to any teaching domain, that never starts from zero:

Paste a job description, answer four quick questions, and a Codex agent reads it, sizes you up, and commits a day-by-day roadmap to your memory - the plan itself is a versioned file (roadmap.yaml).
Every session opens with recall. Day 13 greets Alex (the seeded demo learner for this hackathon) with his September interview goal and the exact LEFT JOIN edge case he's shaky on, then builds the day's drill to attack that weakness.
Mastery is honest. Get a prediction wrong and mastery visibly ticks down, committed with evidence. No participation trophies.
Misconceptions are a ledger. Alex's two-week-old belief that "WHERE filters before JOIN" gets probed with a transfer question, and when he finally reasons through it, the agent flips it [OPEN] - [RESOLVED] - you watch the actual red/green diff of his brain.
Exams fork your memory. A mock exam is a real thread/fork: a second examiner inherits your entire history, writes questions aimed at your weakest concepts, grades your SQL by executing it in the sandbox, and commits the results back (Alex: readiness 64.0 - 72.3).
Your memory belongs to you. It's plain markdown and YAML - scrub a time machine across 159 commits, diff any two weeks of your learning, export the whole repo and leave.

How we built it

The unusual part: Codex isn't a feature of EduAgent - it's the runtime. A Node/TypeScript host speaks JSON-RPC to codex app-server, and every product feature maps to a protocol primitive:

threads - tutoring sessions (resumable, replayable)
thread forking - mock exams that inherit your memory
sandboxed execution - code graded by actually running it
file tools + git - the learner model itself
MCP - a stdio server exposing 9 ui_* tools the model calls mid-turn to push exercises, quizzes, and wrap cards into the browser
skills - the pedagogy (recall-first openings, socratic probing, transfer checks)

Around that: a Next.js front end, SQLite mirroring thread items for instant replay, per-learner git workspaces, and a Hetzner VPS provisioned with Pulumi, deployed with Docker + Caddy, with a prod auth setup (Clerk) and daily demo-world reseeds.

I also built it with Codex end to end: before writing product code I wrote a 14-step spike harness against the protocol and kept notes of everything it taught me; then GPT-5.6 implemented the product slice by slice, with the session rollouts on disk as ground truth whenever we disagreed about what actually happened. The session IDs are in the README.

Challenges we ran into

Making the sandbox work in production. On Linux, Codex sandboxes with bundled bubblewrap - which, inside a Docker container on Ubuntu 24.04, hits three separate walls: unprivileged user namespaces, AppArmor, and the default seccomp profile. The fix was a custom seccomp profile (moby's default plus the Landlock/userns syscalls), one sysctl, and apparmor:unconfined on exactly one service - then proving it by probing disk effects: writes inside the workspace land, writes outside are blocked, network is denied.
Letting the agent commit. The sandbox (correctly) blocks writes to .git. The answer was surgical: add just the workspace's .git to writableRoots, so the agent can commit its own memory but nothing else.
Forks need a parent rollout. You can't fabricate a Codex rollout, so a freshly seeded demo world can't fork an exam - the fix is a self-healing warm turn the first time someone asks for one.
A believable demo world, deterministically. The seeded learner has three weeks of history; the seeder is fully deterministic (same seed + clock - identical HEAD sha) with self-checks like "every session wrap's mastery deltas must equal that session's commit deltas."
A brand-new protocol with no tutorials. I pinned the CLI version and learned by experiment - things like "developer instructions only apply at thread start" cost real debugging hours and are now written down.

Accomplishments that we're proud of

The product runs on Codex in production. Not a wrapper around a chat API - a hosted, HTTPS, authenticated, rate-limited app where every tutoring turn, grading run, and memory commit is a real Codex session.
The moment on camera is real. The misconception flipping [OPEN] - [RESOLVED] in the demo video is the live product committing to a real git repo, with the evidence trail in the diff.
Thread forking as a product feature. "Fork your memory into an examiner" turns a protocol capability into something a learner can feel.
A learner model you can read. Anyone can open Alex's repo and understand exactly why the tutor believes what it believes - and export it.
Built solo during build week, with Codex as the pair programmer throughout.

What we learned

App-server is an application runtime, not a dev tool. Threads, forks, rollouts, sandboxing, and MCP compose into product features nobody associates with "coding agents."
Legible memory beats opaque memory. Files you can read, diff, and export earn trust in a way embeddings never will - and git gives you time travel for free.
The model is maybe a third of the product. The harness around it - serialization, honest state, replay, gating, determinism - is where a demo becomes something you can hand to a judge.
More Linux sandboxing internals (Landlock, bubblewrap, seccomp, AppArmor) than I ever planned to know.
Pedagogy is promptable. Recall-first openings, one-thing-at-a-time socratic probing, and transfer checks that actually resolve misconceptions - the teaching style lives in versioned skill files, not in code.

What's next for EduAgent

More verticals. The memory format is subject-agnostic - math proofs, language learning, medicine - anywhere "what you're shaky on" matters more than "what's next in the playlist."
Smarter forgetting. The spaced-repetition queue already reacts to lapses; next is fitting per-concept decay curves from real evidence.
Portable memory as a standard. Your learner repo should travel with you - across tutors, across models. The tutor should compete on teaching, not on holding your history hostage.
Classroom mode. A teacher dashboard is just another reader of the same commits: see the class's misconception ledger, not a black-box grade.
Near-term housekeeping: key rotation, hardening, and opening the demo beyond the judging window.