Mynawoo Learning Autopilot

An AI learning agent powered by GPT-5.6 that turns every learner mistake into a personalized lesson, practice set, and adaptive study plan.

Comment

Inspiration

I built Mynawoo around a simple frustration: learning platforms remember a learner's progress, but AI conversations usually do not.

A learner can spend weeks completing lessons, making mistakes, reviewing vocabulary, and advancing through a CEFR course. But when they open an AI assistant, that entire learning history disappears and the conversation starts from zero.

For OpenAI Build Week, I wanted to close that gap.

My goal was not to place another generic chatbot inside an education product. I wanted ChatGPT to securely understand the learner's real course, current lesson, progress, recent mistakes, difficult vocabulary, and spaced-repetition schedule—and then help them take the most useful next action.

What it does

Mynawoo Learning Autopilot connects ChatGPT to a learner's Mynawoo account through OAuth and the Model Context Protocol.

A learner can ask questions such as:

  • What should I study today?
  • Where am I making the most mistakes?
  • Create a grammar exam based on my current lesson.
  • Show me the vocabulary I struggle with.
  • Add this word to my Leitner cards.
  • What should I review before continuing?
  • How has my learning changed this week?

ChatGPT can securely retrieve the learner's active course, CEFR level, current unit and lesson, lesson progress, grammar mistakes, difficult vocabulary, Leitner review cards, and learning analytics.

It can then recommend a specific next step and, after the learner approves it, save a targeted grammar exam, vocabulary card, Leitner set, or personalized learning recommendation directly to Mynawoo.

The result is a closed learning loop:

Learn in Mynawoo → analyze with ChatGPT → take action → save the result → continue learning

The assistant does not only answer questions. It helps the learner move forward inside their real learning journey.

A real learning agent, not a generic chatbot

Mynawoo Learning Autopilot is connected to the live Mynawoo learning system rather than sample data or a static knowledge base.

The learner-facing MCP provides 24 focused tools covering:

  • Courses, CEFR levels, units, lessons, and lesson search
  • Current learning state and progress
  • Grammar content and personalized exam generation
  • Previous mistakes and cross-skill weakness analysis
  • Learning recommendations and study planning
  • Leitner sets, due cards, and difficult vocabulary
  • Vocabulary-card preview, creation, editing, and deletion
  • Learning analytics across different time periods

The tools return structured, bounded data instead of exposing the underlying database or unrestricted backend operations.

Eight interactive ChatGPT widgets turn these results into useful interfaces for course selection, current progress, weakness analysis, exam confirmation, generated-exam previews, vocabulary previews, Leitner-set selection, and today's vocabulary review.

This allows ChatGPT to behave like part of the learning product rather than a separate text-only assistant.

What I built for OpenAI Build Week

Mynawoo existed before the hackathon as a web and Android language-learning platform.

This submission focuses specifically on the new agent layer that connects the existing learning system to ChatGPT and turns learner data into safe, personalized actions.

The submitted work includes:

  • A learner-facing MCP with 24 narrowly scoped tools
  • OAuth-based account connection and permission scopes
  • Structured input and output schemas for reliable tool calls
  • Interactive ChatGPT Apps SDK widgets
  • Aggregation of progress, mistakes, lessons, and vocabulary into useful learning context
  • Cross-skill weakness analysis for grammar, reading, listening, writing, and vocabulary
  • Confirmation-based grammar exam generation
  • Preview-before-save vocabulary workflows
  • Persistent personalized learning suggestions
  • Idempotency protection for repeatable write operations
  • Ownership checks and private learner data boundaries
  • Auditing and safe error handling for MCP actions
  • Deep links back into the relevant Mynawoo lesson, exam, or vocabulary section

The work transforms Mynawoo from a platform that learners use beside ChatGPT into a platform that ChatGPT can understand and operate with safely.

How I built it

The Mynawoo backend is built with Python, Django, Django REST Framework, PostgreSQL, Redis, and Celery.

The MCP layer sits in front of existing learning services. Each tool has a focused responsibility, a defined schema, required OAuth scopes, and a bounded response.

