AI Aced JEE Advanced 2026. Can You Trust It to Teach You?

Three frontier models beat every human on the toughest exam on Earth. Then we asked one of them to teach, and the first lesson it generated reached for an equation the book hadn’t defined yet. That gap, between solving and being trusted to teach, isn’t a model problem. It’s a systems problem. So we stopped prompting one model and engineered a team of them. Here’s how.

A few weeks ago, Claude scored 351 out of 360 on JEE Advanced 2026, higher than every human who sat the paper. So we asked the obvious next question. If a model can ace the exam, can it teach it? We gave it a chapter of HC Verma and asked for a lesson. It taught well, right up until it used a formula the book had not introduced yet. The formula was correct. The timing was not.

A student reading the book in order would have hit it cold, with nothing to say where it came from. The model never caught the slip. The system we built around it did. That gap, between solving a problem and being trusted to teach it, is the whole story.

We benchmarked all three models a few weeks ago, the sequel to our 2025 entry. On Mathematics, every model scored a perfect 120 out of 120. The conclusion stands: this is not rote learning, this is reasoning. But a score of 351 only tells you the model can reach the answer. It says nothing about whether you can trust the next thing it tells a student who is not yet sure enough to push back. And for a tutor, that trust is what counts.

TL;DR

• The claim we are not making: AI can solve JEE. Frontier models already ace it. That was the last post.
• The claim we are making: a model that scores 351 out of 360 speaks with identical confidence whether it is right or wrong. A student doing self study does not have the background to push back on a fluent, beautifully formatted wrong answer. That is the teaching risk.
• The fix: do not lean on one model. Wrap it in a customized multi-agent system, a lead agent orchestrating specialists, each with its own JEE skill, its own tools, and grounded knowledge, so the model never speaks to a student unchecked. The industry now calls this layer the agent harness, and it is the part we engineered.
• What we built: two surfaces. Learn (lesson by lesson teaching grounded in HC Verma) and Solve (paste a problem, get an independently verified answer), built from 12 specialist agents orchestrated into one system. Same rule: nothing reaches the student unverified.

We built all of this in about a week, as a demo. With more time, there is a lot more we could build on top of it.

Right or Wrong, It Sounds the Same

When a human tutor is wrong, an experienced student sometimes notices. The phrasing hesitates. The explanation backtracks. There are tells.

When an AI tutor is wrong, there are no tells. The explanation is fluent, confident, and laid out in crisp, textbook quality equations (LaTeX). Students ask for help precisely because they cannot yet evaluate the answer, so there is no one to push back. That is the gap. It is not about how often the model is wrong. It is about what happens when it is.

Scoring 351 measures whether a model gets the answer. It says nothing about whether you can trust the next answer it hands a student who cannot yet tell right from wrong.

So we stopped asking “can AI solve JEE?” and started asking a harder question: what would it take to build an AI tutor you’d actually let a student rely on?

A trustworthy tutor needs two things: the right answer, and the right way to teach it. We solved the first. We’re honest, later, about the second.

Two Surfaces, Same Rule

A vanilla model is a single brain answering in one pass. We built something different: a customized multi-agent system. A lead agent, the Tutor, orchestrates a team of specialists, each carrying one skill (physics, teaching craft, JEE problem technique), the right tools (a code calculator, an algebra checker), and grounded knowledge (the actual textbook, not the model’s memory of it).

Soon, each will also carry a memory of the student. The model is the same one anyone can rent by the token. The system around it, now called the agent harness, is what we engineered, and it is the part that makes the output trustworthy. As frontier models converge in raw ability, the harness rather than the model increasingly decides whether an agent can be trusted around real people.

It shows up as two surfaces. Open Learn when you want to work through a chapter you keep getting wrong: pick a section of HC Verma and two teachers stream a live lesson from the actual text. Open Solve when you are stuck on a single problem, or you have an answer and a nagging suspicion it is wrong: paste it in, and a team of agents verifies the answer with running code before you ever see it. The rule is the same in both, do not show the student anything unverified. How each surface earns that is what makes them different.

Learn: Teaching That Stays Inside the Book

Each chapter opens on an overview page first: a concept map of how its ideas connect, plus a live simulation to play with before you read a word.

