Thoughts
Agentic Learning: What If the App Learned How to Teach You?
Exploring a voice-driven learning environment where an agent manages the learning workflow while the student does the cognitive work.
Sep 9, 2026 - 5 min read
What if a learning app didn’t make the student operate it?
Most learning apps are built around a set of tools.
You open the app, choose a subject, find a lesson, create notes, start a quiz, check your mistakes, and decide what to study next.
The student is responsible for operating the entire learning system.
I started thinking about a different approach:
What if the learning system itself was agentic?
Instead of making the student navigate through different features, the student could simply tell the agent what they want to learn.
From there, the agent could take responsibility for coordinating the learning experience.
The idea
Imagine opening the app and saying:
“I have a physics test next Friday. Help me prepare for it.”
Instead of asking the student to configure a study plan, the agent could understand the goal and begin building the learning environment around it.
It could:
- Create and organize notes.
- Break the subject into concepts.
- Identify prerequisites.
- Teach concepts progressively.
- Ask questions and test understanding.
- Record mistakes and misconceptions.
- Create revision material.
- Generate tests based on what the student actually knows.
- Identify weak areas from test performance.
- Revisit difficult concepts later.
- Adapt the next learning activity based on the student’s progress.
The student wouldn’t need to constantly decide which feature to use next.
The agent would handle the workflow.
The agent wouldn’t replace learning
There is an important distinction here.
The goal isn’t to make an AI that simply gives students answers.
In fact, that could make learning worse.
The student still needs to think, recall, solve, explain, and make mistakes.
The agent’s job is to create the conditions for that learning to happen.
So instead of:
AI -> gives answer -> student moves on
the system could work more like:
Learn -> Attempt -> Evaluate -> Identify weakness -> Explain -> Practice -> Re-test -> Revise
The agent manages this cycle while the student does the actual cognitive work.
Voice as a core interaction
I also want the system to be heavily voice-driven.
Typing every instruction creates friction, especially when the student is trying to learn.
Instead, the student could simply talk to the agent.
They could say:
“Teach me this concept.”
or:
“Quiz me on what I studied yesterday.”
or:
“I don’t understand this part. Explain it another way.”
The agent could also interact through voice during active learning, asking questions and listening to the student’s responses.
The purpose of voice isn’t simply to add a voice assistant.
It’s to reduce the amount of interaction required to operate the learning system.
A different kind of learning app
This leads to a broader vision.
I don’t want to build an app where AI is just another feature.
I want to explore an app where the agent is the primary interface.
The application provides the structured environment:
- Notes
- Concepts
- Tests
- Mistakes
- Revision
- Progress
- Learning history
But the agent moves through these areas on the student’s behalf.
The student shouldn’t have to think:
“Which button should I press?”
They should be able to think:
“What do I want to learn?”
and communicate that naturally.
An example
Suppose a student is learning Electromagnetic Induction.
The agent could begin by determining what the student already understands.
It might teach a concept, then ask a few questions.
If the student repeatedly struggles with one part, the agent could recognize that pattern.
It could:
- Explain the concept differently.
- Add the misconception to the student’s learning record.
- Give targeted practice.
- Re-test the concept later.
- Include it in a future revision session.
Eventually, a larger test could be generated from the student’s actual history rather than from a generic question bank.
The system would therefore become increasingly aware of:
What the student has learned.
What they haven’t learned.
What they repeatedly forget.
And what they should work on next.
The question I’m exploring
This idea is still just an idea.
I haven’t built the complete system, and I don’t know yet how well the concept would work in practice.
There are difficult questions to solve:
- How autonomous should the agent actually be?
- How do we prevent it from teaching incorrect information?
- How should it determine whether a student truly understands something?
- When should it interrupt the student?
- How should revision be scheduled?
- How much control should the student retain?
- How do we prevent excessive dependence on AI?
- What should be handled by deterministic software versus an AI model?
- How do we make the system useful without making it complicated?
Those are the problems that make this interesting to me.
The vision
The simplest way I can describe the idea is:
The student chooses what they want to learn. The agent figures out how to help them learn it.
The application becomes less like a collection of educational tools and more like a learning environment operated by an agent.
I’m interested in exploring how far that idea can actually go.
Maybe it becomes a useful product.
Maybe parts of it work and parts don’t.
Maybe the entire approach needs to change.
That’s okay.
For now, this is an experiment in answering one question:
What would happen if we stopped building learning apps that students have to operate, and started building learning environments that could operate themselves?