Homeroom

An AI workspace that turns a K-12 student's classes, calendars, and family logistics into one calm next step, and asks before it saves or shares anything.

Comment

Inspiration

Emily is fourteen and about to start ninth grade. She has the kind of mind that loses the thread between an assignment being posted and the assignment being done, not for lack of trying. Her coursework lives in Google Classroom, her band schedule in a separate app, her due dates in a portal, and her family logistics in a stream of texts. Every system holds a piece of the truth. None of them helps her turn that into a day she can actually do.

So a parent becomes the human integration layer, every night, scrolling six apps to answer one question: what does she need to do next? Homeroom is built to answer that question for her, and to teach her to answer it herself.

That is why we built Homeroom.

What it does

Homeroom is a guardian-connected AI workspace designed specifically for K-12 students.

When Emily opens Homeroom, she does not see an empty chatbot. She sees a calm workspace built only from approved school and activity sources, and it starts her off with a view of her day:

  • an optional private check-in ("How are you arriving today?")
  • one recommended thing to start, and the option to choose a different task instead
  • a focus room that breaks the real assignment into small steps with a timebox, and saves her progress
  • a calendar that separates schoolwork, band, and school district events
  • her classes, each tied to its live source
  • a source-backed supply list that shows only what the school's official page lists
  • short, class-scoped learning rooms that coach with hints without just giving answers
  • and a student-controlled way to ask a guardian for help

Homeroom turns scattered school information and activities into one manageable day, while keeping Emily in control of every action.

The Golden Experience

The demo follows one complete, testable student journey, and every step leaves evidence:

  1. Emily starts a private, role-scoped student session.
  2. Homeroom builds her Today view from seven Google Classroom classes, coursework, a BAND/CutTime calendar, district dates, and an official supply list.
  3. She can start by describing her day, and GPT-5.6 replies with next steps based on how she is feeling.
  4. She starts the recommended step, or chooses another, and the focus room turns it into visible steps with a timebox; her Homeroom progress is saved while the Classroom assignment stays untouched.
  5. She practices an algebra refresher with progressive hints rather than being handed the answer; the application grades the work.
  6. When a school assignment or activity changes, Homeroom shows exactly what changed and asks before updating a saved plan.
  7. Homeroom will let Emily know when there's an activity that might require guardian approval and lets her send them a message.
  8. Her guardian opens a Family inbox, acknowledges the note, and sees privacy-safe progress and an approved-only weekly summary, never her private coaching or answers.

The result is not simply a conversation. It is a visible, consent-driven workflow supporting Emily in her daily journey.

Student safety and agency

Homeroom's boundaries are enforced by application code, not left to the model:

  • external educational sources are read-only
  • GPT-5.6 can propose actions but cannot authorize them
  • approvals are bound to the actor, the exact arguments, the expected state versions, and an idempotency key
  • guardian access is role-scoped and limited to an allowlisted projection
  • Emily sees the guardian projection before it is published
  • practice is graded deterministically by the application
  • the model provides hints and instruction instead of silently completing schoolwork
  • model responses are never treated as the authoritative source of school facts
  • and the submission uses fictional student data, with no access to a minor's real school account

The AI can explain and propose. The application decides what is valid, permitted, and saved.

How we built it

Homeroom is a Next.js application running through Vinext on Cloudflare Workers.

The technical foundation includes:

  • TypeScript, React, and Next.js
  • Vinext and Vite
  • Cloudflare Workers and Cloudflare D1
  • the OpenAI Responses API with GPT-5.6
  • strict, stage-scoped function tools
  • Zod validation at trust boundaries
  • signed, role-scoped session cookies
  • CSRF and same-origin protections
  • D1-backed rate limiting
  • append-only source versions
  • version-bound approval receipts
  • Google Classroom, iCalendar, and official-school-page adapter boundaries
  • Resend for the approved-only guardian email digest
  • role-scoped judge access for reviewers
  • and Vitest coverage plus GitHub Actions verification

The Responses API loop uses low reasoning effort, concise output, store: false, strict function schemas, and a bounded tool-round limit. It preserves complete output items and function call IDs across continuations. Tools are exposed by stage: orientation can only reach approved read tools, while plan persistence is isolated to a separate write stage that requires a verified approval receipt.

How we used Codex

