IdentAI: Autonomous Background Learning Ops Agent

An autonomous background agent built with Strands Agents SDK & Bedrock AgentCore that handles routine grading & progress tracking, surfacing only when mentors must make critical student decisions.

Comment

Inspiration

Over the past year teaching computer science in high school, I lived the same structural friction every Sunday night: preparing differentiated curriculum for thirty students with wildly disparate skill levels.

In any introductory programming session, five students finish in minutes and need open-ended algorithmic challenges, fifteen move at grade level, and ten are completely blocked by indentation, syntax, or variable scoping errors. Hand-crafting three tiered worksheets, three aligned quizzes, and three matching answer keys takes hours of repetitive drafting before a teacher ever steps foot in the classroom. Furthermore, generic AI chatbots fail educators because they act as "answer dispensers," outputting copy-paste code that circumvents the cognitive struggle required for real mastery.

I built IndentAI to solve the exact problem I faced in my classroom: an autonomous worker that plans, generates, audits, and formats differentiated curriculum while keeping the educator firmly in the loop.

What It Does

IndentAI turns a single learning objective (e.g., "Unit 2: Nested Loops & Grid Navigation") into an export-ready, classroom-verified instructional package:

  1. 3-Tier Differentiated Scaffolding: Autonomously synthesizes three aligned difficulty tiers:
    • Tier 1 (Foundational): Word banks, fill-ins, and execution trace tables for struggling students.
    • Tier 2 (On-Level): Guided self-correction and syntax-to-logic problem sets.
    • Tier 3 (Advanced): Open-ended optimization, complexity analysis, and algorithmic extensions.
  2. Self-Auditing & Auto-Repair Loop: The agent evaluates its own generated assets against pedagogical rules. If an asset fails (such as a missing trace table in Tier 2), it self-corrects and re-audits in the background before the educator ever sees it.
  3. Misconception-Driven Assessments: Multiple-choice distractors are mapped directly to conceptual flaws (e.g., choosing 7 instead of 12 for nested loops of 3 and 4 indicates additive instead of multiplicative thinking), showing teachers what to reteach rather than just who lost points.
  4. The Teacher Review Desk: When the agent encounters a genuine pedagogical decision (such as whether Grade 7 advanced students should use coordinate pairs or matrix notation), it halts and routes the item to the review queue for one-click human authorization.
  5. Classroom-Ready Export: Generates clean, print-ready PDFs, Markdown, and HTML packages with teacher notes and answer keys.

How We Built It

  • Agent Core & Reasoning: Powered by Amazon Bedrock invoking Amazon Nova Pro (us.amazon.nova-pro-v1:0) via the ConverseStream API for schema-adherent curriculum synthesis and self-audit evaluations.
  • Deterministic Code Evaluation: Built an Abstract Syntax Tree (AST) inspection engine in Python (app/interpreter/evaluator.py) to validate student code structures, extract nodes, and detect syntax errors without execution hazards.
  • Resilience & Dual-Engine Design: Engineered an autonomous fallback mode (MODEL_PROVIDER=mock) backed by SQLite (data/lessons.db) to ensure complete operational continuity during intermittent school internet connections or API quarantines.
  • Backend & API: Powered by FastAPI with structured Pydantic data schemas, background session logging, and RESTful endpoints for lesson generation and review desk approvals.
  • Infrastructure & Deployment: Fully containerized via Docker (agentcore/Dockerfile) for reproducible local or cloud deployment.

Challenges We Ran Into

  • Classroom Connectivity & Cloud Resilience: School networks frequently suffer from strict proxy firewalls and connection drops. We solved this by designing a dual-engine runtime where the system deterministically falls back to local AST parsing and SQLite-cached lesson progressions if cloud endpoints become unreachable.
  • Preventing Hallucinated Answer Keys: Language models often hallucinate answers to synthetic code challenges. We introduced an automated self-audit verification loop where the agent cross-checks every question against the generated worksheet before saving drafts.
  • Balancing Autonomy with Oversight: Defining the boundary between what the agent should auto-repair versus what requires human judgment. Formatting bugs and missing tables are repaired automatically, while curriculum scope decisions are explicitly escalated to the teacher.

Accomplishments That We're Proud Of

  • Validated by real high school teaching requirements—producing documents ready to print and hand to students immediately.
  • Implementing a complete self-healing audit loop where the agent catches and fixes its own defects without human intervention.
  • Achieving a sub-second human-in-the-loop dashboard that respects teacher time and domain expertise.

What We Learned

  • Foundation models like Amazon Nova Pro excel at strict, structured JSON schemas when given clear role boundaries and step-by-step evaluation rubrics.
  • Autonomous agent design is most effective when paired with deterministic validation layers (like Python ASTs) rather than relying exclusively on LLM outputs.

What's Next for IndentAI

  • Expanding language support beyond Python to JavaScript, Scratch block translation, and C++.
  • LMS integrations with Google Classroom and Canvas to assign tiered worksheets with one click.
  • Live student IDE telemetry, allowing real-time hint escalation during in-class lab sessions.

Built With

Share this project:

Updates

Submission history