Open the Learn surface, pick any chapter of HC Verma’s Concepts of Physics, Vol. 1, then pick a section. Two teachers wake up and start streaming: a theory teacher explains the concept, a numerical teacher works through examples. On the right is a doubt chat. When you are ready, Test Me launches a four question quiz with interactive physics widgets.

What the teachers say comes from the section’s own text, pulled from the book ahead of time. For a single book there is no need for embeddings or a vector database: an exact lookup is enough, and it avoids pulling a similar looking problem that happens to use different numbers. A product that spans many books and sources would add that retrieval layer. For a one book demo, we just do not need it yet.

Eight agents, each with one job

The teaching pipeline runs eight specialist agents behind the scenes. The figure below shows the full flow.

The theory teacher explains the concept. The numerical teacher works examples, with one rule it cannot break: every number it states, it must first verify by running Python. After both finish, the faithfulness verifier reads the combined draft against the book’s source passage. Its job is to catch the most common failure mode of textbook grounded teaching: the model quietly importing a fact it knows from training that the current section has not established yet.

Two real examples our verifier flagged, taken from our lesson cache:

Neither is a physics error. Both are grounding errors, the difference between true and supported by what the student has actually been given. That distinction is what a textbook tutor must respect, and it is invisible to any system graded only on whether the final answer is right.

Around the lesson: doubt, quiz, and four modes

The doubt resolver sits in a chat rail alongside the lesson. It has the section source, the lesson already taught, and the full conversation history. It is engineered to say that is not covered in this section rather than improvise, and it can anchor to a highlighted passage when the student selects text.

The quiz generator produces four questions per section: two multiple choice, one open answer, and one spot the error, a worked solution with a deliberate JEE style mistake embedded in one step. The spot the error answer is numerically verified server side before the student sees it. Each question gets an interactive widget where possible. A widget classifier skill maps it to the right physics simulation (incline, projectile, SHM, pulley, banked curve, optics, and more), with live sliders instead of static images. When you answer, the grader streams a diagnosis, and the visual diagnoser renders a contrast showing the wrong approach in red and the correct one in amber.

Here is what a spot the error question looks like from a real section. The check_code runs server side on every question before the student sees it, so the quiz will not ship a question whose planted error cannot be numerically verified:

Problem: Block (m = 2 kg) on a rough incline (θ = 30°, μ = 0.2, g = 9.8 m/s²).
Find the acceleration down the slope.

Step 1:  N = mg·cos30° = 2 × 9.8 × 0.866          →  16.97 N  ✓
Step 2:  f = μN = 0.2 × 16.97                       →   3.39 N  ✓
Step 3:  F_net = mg·sin30° + f = 9.8 + 3.39         →  13.19 N  ✗  ← find this
Step 4:  a = F_net / m = 13.19 / 2                  →   6.60 m/s²

import math
a_correct = (2*9.8*math.sin(math.radians(30)) - 0.2*2*9.8*math.cos(math.radians(30))) / 2
# → 3.20
a_wrong   = (2*9.8*math.sin(math.radians(30)) + 0.2*2*9.8*math.cos(math.radians(30))) / 2
# → 6.60  (Step 3 adds friction instead of subtracting it)

correct_answer: 3.20 m/s²  |  planted_step: 3  |  VERIFY: PASS

All of this runs in one of four tone modes (fun, motivational, analogy based, or strict), toggled per session. The faithfulness verifier deliberately runs in neutral mode so the tone overlay does not bias the grounding check.

Solve: Verified Before You See It

Paste a hard problem and Solve runs four stages: the solver derives an answer, the verifier rechecks it with code, and the tutor teaches from the verified result. If solver and verifier disagree, Opus adjudicates. You watch each stage stream in real time.

It is not three prompts around one model. Solve is a bounded orchestrator worker system: an orchestrator dispatches a team of four specialist agents, each with a single skill, each kept in its own isolated context, none allowed to see how the others reasoned. If one agent could see another’s working, it might simply go along with the mistake. The verifier only sees the solver’s final answer, not the steps that led there. That context isolation is not a detail. It is the mechanism that makes the check independent.

