Classroom Differentiation Agent

inclusive education, automated. A teacher pastes one lesson, ticks the support needs in the class, and gets back a differentiated version for each — checked by a guardrail agent

Comment

Inspiration

Children with additional learning needs have always had my heart. In Dutch education we call it passend onderwijs — inclusive education — and the intention is beautiful: every child gets what they need to learn. But the reality lands on the teacher. Differentiating one lesson for a class where five or more pupils each have a different support profile is slow, repetitive work, done by hand, lesson after lesson. Teachers want to do it. Many of them burn out trying.

I want to give teachers the tools to help these children even better — without coming home exhausted.

What it does

A teacher pastes one lesson, ticks which support needs are present in the class, and the agent rewrites the material once per profile — automatically, without lowering the academic level.

How we built it

Building on what came before

This isn't where my journey started. In an earlier project I built a tool that helped teachers differentiate lesson material inside their own documents, profile by profile. It worked — but teachers kept telling me the same thing: "If I could just do this for my whole class in one go, everything would be so much easier."

That comment stuck with me. Two weeks ago I came across the All Things Agentic Hackathon, and it was the final push I needed to build exactly that — a whole-class version — before returning to optimise my existing work.

Under the hood it's a multi-agent system on Google Cloud:

Two Google ADK agents: a rewrite specialist (the support profile is passed in as a parameter, so one specialist serves every profile) and a guardrail agent that checks each rewrite against a fixed set of pedagogical rules before it reaches the teacher. A FastAPI backend orchestrates them — looping per selected profile, calling both agents, and assembling the results. Both agents run on Gemini 3.5 Flash on Vertex AI (EU endpoint), and the whole service is deployed on Cloud Run in europe-west4. Privacy by design: the teacher ticks which barriers occur in the class — no names, no per-pupil data, everything within the EU region.

**What we learned

The biggest lesson was architectural honesty. My first instinct was to describe a grand orchestrator agent — but the orchestration is really plain Python, and state is in-memory, not persisted. Saying that clearly is stronger than overclaiming. I also learned how much a second agent changes the story: building a guardrail purely to check the first agent turned "a chatbot that returns text" into a system that enforces its own promise — that the academic level is never lowered.

Challenges we ran into

Migrating to Gemini 3.5, wiring up the ADK for the first time, and getting a clean deployment on Cloud Run (IAM roles and re-authentication were the usual suspects). The hardest part wasn't the code, though — it was staying disciplined about scope: building one thing that genuinely works, rather than everything at once.

What's next for Classroom Differentiation Agent

The pedagogical rules are being refined together with a practising teacher and an educational specialist, both to sharpen the current profiles and to add the remaining ones. After the hackathon, I'll bring these learnings back to my existing tool.

Accomplishments that we're proud of

A working multi-agent system, deployed live on Google Cloud, that enforces its own pedagogical promise. The guardrail agent means the tool doesn't just rewrite material — it checks every rewrite against a fixed set of rules before it reaches the teacher, so the academic level is never lowered and the pupil still does their own thinking.

What I'm most proud of: these were the first agents I'd ever built, and I took them from an idea to a live, deployed application on Cloud Run — solo, in one week, alongside a full client load.

What we learned

These were the first agents I'd ever built. I'd read a lot about them, and the examples I kept seeing — what people are already pulling off with agents — genuinely excited me. That short deadline was exactly the push I needed to dive in and build my own.

The biggest technical lesson was how much a second agent changes the story: building a guardrail purely to check the first agent turned "a tool that returns text" into a system that enforces its own promise. I also learned to read a Python traceback from the bottom up, that IAM roles and re-authentication are the usual suspects in a Cloud Run deploy, and — maybe most importantly — the value of staying disciplined about scope: building one thing that genuinely works, rather than everything at once.

Built With

Share this project:

Updates