A tool request passes through:

  1. Authentication and OAuth scope validation
  2. Tool-specific input validation
  3. Mynawoo learning services
  4. Ownership and permission checks
  5. Structured output generation
  6. Audit and error handling
  7. An optional interactive ChatGPT widget

Write operations are intentionally more controlled than read operations.

For example, ChatGPT first resolves the learner's intended grammar lesson and shows a confirmation interface. Only after the learner confirms the target does it generate and save the exam.

Vocabulary follows a similar preview-first flow. The learner can inspect the word, translation, explanation, example, synonyms, antonyms, CEFR level, and selected Leitner set before the card is stored.

Retryable write operations support idempotency keys so a repeated request does not accidentally create duplicate exams, cards, or recommendations.

I used Codex with GPT-5.6 to navigate the existing Django codebase, define the MCP boundaries, improve tool contracts, refactor learning services, inspect authorization flows, trace edge cases, and iterate on the end-to-end ChatGPT experience.

Codex was especially valuable because the work crossed authentication, course content, learner progress, exams, Leitner vocabulary, analytics, and interactive UI resources inside a large production codebase.

Security and isolation

An AI learning assistant needs useful context, but it should not receive unrestricted access to the application.

Mynawoo uses scoped OAuth permissions for learning data, exams, vocabulary, analytics, and personalized recommendations. Tools only receive the minimum information required for the current action.

Generated exams and vocabulary remain associated with the authenticated learner. Write actions repeat ownership validation, and sensitive actions use explicit confirmation or preview flows.

Mynawoo also has a completely separate Admin MCP for authorized platform operations. The learner MCP and Admin MCP use separate registries, permissions, and operational boundaries, preventing administrative tools from being exposed to learners.

High-impact administrative actions use a preview-and-apply workflow instead of allowing the AI to make silent production changes.

Challenges

Choosing the right amount of context

Sending every piece of learner data would create noise and unnecessary privacy risk. Sending too little would produce generic recommendations.

I built focused context services that combine only the most relevant information: recent mistakes, weak skills, current progress, difficult words, due Leitner cards, and previous recommendations.

Making AI actions safe

It is easy to let an AI generate text. It is much harder to let it safely create something inside a real user account.

I added ownership checks, OAuth scopes, structured validation, confirmation interfaces, preview flows, audit records, and idempotency protection so useful actions remain controlled and predictable.

Connecting AI to an existing product

Mynawoo already served learners through web and Android applications. The new agent layer had to reuse real course and learner data without disrupting those existing experiences.

The MCP integration therefore uses the same underlying domain services and stores generated results in formats already understood by the web and mobile applications.

Accomplishments that I am proud of

  • Connected a live language-learning platform to ChatGPT
  • Created a closed loop between analysis and real learner action
  • Built 24 focused learner tools instead of exposing broad backend access
  • Added interactive ChatGPT interfaces rather than returning raw JSON
  • Combined course progress, mistakes, analytics, and spaced repetition in one assistant
  • Allowed generated exams and vocabulary to continue inside the existing Mynawoo applications
  • Separated learner AI access from privileged administrative operations
  • Added production-oriented authorization, auditing, validation, and retry safety

What I learned

The quality of an educational agent does not depend only on the intelligence of the model.

It also depends on the quality of its tools, the structure of the curriculum, the accuracy of learner history, the amount of context provided, and the boundaries around every action.

I learned that the most useful AI tutor is not one that constantly generates more content. It is one that understands what the learner has already studied, identifies the most important weakness, and helps them take the next meaningful step.

What's next

The next stage of Mynawoo Learning Autopilot will include:

  • Daily adaptive learning plans
  • Personalized speaking and pronunciation practice
  • More interactive ChatGPT learning activities
  • Long-term skill comparisons across grammar, reading, listening, writing, and vocabulary
  • Teacher and organization dashboards
  • More multilingual CEFR courses
  • Smarter review scheduling based on learner performance
  • Optional proactive reminders for due lessons and vocabulary

My long-term goal is to give every learner an AI learning companion that understands not only what they are asking now, but also what they have learned, where they struggle, and what they should do next.

Built With

Share this project:

Updates