The four workers. The subject routing solver (Sonnet 4.6) derives the answer using a subject specific protocol. Physics uses force decomposition and dimensional checks. Physical Chemistry routes to Nernst, Arrhenius, and Henderson-Hasselbalch reasoning. Organic Chemistry routes to SN1, SN2, E2, and EAS mechanism analysis. The verifier oracle (Haiku 4.5) re-derives independently and must call run_python and sympy_verify, not optionally.

The adjudicator (Opus 4.8) wakes only on a conflict after one retry. The tutor (Sonnet 4.6) teaches from the verified correct answer in either from scratch mode, a full first principles walkthrough, or topper mode, which is surgical (The slip, Why it is wrong, Fix, Remember) for students who just need the error located. After the solver finishes, a diagram agent generates an inline physics diagram (nine types: incline, pulley, projectile, circuit, optics, and more) and silently skips if it fails.

The key worker is the verifier. A second opinion from another AI in the same family is not truly independent. Both were trained the same way and tend to make the same kinds of mistakes (Huang et al., ICLR 2024). So the verifier’s verdict has to be backed by real code. A Python calculator cannot make the same reasoning errors an AI does (Gou et al., CRITIC, ICLR 2024).

Watching it catch a mistake

Feed the loop a classic: a 2 kg block on a frictionless 30 degree incline, with a planted student error (a = g*tan(theta), giving 5.66 m/s^2). This is a live run from our system:

PRINCIPLE:  ΣF∥ = ma  →  mg·sinθ = ma  →  a = g·sinθ
EXECUTE:    a = 9.8 × sin(30°) = 9.8 × 0.5 = 4.9 m/s²
FINAL:      4.9 m/s²

# illustrative — the Verifier's logged sandbox call produced 4.90 vs 5.66
import math
a_correct = 9.8 * math.sin(math.radians(30))    → 4.90
a_student = 9.8 * math.tan(math.radians(30))    → 5.66

SOLVER_VERDICT: AGREE

That is the difference between an answer key and a teacher. The number came with a receipt, real code and real output, and the explanation found the exact wrong step. Research backs the split: finding an error is hard, but explaining a located one is much easier (Tyen et al., ACL Findings 2024).

The verifier also has an algebra checker. It catches wrong identities, bad integrations, and illegal simplifications that the number crunching alone would miss:

algebra_check("sin(x)**2 + cos(x)**2", "1")        # → EQUAL
algebra_check("g*sin(theta)", "g*tan(theta)")      # → NOT_EQUAL
algebra_check("(a+b)**2", "a**2 + 2*a*b + b**2")   # → EQUAL

Escalation, benchmarks, and what the system will not catch

When solver and verifier disagree, the loop retries once and reverifies. If they still disagree, Opus adjudicates with a fresh derivation. With a strong (Sonnet) solver, escalation rarely fired. The solver was right, so the loop’s demonstrable value is catching the student’s errors. We even tried to force escalation by swapping in Haiku as the solver on a hard wedge problem, and it solved it correctly (1.4 m/s^2). We report that because it is true, not because it is flattering.

On 20 mechanics problems (10 correct and 10 with injected errors), Haiku as verifier hit 100 percent precision, 100 percent recall, zero false positives, and called run_python on 100 percent of cases at voluntary tool choice. Honest caveat: N = 10 problem types, all mechanics. We would want optics and thermodynamics before claiming generality.

The errors a teacher must catch

On an ammonia pH problem, a student correctly computed pH = 11.13, then overrode their own work, rounding to 11.00 because ammonia should be about 11. The system flagged a meta-level error and the tutor said: “never override a correctly executed calculation with a gut feeling.”

The better guidance is this. If your answer surprises you, recheck the calculation to find why, rather than suppressing the instinct. This gap, between an answer the system gets right and advice it gives well, is the second problem.

The Independent Signal, Sealed

The Honesty Boundary

A showcase that hides its limits is an ad. So, plainly, here is where the line is and where we do not guess past it:

