Grasp

Inspiration

Take-home work stopped measuring anything, and everyone knows it. A student turns in a fluent, well-structured essay. Did they learn something, or did they type a prompt? You genuinely cannot tell from the page — and the whole institution is built on the assumption that you can. Schools responded by buying AI detectors, which don't work, are trivially evaded, and falsely accuse the exact students least able to defend themselves: non-native speakers, whose careful prose reads as "too clean." But detection was always answering the wrong question. Nobody actually cares whether a model touched the work. The real question is "does this student understand what they turned in?" Those two questions came apart the day ChatGPT shipped, and everyone kept measuring the first one because it looks measurable.

We built Grasp because the honest move isn't to ban the tool — it's to change what you assess. Let students use AI freely. Then ask them to defend what they submitted.

What it does

Grasp reads a student's specific submission and interviews them about it — questions answerable only if they actually understand what they turned in. The output isn't a grade or a verdict. It's an understanding map: per concept, what they can defend, what they can't, and where their edge is.

The demo makes the whole thesis visible in three students who answered one economics assignment:

• Priya wrote hers by hand → 6/6 defended
• Marcus used AI, and understood every line → 6/6 defended
• Devin used AI and never read it → 0/6 defended

Marcus and Devin submitted near-identical essays. No detector on earth separates them — there's nothing in the text to separate. Only the defense does. Asked almost the same question — "raise a binding rent cap but keep it below market; does the shortage grow or shrink?" — Devin dodges ("it depends on many factors") while Marcus predicts exactly ("demand falls, supply rises, the shortage shrinks but doesn't vanish"). Marcus is the point. He used AI, and he passes, because he understands it. Grasp measures understanding, not authorship.

How we built it

The engine is five stages, and the whole product was built with Codex from a validated design spec, running on GPT-5.6 at every step.

1. Claim extraction pulls the defensible claims out of a submission — the specific choices that could have gone another way — each tagged with the causal model the student must hold to own it.
2. Adaptive probe generation must perturb that model — change an input and ask what the student's own argument predicts — never ask for paraphrase.
3. A separate answer-leak critic rejects any probe answerable from its own wording.
4. Evaluation returns defended / shaky / undefended with reasoning.
5. An adaptive controller climbs on a strong answer and backs off to find the edge on a weak one; no single answer resolves a concept.

The one architectural invariant: the engine never sees who wrote the work, or how. Provenance is excluded by explicit database selects. If it leaked in, Grasp would be a covert AI-detector and every result would be circular. That's why Marcus (AI-assisted) scores identically to Priya (hand-written) — same treatment, by construction. There is no "cheated" field anywhere in the schema.

We used gpt-5.6-sol for the judgement calls and gpt-5.6-terra for the high-volume leak critic. The stack: Next.js, TypeScript, Prisma, Postgres (Neon), Tailwind, deployed on Vercel.

Challenges we ran into

Every one of these was found by running the thing, not reasoning about it:

• Paraphrase drift — the failure that hides in plain sight. A student who never read their essay can still restate any paragraph of it, fluently. So any probe answerable by restating is one they pass, and the assessment silently degrades into a reading quiz everyone passes. The fix is the whole product: probes must perturb the model, because a model can be run forward on a new input and a memorised paragraph cannot.
  • Probes that answer themselves. "What if demand were perfectly inelastic, so quantity doesn't respond to price?" defines the term it's testing. We caught this with a second GPT-5.6 pass that rejects self-answering probes — verified by feeding it a deliberately leaky one, which it flagged with exact reasoning.
  • Supplying the model. The subtle one. A probe that hands over the equations (Qd = 100 − P) isn't testing whether the student knows quantity rises as price falls — the equation says so. Someone with no understanding just does the arithmetic. We had to teach the generator to give a situation, never the relationship.
• The assessment wasn't reproducible. The same student produced three different maps across three identical runs. The cause was arithmetic: a defended verdict at difficulty 5 scored exactly the resolution threshold, so a single probe could close a concept. And temperature is rejected by GPT-5.6 — you can't turn sampling noise down at the API — so we had to average it out structurally, requiring two probes per concept minimum. After the fix: Marcus 6/6 and Devin 0/6, every run.
  • Phantom 401s. Every GPT-5.6 tier intermittently returned 401 in clustered bursts — one call in six — while a different model on the same key went 8/8. We built a retry wrapper with exponential backoff; without it, a 36-call defense session died ~100% of the time.

## What we learned

The hard part was never the AI. It was defining the one distinction the whole product rests on — the difference between a student who can restate their work and one who can run the model behind it — and then being disciplined enough to make the engine blind to authorship, even when peeking would have been easy. The most honest system is the one that refuses to answer the question everyone else is asking.

## What's next

Grasp doesn't solve proctoring — it solves the questions, generating a personalized viva against each student's specific work at a scale no teacher could reach by hand. Where the defense happens stays an institutional choice. Next: real accommodations for anxious and non-native students, LMS integration so the artifact is locked before questioning, and a teacher-facing view that turns a class of understanding maps into "here's what to teach tomorrow."

Built With

• codex
• gpt-5.6
• neon
• next.js
• node.js
• openai
• postgresql
• prisma
• react
• tailwindcss
• typescript
• vercel
• zod