How We Made Iggy Smarter Without Slowing Him Down for Younger Kids

July 26, 2026· IQnition team

Iggy just got a lot better at helping older students with hard math — and along the way, we fixed a small but real bug that was frustrating families who send in photos of homework. This is a peek behind the curtain at what changed, why it matters, and how we thought about the tradeoffs.

How we tend to work

Both of the changes in this post started the same way: a real family told us something wasn’t good enough. A beta parent said her junior’s calculus answers were wrong. Another parent uploaded a photo of a worksheet and watched Iggy “forget” it a few minutes later. In both cases, we looked at the problem that week, argued about the right shape of the fix, wrote the code, ran the tests, and shipped it.

Sometimes a fix is a config change we can ship the same day. Sometimes — like the memory rebuild in this post — it’s a real architectural change that takes a few days of careful engineering, plus tests, plus a design doc so future us doesn’t reinvent it. Either way, we’d rather move quickly on a real family’s actual pain than sit on it while we design something grander. The bigger, prettier version can come next quarter. The kid stuck on their homework tonight can’t wait until next quarter.

The problem: one AI model was doing every job

For most of the past year, Iggy used a single general-purpose AI model whether your third grader was working through addition or your eleventh grader was stuck on a calculus derivative. That worked well enough for the younger kids, but our beta parents kept flagging the same thing:

“It’s great for my daughter in 5th grade, but my son is a junior and Iggy gets his calculus wrong.”

They were right. The model we were using was fast and friendly, but it wasn’t built for the kind of multi-step reasoning that AP Calc or advanced Algebra II require. You could see it in the answers — Iggy would confidently derive a result that skipped a step, or apply a rule that only looks like the right one.

Two families of AI models — and why the difference matters

There are two broad classes of AI models useful for tutoring:

Instant-response models. These generate an answer in a couple of seconds. They’re excellent for conversation, definitions, arithmetic, and single-step reasoning. What they don’t do well is “think out loud” — they don’t pause internally to check their own work.
Reasoning models. These are a newer class (you may have seen them called “o1” or “thinking” models in other products). They spend time before answering — sometimes 20 or 30 seconds — generating internal chains of reasoning that never appear in the final response, then producing an answer. On hard problems, this is a large accuracy improvement. On simple problems, it’s just a long wait for the same answer.

The design lesson is straightforward: use each class where it belongs. A first grader shouldn’t wait 40 seconds for “what’s 2 + 2?” — and an AP student shouldn’t get a fast wrong answer to a derivative.

The fix: match the model to the grade

Iggy now routes each request to a different model based on the student’s grade:

Grades 3–6 get a fast instant-response model at its lightest setting — great for arithmetic, fractions, and simple word problems.
Grades 7–8 get the same model at a slightly deeper “thinking” setting for multi-step pre-algebra.
Grades 9–10 get a proper reasoning model at moderate depth — enough for Algebra II and Geometry.
Grades 11–12 and AP get the reasoning model at full depth — for calculus, statistics, and college-prep material.

If we don’t know the student’s grade for some reason, we default to the safest option: the fast, US-hosted model at its light setting. A missing grade never routes up to the heaviest tier by accident.

The hard part isn’t picking models — it’s making them safe

Choosing a smarter model for older students is easy to say and complicated to ship responsibly. The reasoning model that’s genuinely best-in-class at STEM right now originates outside the US, which is a completely reasonable choice technically — but it needs the right operational surface before it can touch a kid’s homework. What that meant for us:

Route through a vetted US-hosted enterprise pipeline — the model runs on servers we’ve approved, and requests can’t silently reroute to servers we haven’t. If the approved path is unavailable, the request fails cleanly rather than fall back to a location we didn’t sanction.
Zero-data-retention at the account level. The upstream providers are contractually bound not to store prompt or response data. We don’t just trust that — we require it via the routing configuration.
No training on child data. Written into the routing policy, per request, on top of the account-level agreement.
Personal information is scrubbed BEFORE the model call. Every request passes through a safety and privacy gateway that removes phone numbers, addresses, names, and identifiers — the vendor never sees them. This isn’t specific to one model; it’s the same gate every AI call in Iggy has been passing through for months.
A compliance feature flag. The higher-tier model can be turned off from a single environment variable without a code change. That means if anything ever looked wrong, we could roll back the whole tier in under a minute.

A parent shouldn’t need to know any of this to trust Iggy. But if you do want to know, this is the shape of it.

What this looks like in an actual session

An early beta test. A 10th grader shared this Algebra II problem:

Simplify: (12a² + 54a) ÷ 54a

The previous Iggy would have taken a stab and might have skipped a step. The new Iggy walked her through it Socratically — one move at a time, pausing after each to ask what she thought came next — and landed on the correct simplified form of (2a + 9) / 9. Total wall-clock time: about a minute. Not instant, but the kind of pause that comes from a tutor actually working, not a tool guessing.

For grade-school kids, response times stayed roughly the same as before, because their tier didn’t change.

The photo problem we also fixed

