Learning Engineer Agent: What Does Agentic AI Actually Mean for EdTech?

---

🚀 Learning Engineer Agent is live in production. Try it at learning-engineer-agent.web.app — sign in with Google and request a beta access code using the form on the access screen, or reach out to me directly.

Access is code-gated and intentionally limited. I am inviting a small cohort of early users — instructional designers, L&D practitioners, and EdTech researchers — who want to explore the system and are willing to share feedback. If you would like a code, request one here.

---

How it works (Pipeline V2 Flow): Knowledge Base ➔ Interviews ➔ Synthesis ➔ Course Outline ➔ Lessons ➔ Slides

Here is how the collaborative V2 pipeline works in simple terms:

1. Knowledge Base: AI researches the web to map core concepts and identify initial knowledge gaps.
2. Interviews: Invite subject matter experts to share real-world insights via AI-led Socratic chats.
3. Synthesis: Combine web research and expert interview transcripts into a unified, structured Knowledge Base.
4. Course Outline: AI structures modular learning pathways (Novice, Intermediate, Advanced) and sequences lessons.
5. Lessons: Draft slide-by-slide visual layouts, copy, narration scripts, and QA audits in parallel.
6. Slides: Compile and style storyboards into final, ready-to-teach slide decks.

Watch the original Pipeline V1 demo (How it started):

The Question That Started This

I have spent years in EdTech — building platforms, thinking about content, watching instructional designers struggle with the same fundamental problem over and over. Subject matter experts know things that are extraordinarily valuable. But getting that knowledge out of their heads and into a structured learning experience is slow, expensive, and deeply inefficient.

When large language models became genuinely capable, the obvious question was: can AI solve this? Can you give an AI a topic and get back a complete, ready-to-teach eLearning course?

The short answer is yes. The more interesting answer is: yes, but not in the way you might expect — and understanding the difference matters enormously for anyone building AI products in education.

This project is my attempt to build that system, and to think rigorously about what “agentic” actually means when the output needs to be trusted by real learners.

---

The Problem With “Just Give It a Topic”

The fantasy version of this product is simple. You type “Introduction to Negotiation for Sales Teams” and thirty minutes later a polished eLearning course lands in your inbox. No humans required.

I considered building exactly that. I decided not to.

Here is why. The hardest problem in eLearning is not content generation — it is knowledge elicitation. Subject matter experts have what researchers call tacit knowledge: things they know so deeply that they can no longer articulate them clearly. They teach the theory while their actual expertise lives in the exceptions, the edge cases, the heuristics they have developed over years of practice.

An AI that researches a topic on the web and generates slides is not solving this problem. It is generating a reasonable-looking approximation of what the internet knows about a topic. That is useful for some things. For expert knowledge transfer, it is not enough.

The real product needed to do something harder: extract what the expert actually knows, and integrate it with human-in-the-loop validation at key stages to combine AI scale with human expertise.

---

What Agentic AI Looks Like in Practice

Before building this, I spent time thinking carefully about what “agentic” means — not as a marketing term, but as an architectural commitment.

A/B testing tools or simple code generators can run autonomously without human intervention. For eLearning course creation, I believe fully unsupervised autonomy is the wrong design.

The reason is not capability. It is trust and quality.

An eLearning course that will be used to train hundreds of employees cannot contain hallucinations, structural errors, or pedagogically unsound sequences. The cost of a mistake in training content is not a wrong search result that a user ignores; it is a misconception that propagates through an organization. The stakes demand human judgment at critical junctures.

So instead of one long-running autonomous agent, I designed a system of agentic episodes — discrete bursts of intelligent autonomous behavior, each producing a meaningful output that a human reviews and approves before the next episode begins.

This distinction — agentic episodes versus long-running autonomous agents — is the most important architectural insight in this project.

---

The User-Facing Workflow

To lower cognitive load for the course creator, the system structures the user journey into 6 clear steps, aligned with what the AI does versus what you do:

1. Knowledge Base:
   • 🤖 AI does: Gathers 30+ web sources to map core concepts and identify initial expert knowledge gaps.
   • 👤 You do: Enter your course topic, target audience, and optional context.