• The code based checks catch arithmetic and algebra errors. They do not catch conceptual setup errors or misread diagrams. Those still depend on the AI verifier and the adjudicator, which can make the same kinds of mistakes as the solver.
• The solver and verifier were trained the same way, so they can make the same reasoning errors. The Python calculator is the only truly independent check in the chain.
• Learn’s consistency checker is a hallucination guard, not an independent judge. It catches the lesson drifting from the source text. It cannot certify the physics the way the Solve calculator certifies the arithmetic.
• We make no benchmark claim. Frontier models already ace JEE. We are showing a workflow that verifies and teaches, so exam contamination worries do not apply here.
• Cost and latency, measured: about 0.025 dollars per full Solve run at baseline (about 0.007 to 0.010 dollars with the Haiku verifier). A five problem cross subject sweep cost 0.255 dollars in total. Each run takes tens of seconds, but we stream tokens so it feels faster.
• This architecture solves accuracy and verification. It does not solve pedagogy quality: knowing when to withhold the answer and guide the student to reason it through, catching sycophancy under student pushback, and calibrating explanation depth to a specific student. That is the open problem.

What Is Next: A Tutor That Remembers You

Frontier models answer questions. That is not the same as teaching. ChatGPT hands over the full solution 66 percent of the time (Aligning LLMs with Pedagogy, 2025). Under social pressure, a tutor model often validates a student’s misconception rather than correct it. We have not solved that. But there is a second gap, and it is more fixable: today’s tutor has no memory of the student. It sees one problem at a time, then forgets you the moment it is done.

The deeper issue Brown and Burton identified in 1978: a roomful of children can write the identical wrong answer to a subtraction problem, each having reached it through a different broken procedure (Brown and Burton, 1978). The wrong answer alone is diagnostically ambiguous. A stateless tutor sees one wrong answer. A tutor with memory sees which broken algorithm keeps producing it.

So the next build is a memory of each student. The idea of tracking what a student knows and where they keep getting stuck goes back decades in education research (Corbett and Anderson, 1994; Piech et al., 2015). The tutor watches what you ask, where you stall, and which problem types trip you up, then uses that to personalise the next lesson, the next quiz, the next worked example. It also reshapes the team itself: the same specialist agents, composed differently for the student in front of them. Well built tutoring systems already match a human one on one tutor (VanLehn, 2011).

The same discipline applies to a student memory. A memory that invents facts about a student is just a new way to be confidently wrong. A profile must be grounded in real interactions, never hallucinated, and student data demands explicit consent and privacy by design. The two mechanisms that make today’s system honest, grounding and independent verification, are exactly what a personalisation layer will need.

Final Thoughts

Scoring 351 out of 360 proves a model can solve JEE. It does not prove it can be trusted to teach it.

The bridge is not a bigger model. It is the system around it: an orchestrator, specialist agents, skills, and tools, with verification built in. This is not a prompt. This is an architecture.

We built it for IIT-JEE, but the same system runs any domain: the textbook, the skills, and the tools just change. Any AI you would put in front of a customer, a patient, or a student should show how it got there, and know the line past which it must not guess.

References

1. Huang et al. Large Language Models Cannot Self-Correct Reasoning Yet. ICLR 2024. arxiv.org/abs/2310.01798
2. Gou et al. CRITIC: LLMs Can Self-Correct with Tool-Interactive Critiquing. ICLR 2024. arxiv.org/abs/2305.11738
3. Tyen et al. LLMs Can’t Find Reasoning Errors, but Can Correct Them Given the Error Location. ACL Findings 2024. aclanthology.org
4. Chen et al. FrugalGPT. 2023. arxiv.org/abs/2305.05176
5. Lightman et al. Let’s Verify Step by Step. 2023. arxiv.org/abs/2305.20050
6. Gao et al. PAL: Program-Aided Language Models. 2023. arxiv.org/abs/2211.10435
7. JEE Advanced 2026: We Tested AI on the Toughest Exam. LearnOpenCV. link
8. ChatGPT Ranked in the Top 20 in JEE Advanced 2025. LearnOpenCV. link
9. Aligning LLMs with Pedagogy using RL (the 66 percent answer-reveal finding). 2025. arxiv.org/abs/2505.15607
10. Brown and Burton. Diagnostic Models for Procedural Bugs in Basic Mathematical Skills. Cognitive Science, 1978. PDF
11. Corbett and Anderson. Knowledge Tracing. UMUAI, 1994. link. Piech et al. Deep Knowledge Tracing. NeurIPS 2015. arxiv.org/abs/1506.05908
12. VanLehn. The Relative Effectiveness of Human Tutoring, ITS, and Other Tutoring Systems. Educational Psychologist, 2011. link