Codex was the engineering collaborator on Homeroom from the first commit to the last. We worked spec-first: before writing a feature, we had Codex turn the product decision into an explicit, testable contract, the Golden Experience Contract, then a state machine, before any UI existed. We worked test-first: Codex wrote failing tests for each trust boundary (approval receipts, source adapters, the identity flow) and implemented against them, which is why the repo ships 430 tests at 88% statement coverage rather than as an afterthought. Codex drove the parts that are easy to skip in a hackathon and expensive to skip in a product: the D1 migrations, the SSRF guards on every external source fetch, the CSRF and same-origin hardening, and the release verification. The whole arc is visible in the commit history on the codex/foundation branch, where every commit passed the same CI gate. Codex's most valuable contribution wasn't speed. It was forcing product decisions to become explicit contracts before they became code.

Technical verification

The release foundation includes:

  • 430 passing automated tests across 100 files
  • 88.40% statement coverage, 80.23% branch, 91.92% function, 90.77% line
  • six passing Playwright journeys across desktop and mobile, including an accessibility pass
  • a clean TypeScript check and a clean lint check
  • a successful production build
  • zero reported npm vulnerabilities
  • and deployed-origin smoke tests for both student and guardian identities

The public Cloudflare deployment has been exercised end to end with seven fictional Google Classroom classes, fourteen coursework items, BAND/CutTime-compatible calendar events, a district calendar, an official source-backed supply list, D1 persistence, role-scoped judge access, and live GPT-5.6 planning.

Challenges we faced

Keeping the model helpful without making it authoritative. The model needs enough freedom to explain, personalize, and teach. It must not have enough authority to change a student's plan, publish to a guardian, or invent school facts. We separated proposals from commits and bound every consequential write to an application-verified approval.

Making a dynamic AI experience reliably demonstrable. External systems, OAuth, and live school data can make a short judge demo fragile. Homeroom uses normalized source adapters and controlled fixture versions, so the same interface can support Google Classroom and iCalendar while the recorded and judge experiences stay deterministic and safe.

Designing guardian involvement without creating surveillance. Parents need visibility into important logistics, but the student should understand exactly what is shared. Homeroom builds a guardian-safe projection, shows it to Emily first, and publishes only after her explicit approval.

Teaching rather than completing. A school assistant should help a student learn, not quietly do the work. The learning rooms separate AI-generated instruction from deterministic grading: the model gives progressively stronger hints, and the application validates the work.

What we learned

The safest and most useful educational AI architecture is not "give the model every tool." It is: give the model a narrow stage, provide only the tools that stage needs, validate every argument outside the model, show the student the proposed consequence, require explicit approval, and preserve evidence of what happened.

We also learned that student agency has to be visible in the interface, not just promised in a privacy policy. The features that matter most are the ones a scattered fourteen-year-old will actually use at 7 AM: one next step, a way to say "not this," and a shame-free way back in after a missed day.

Who it's for, and what's next

Homeroom is built first for the students who feel this problem most acutely: the millions with ADHD, a 504 plan, or an IEP, for whom executive function, not ability, is the barrier between knowing the work and doing it. The nearest path to real students does not wait on a district: guardian-forwarded assignment summaries, public iCalendar feeds, and public district calendars can power a real daily plan today, with full school integration following where a district approves it.

From there, our roadmap is to:

  • generalize identity and household setup beyond the single fictional Build Week family
  • expand the district-calendar and official-school-page adapters beyond the current fictional school district implementation
  • add deeper accessibility and multilingual support
  • add district-controlled deployment, retention, and administrative policies
  • extend the source-backed learning workflow across more subjects and school systems
  • and package the experience as a dedicated student app
  • expanding product scaffolding to support broader age and grade experiences

The goal is not to replace teachers, counselors, or parents. It is to give every student a calm, trustworthy layer that helps them understand what is happening, decide what to do next, learn how to begin, and ask for help when they need it. It brings everything together into one unified platform to help students and parents stay organized, confident, and successful.

Built With

  • cloudflare-d1
  • cloudflare-workers
  • codex
  • google-classroom-api
  • google-oauth
  • gpt-5.6
  • icalendar
  • love
  • next.js
  • openai-responses-api
  • playwright
  • react
  • resend
  • typescript
  • vinext
  • vite
  • vitest
  • zod
Share this project:

Updates