While we were working on the model routing, a parent hit a related snag. Their daughter uploaded a photo showing three multiple-choice questions from a stats worksheet. Iggy correctly transcribed all three and helped her through question 8. But when she asked about question 9, Iggy said, “I don’t have the text for question 9 — could you share it?” She replied that she’d sent it in the image, and Iggy answered, “I’m sorry, I can’t see any images.”

Frustrating — and technically the interesting part is why. Two things were happening.

First: the reasoning model we use for the older tier can’t process images directly. It only reads text. So we built what we call a vision router: any image the student uploads is first sent to a separate multimodal model that transcribes it — reads the handwriting, preserves the math notation, describes any diagrams — and hands back plain text. The reasoning model then works on the text. Two calls per image, one clean pipeline for every grade. (For consistency and OCR quality, we route every image this way, not just the older tier’s. It’s better at reading young kids’ handwriting than a general-purpose reader would be.)

Second — the actual bug — Iggy’s short-term conversation memory only kept the last handful of turns. The photo’s transcription lived inside the first turn, and by the time you’d worked through question 8, that turn had rolled out of memory. Iggy wasn’t lying about not seeing the image; it genuinely no longer had the transcription in view.

Fix: a proper session-scoped memory for anything the student uploads. Photos, and eventually voice notes when we add that feature, now stay in scope for the entire conversation. When you upload a worksheet on turn one, Iggy still remembers it on turn twenty. The structure holds one row per uploaded artifact, tagged with its modality (image today, audio when we add voice), stored full-fidelity — never summarized to save space, because a summarized worksheet is a worksheet the tutor gets wrong in a subtle way you’d never catch.

Handling the hard cases: when the model is slow or gets stuck

Reasoning models come with a failure mode we hadn’t seen before: on genuinely pathological problems (an unsolvable logic puzzle, for instance), the model can get stuck iterating for minutes. In our first tests with a real unsolvable puzzle, one request took over five minutes before it was killed by a server timeout — and the student saw a scary “trouble connecting” message that had nothing to do with their internet.

We added two guardrails:

A 90-second client-side timeout on every reasoning-model request. This is transport-level (we hang up the phone if it’s still ringing after 90 seconds), so it works no matter what the model is doing on the other end. Genuine deep-reasoning turns finish well under this. Pathological loops don’t.
Honest error copy. When we bail out after 90 seconds, Iggy tells the student the truth: “I got stuck on that one. Try sending it again, or ask me to help you with just the first step to get started.” Two things it deliberately doesn’t say: don’t blame the student’s internet, and don’t tell them to “rephrase” a homework problem they can’t change. Small copy detail — real UX difference for a kid staring at a broken screen.

What families should notice

Older students get materially better math help — especially calculus, precalc, and higher-level algebra. Response times on those grades are longer (30–60 seconds instead of a few) because the model is actually thinking through the problem. It’s a deliberate tradeoff we made in favor of accuracy.
Younger students shouldn’t notice much of a difference — they were already well-served by the previous model, and their tier stayed fast.
Photo-based homework now works across a whole session. You can upload one photo and reference it across many follow-up questions. Iggy won’t ask you to re-share it.
The tutor is honest when it’s stuck. If a problem is unusually hard and Iggy takes too long, it tells you so and asks you to retry — instead of timing out silently.

What we didn’t do (and are working on next)

We want to be honest about what a smarter model doesn’t fix. Even the best AI models today can be confidently wrong on tricky problems — especially puzzles with multiple constraints or subtle logic. The next thing on our list is an answer-verification layer for math: when Iggy gives a final answer, a deterministic checker built on proper math libraries will confirm the arithmetic before the student sees the answer marked as final. That’s a bigger project — measured in weeks, not days — but we think it’s where the next large accuracy win lives. A math library is dumb but always right; a language model is smart but sometimes wrong. Composing them well should give us the best of both.

We’re also planning a voice input mode so students can talk through a problem instead of typing. Younger kids especially find speaking easier than typing, and the memory system we just built is already prepared to hold voice transcripts alongside photo ones — no rebuild required.

The philosophy underneath all this

A tutor’s job is to help a student learn, not to impress anyone with what it can do. That means:

Being fast when the problem is simple.
Being thorough when the problem is hard.
Being honest about limits — broken photos, hung requests, genuinely hard problems.
Keeping safety and privacy the first check on every request, not something bolted on after.

If Iggy is quietly better this week and you don’t notice at all — that’s the goal. And if your junior gets their calculus homework right on the first try, we hope it feels like magic. The truth is closer to careful engineering, but we’ll take either interpretation.

If Iggy does something weird, please tell us

Every fix in this post started with a family flagging something that felt off. The junior’s wrong calculus answers. The photo Iggy “forgot” mid-conversation. The scary “trouble connecting” message on a slow response. None of those are things we could have found by looking at our own dashboards — they were real friction in real sessions, and someone had to tell us.

So if Iggy does something that surprises you — good or bad — please tell us. Reply to any Iggy email, or send a note through the app. We can’t always ship a fix the same day. But the odds that a real report from a real family becomes a real change to Iggy in the next couple of weeks are much higher than you’d guess.

We especially want to hear from families with kids in grades 9–12; that’s the tier we just changed, and your feedback is what tells us whether we got it right.