2. Interviews:
   • 🤖 AI does: Conducts live Socratic audio/text interviews to extract tacit expert insights.
   • 👤 You do: Invite subject matter experts by email; they answer at their own pace using a secure link.
3. Synthesis:
   • 🤖 AI does: Synthesizes transcripts and web research, resolving gaps into a unified base.
   • 👤 You do: Review synthesized concepts and fill in any remaining gaps.
4. Course Outline:
   • 🤖 AI does: Generates modular learning pathways (Novice, Intermediate, Advanced) and sequences lessons.
   • 👤 You do: Customize modules, reorder lessons, and select your approved pathway.
5. Lessons:
   • 🤖 AI does: Drafts slide-by-slide visual layouts, copy, narration scripts, and QA audits in parallel.
   • 👤 You do: Review the generated copywriting blocks, visual layouts, and voiceover scripts for each lesson.
6. Slides:
   • 🤖 AI does: Assembly engine compiles and styles lesson storyboards into ready-to-teach slide decks.
   • 👤 You do: Select typographic styles, preview compiled slides, and export to Google Slides in one click.

---

Under the Hood: LangGraph & The 10-Agent Engine

While the user interacts with 6 simple gates, the backend orchestrates a complex network of 10 specialized agents via LangGraph. An agent earns its existence in this system only if it has a genuinely different cognitive expertise.

Agent	Expertise
DiagnosticAgent	Web research, knowledge base construction using Gemini 2.5 Flash.
InterviewAgent	Socratic expert interviews — tacit knowledge elicitation using Claude Sonnet.
KnowledgeSynthesisAgent	Maps expert insights to concept nodes, weights by depth score, flags expert-vs-research contradictions.
CurriculumArchitectAgent	Prerequisite sequencing, pathway-differentiated course structures (novice / intermediate / advanced).
PedagogicalDesignerAgent	Instructional strategy selection (worked examples, misconception-correction, scenario-based) using Mayer’s multimedia principles.
LessonResearchAgent	Targeted research per lesson — gap-filling informed by the instructional strategy.
ContentAgent	Instructional writing from a fully-specified pedagogical brief.
StoryboardAgent	Multimedia learning principles — visual slide-by-slide layout copywriting.
QAAgent	Constructive alignment audit per module — objectives ↔ content ↔ assessments.
SlideAssemblyAgent	Compiles and styles visual spec storyboards and copywriting blocks into final slide formats.

Map-Reduce Parallel Storyboarding

In Pipeline V2, lesson storyboard generation runs in parallel using a map-reduce architecture. When the creator approves an outline (e.g. an Intermediate pathway with 20 lessons), the orchestrator triggers 20 parallel threads. Each thread researches, drafts storyboard copy, writes voiceover scripts, and audits the lesson for alignment. The system utilizes Cloud Run’s Always-On CPU allocation to complete all 20 lessons concurrently in seconds, rather than minutes.

---

Technical Stack

The system is built on a microservices architecture, with each agent running as an independent Cloud Run service.

• Frontend: Flutter Web, deployed on Firebase Hosting. Single codebase handles both course creator and expert interview flows.
• Backend: Python services on Google Cloud Run with --no-cpu-throttling (Always-On CPU) to support heavy background concurrency without thread interruption.
• LLM Strategy: Hybrid. Gemini 2.5 Flash handles research and web grounding with search grounding. Claude Sonnet handles reasoning-heavy tasks like Socratic interviewing, synthesis, outline structuring, and visual slide storyboarding.
• Orchestration: LangGraph manages the graph state, checkpointing progress to Firestore, handling parallel execution, and waiting at human interrupt gates.
• Infrastructure: Firestore for real-time state sync, Secret Manager for API keys, and Google Slides/Drive APIs for slide exports.

---

Technologies: Flutter, Python, Google Cloud Run, Firebase, Vertex AI, Anthropic Claude, Gemini 2.5 Flash, LangGraph, Google Slides API
Timeline: 2026 — Present
Status: Live in Production · Pipeline V2 Deployed

Interested in AI-powered learning systems or the design of human-in-the-loop products? Let’s connect!