Ask: a CSTR question solved with Python in the browser, 0.667 at high confidence after an independent re-solve
ChemLab CSTR: all three steady states, which ones are stable, and the S-curve
ChemLab 3D views of a shell-and-tube heat exchanger and a distillation column, plus a first-angle drawing
ChemLab: eight simulations, each with charts and a process flow diagram
Quizzes on chemical engineering topics and a company-wise interview bank
Today view with phone reminders, a notices inbox for class messages, and Time to Finish
PYQ Predictor, OA coding practice and the interview bank

Inspiration

We're chemical engineering students at NITK. If you ask a chatbot to do an engineering calculation, it hands you a clean, confident number, and sometimes that number is just wrong. In an exam that costs you marks. In a real design it costs a lot more. So we wanted a study helper that never gives you a number it didn't actually compute, and that will tell you "I'm not sure" rather than guess.

What it does

StudyForge is a personal study agent for engineering students.

Verified solving. Nemotron plans the solution and writes Python, and the student's own browser runs it inside a sealed Pyodide sandbox. The script has to compute the answer and also check it a second way, and both have to agree. After that, a second model solves the question again on its own, and only if it matches do you see the answer at high confidence. If the two disagree, a third solve breaks the tie. If it still can't verify the answer, it tells you that.
No invented numbers. Every number in the written explanation has to come from the sandbox output, the question itself, or a physical constant. If one doesn't, the explanation gets regenerated or flagged.
Photo questions. Take a photo of a problem or upload a scanned page. A vision model reads it, and you confirm the text before anything gets solved.
Quizzes where the numerical answer keys are worked out by code in the sandbox, not written by the model.
The rest of your study life: deadlines and reminders (including push notifications on your phone), a notices inbox for class messages, prep packs for each deadline, weak topics tracked from your quiz results, lecture notes PDFs, Time to Finish, a PYQ predictor, an interview bank and OA prep.
ChemLab: eight tested simulations (CSTR, PFR, batch, McCabe-Thiele distillation, heat exchanger, flash drum, recycle with purge, and pipe and pump) with charts, process flow diagrams, engineering drawings and 3D views. The CSTR one finds every steady state and shows you which ones are stable.

Judges can just press Try demo on the live site. You don't need an account, and it runs on the same real API.

How we built it

Nemotron on Nebius Token Factory. There are four roles, and each one has a fallback:

router: Nemotron 3 Nano 30B classifies the question.
solver: Nemotron 3 Ultra 550B writes the code and the explanation, with Super 120B as the fallback.
cross_check: Ultra re-solves every answer independently, with a 2-of-3 tie-break.
vision: Nemotron 3.5 Super VL reads photos and scans.

Sandbox. Python written by the model never runs on our server. It runs in a Web Worker where the network APIs are removed before the user's code starts. There's a kill timer, the output is capped, and every message the worker sends back to the page is treated as untrusted.

Stack. React 19, Vite and TypeScript on the front end, FastAPI and Pydantic on the back end, Supabase (Postgres, Auth, Storage), all on the free tiers of Vercel and Render. KaTeX for maths, Mermaid with DOMPurify for diagrams, and numpy/scipy for ChemLab.

Spend safety. We log every model call with what it cost. There are hard caps per user, per IP, per day and overall, so spending stops before the credits run out.

Results

Accuracy: 46 out of 48 correct on a held-out set of questions the system never saw while we were building it. When it isn't sure, it shows low confidence or "not verified" instead of a wrong number.
Cost and speed (live, 27-28 Oct): a median of about $0.027 and about 33 seconds of model time per solve, and that includes the independent re-solve.

Challenges we ran into

Keeping the numbers honest. To check "no invented numbers" we had to parse LaTeX, scientific notation, subscripts and step labels without raising false alarms.
Making the re-solve actually independent. When we asked the same model for "a different method", it often just gave us the same formula again. So we turned the cross-check into a separate solve from scratch with a majority vote.
Templates that looked right but weren't. Our ChemLab templates are exact, but the model sometimes picked the wrong one and showed it at high confidence. We took them out of chat solving and kept them on the ChemLab page until they can sit behind a verify step.
Locking down the sandbox. Python can call back into JavaScript, so the worker strips the network APIs from the global scope and from its prototype chain too.
CSTR multiple steady states. Simple root finding just picks one steady state at random. Our template finds all of them and reports whether each one is stable.
Free tiers only. We had cold starts on the free backend, a spending budget to protect, and evals that cost real credits every time we ran them.

Accomplishments that we're proud of

In our pipeline, a number nobody can back up is a failed check, not a style problem.
Code the model writes never touches our server.
46/48 on unseen questions, and when it doesn't know, it says so instead of giving a confident wrong answer.
A demo mode that lets anyone use the full app with one tap.

What we learned

Let the model propose and let the program decide. Treat every string that comes from a model, a note or a worker as data. Measure on questions you didn't tune on, because your accuracy on your own dev set will lie to you. And give the agent a hard budget, so that when it fails it fails gracefully instead of throwing an error.

What's next

Check My Working: upload your own handwritten solution and see the first step where it goes wrong.
Adaptive practice: fresh, computed versions of the problems you got wrong, on a spaced schedule.
Hook notes search and cited web search up to the agent.
Bring the ChemLab templates back into chat, behind a verify step.