ParentOps

An autonomous AI agent that understands your child’s school communications, turns them into actionable plans, and follows through—from reminders and purchases to exam preparation.

Comment

ParentOps: From School-Message Chaos to Action

Inspiration

Every working parent is familiar with the “9:00 PM school panic.”

You finally open a chaotic school WhatsApp or Telegram group and discover a barrage of messages sent throughout the day:

“Dear Parents, please note that the Science Quiz on Plants will be held on Tuesday. Also, students must bring 2 blue chart papers and a glue stick tomorrow for an art project. Dress code is sports uniform.”

What follows is pure cognitive exhaustion:

  1. Manually opening a calendar app and recording the quiz date.
  2. Scrambling to find chart papers and glue before bedtime.
  3. Figuring out what the child should revise for the quiz.
  4. Remembering to remind the child the next morning.
  5. Hoping nothing else was buried in another teacher's message.

The problem isn't a lack of information. It's the gap between information and action.

Modern parenting increasingly suffers from unstructured, fragmented cognitive overload. Important information is scattered across WhatsApp groups, emails, school apps, PDFs, and teacher announcements, leaving parents to manually interpret, prioritize, remember, and execute everything.

We asked ourselves:

Why should parents have to be human parsers and chore routers?

With agentic AI, school messages shouldn't simply be summarized. They should be understood, planned, and acted upon.

That vision inspired ParentOps — an autonomous AI co-pilot that turns chaotic school communications into completed chores, calendar events, reminders, and personalized study assistance.

What it does

ParentOps bridges the gap between teacher broadcasts and real-world execution.

📅 Automatic Calendar Synchronization

ParentOps identifies important dates and events from school communications, including:

  • Tests and exams
  • Parent-teacher meetings
  • Project deadlines
  • School events
  • Activities and participation dates

It automatically creates corresponding Google Calendar events, reducing the chance that an important school commitment gets forgotten.

🛒 Instant Quick-Commerce Assistance

The agent identifies physical materials required by the child, such as:

  • Chart paper
  • Glue sticks
  • Acrylic paint
  • Sketch pens
  • Craft materials

Instead of merely telling the parent “you need chart paper,” ParentOps generates ready-to-use search links for Blinkit, Zepto, and Amazon India, helping parents move from discovery to purchase immediately.

The goal is simple:

Don't just tell the parent what they need. Help them get it.

📝 AI Study Quiz & Revision Generator

When a message contains an upcoming test, ParentOps identifies the relevant topic and generates a 3-question rapid-fire revision quiz with answers.

This turns a school announcement into something immediately useful:

“Your child has a Science quiz on Plants tomorrow. Here are three questions you can ask over dinner.”

A five-minute interaction can become meaningful revision without requiring the parent to prepare the questions themselves.

🧠 Context, Memory & Deduplication

School communication can be noisy and repetitive.

ParentOps maintains same-day processing context using DynamoDB, allowing it to:

  • Remember messages already processed.
  • Avoid creating duplicate calendar events or reminders.
  • Aggregate related announcements.
  • Maintain context across messages from different teachers.

This allows the agent to reason over the school-day context, rather than treating every message as an isolated request.

How we built it

ParentOps uses a hybrid agentic architecture: an LLM handles ambiguity and reasoning, while deterministic application code guarantees reliable execution.

School Communications
        │
        ▼
 ┌───────────────────┐
 │ Message Ingestion  │
 │ WhatsApp / Email / │
 │ School Sources     │
 └─────────┬─────────┘
           │
           ▼
     FastAPI + SQS
           │
           ▼
 ┌──────────────────────┐
 │   Agentic Processor   │
 │                      │
 │ Understand → Plan →  │
 │ Tool Selection → Act │
 └──────────┬───────────┘
            │
     ┌──────┼───────────┐
     ▼      ▼           ▼
 Calendar  Materials   Study
  Tool      Search      Quiz
     │      │           │
     ▼      ▼           ▼
 Google   Blinkit /   Questions
 Calendar Zepto /     + Answers
          Amazon
            │
            ▼
        DynamoDB
   Context + Deduplication

Agentic reasoning

The agent receives an unstructured school message and determines:

  • What information is important?
  • Is there a deadline?
  • Is there an event?
  • Does the child need to bring something?
  • Is there an upcoming test?
  • Which actions need to be performed?
  • Which tools are required?

Rather than implementing a rigid rule for every possible teacher message, the LLM provides the semantic understanding and planning layer.

Tool-based execution

The agent can invoke specialized tools for specific actions:

School Message
      ↓
Understand intent & entities
      ↓
Determine required actions
      ↓
 ┌────────────┬─────────────┬───────────────┐
 │            │             │
 ▼            ▼             ▼
Calendar    Materials      Study Quiz
Tool        Search         Generator
 │            │             │
 ▼            ▼             ▼
Event       Shopping       Questions
created     links          generated

This separation allows the reasoning layer to evolve independently from the execution layer.

Event-driven processing

We separated message ingestion from agent execution using FastAPI + SQS + ECS Fargate workers.

This provides a more resilient workflow:

  • Incoming messages are accepted quickly.
  • Processing happens asynchronously.
  • Agent execution is isolated from webhook/request timeouts.
  • Multiple messages can be processed independently.
  • Individual processing failures don't affect message ingestion.

Persistent context

DynamoDB is used to maintain processing state and same-day context.

This gives ParentOps a lightweight memory layer for questions such as:

“Have I already processed this announcement?”

“Did I already create an event for this quiz?”

“Was this material request already extracted from another teacher's message?”

Challenges we ran into

1. The Multi-Tool “Premature Settlement” Dilemma

One of the most interesting challenges was getting the agent to finish the entire job.

For example, a teacher's message could contain:

  • An upcoming quiz
  • Required art materials
  • A dress-code reminder

The agent might correctly identify all three, call search_materials, receive the shopping links, and then prematurely conclude that the task was complete — without calling schedule_calendar_event or generate_study_quiz.

This is a fundamental challenge with autonomous LLM workflows:

Correct reasoning about the task does not guarantee complete execution.

Solution

We used a dual strategy.

First, we refined the system prompts with explicit multi-tool execution requirements.

Second, we introduced deterministic Python safety fallbacks inside process_message_with_strands().

After the model finishes its reasoning, the runtime validates the extracted entities and required actions. If a deadline, material requirement, or quiz topic exists but the corresponding tool was not invoked, the application can invoke the appropriate implementation directly.

This gives us the best of both worlds:

LLM flexibility + deterministic execution guarantees.

2. Google Calendar API Exclusive End-Date Constraints

Google Calendar API v3 uses an exclusive end date for all-day events.

For an all-day event:

end = start + 1 day

Our initial implementation passed the same date for both start and end, resulting in HTTP 400 errors:

Invalid start or end date

Solution

We added explicit date validation and standardized all-day event construction using:

datetime.timedelta(days=1)

This ensured that generated events consistently respected Google's expected event boundaries.

3. LLM Parameter Type Variations

LLMs don't always produce tool arguments in exactly the type we expect.

For example, our tool schema expects:

items = ["chart paper", "glue stick"]

but the model could produce:

items = "chart paper, glue stick"

Treating that string as a list can result in incorrect iteration and malformed search queries.

Solution

We added defensive input normalization at the tool boundary.

The implementation accepts both:

["chart paper", "glue stick"]

and:

"chart paper, glue stick"

and normalizes them into a consistent internal representation before processing.

This reinforced an important lesson:

Tool boundaries need to be defensive, even when the caller is an LLM.

Accomplishments we're proud of

🚀 We moved beyond “AI summarization”

The biggest accomplishment is that ParentOps doesn't stop at:

“Here is a summary of your child's school message.”

It attempts to answer:

“What needs to happen, and can I help make it happen?”

A single unstructured announcement can result in multiple coordinated actions:

One school message
       │
       ├──► Calendar event
       │
       ├──► Shopping links
       │
       ├──► Reminder
       │
       └──► Study quiz

🤖 We built a genuinely agentic workflow

The agent decides which actions are relevant rather than following a fixed sequence for every message.

A message containing only a school event shouldn't trigger a shopping workflow.

A message containing an exam shouldn't necessarily trigger a purchase workflow.

The agent determines the appropriate tools based on the meaning and context of the message.

🛡️ We made autonomy reliable

Rather than assuming the LLM will always behave perfectly, we introduced deterministic safeguards around autonomous execution.

This was an important architectural realization:

Autonomy doesn't mean removing deterministic systems. It means using AI where judgment is needed and deterministic code where correctness matters.

⚡ We optimized for the parent's real-world constraints

For a school project due tomorrow morning, a generic e-commerce search result isn't particularly useful.

A parent needs something actionable right now.

Adding quick-commerce search paths made the experience much closer to the real problem we're solving: reducing the time and mental effort required to complete school-related chores.

What we learned

1. Hybrid architecture beats pure LLM reliance

Pure autonomous agents can be brittle.

Combining LLM reasoning with deterministic code-level safety nets gives us a system that is:

  • Flexible when interpreting messy human language.
  • Autonomous when deciding what actions are required.
  • Deterministic when executing critical operations.
  • Easier to debug when something goes wrong.

The winning pattern was:

Let the LLM decide what should happen. Let software guarantee that it happens correctly.

2. Speed is functionality for parents

A standard two-day e-commerce result isn't particularly helpful when a child needs materials at 8:00 AM the next morning.

Integrating quick-commerce search paths transformed the experience from:

“Here's what your child needs.”

into:

“Here's what your child needs — and here's where you can get it right now.”

3. Context matters more than individual messages

A school communication stream isn't a collection of independent messages.

Multiple teachers may discuss the same child, the same event, or the same assignment.

Without context, an agent can create duplicate actions and reminders.

Maintaining same-day context and deduplication therefore became an important part of making the system feel like a co-pilot rather than a collection of disconnected AI calls.

4. Event-driven architecture makes agentic systems more resilient

Decoupling ingestion from processing using FastAPI + SQS + ECS Fargate ensured that external webhook/request timeouts don't interfere with message processing or model execution.

This architecture also gives us a natural foundation for scaling agent execution independently from message ingestion.

What's next for ParentOps

ParentOps is currently focused on the most immediate school-life workflows, but the long-term vision is much broader.

👨‍👩‍👧 A true family context engine

Build a secure family profile containing information such as:

  • Children and their classes
  • School schedules
  • Subjects
  • Known preferences
  • Upcoming commitments
  • Previous assignments and exam performance

This would allow the agent to make increasingly personalized decisions.

🔄 Proactive follow-through

Move from:

“You need to buy chart paper.”

to:

“Chart paper is needed tomorrow. I found it on a nearby quick-commerce service. Would you like me to place the order?”

And eventually, with appropriate authorization:

The agent completes the task autonomously.

📚 Personalized learning loop

Connect upcoming exams with historical performance.

For example:

Upcoming Science Quiz
        ↓
Identify syllabus
        ↓
Review previous performance
        ↓
Identify weak topics
        ↓
Generate targeted questions
        ↓
Parent conducts 5-minute quiz
        ↓
Capture results
        ↓
Adapt future revision

The goal isn't simply to generate questions.

It is to create a continuous learning loop around the child.

🔔 Intelligent reminders and dependencies

School tasks often have dependencies:

School announces project
        ↓
Buy materials
        ↓
Child completes project
        ↓
Parent checks it
        ↓
Pack project
        ↓
Bring to school

ParentOps can evolve from simple reminders into an agent-managed task graph, ensuring that important steps aren't forgotten.

🌐 Multi-channel school intelligence

Expand beyond WhatsApp and individual messages to understand information across:

  • Email
  • School applications
  • Teacher announcements
  • PDFs
  • Images
  • Calendars
  • Digital notices

The goal is to create a single intelligent layer over the fragmented school communication ecosystem.

The bigger vision

ParentOps isn't trying to give parents more information.

Parents already have too much information.

We're building an AI co-pilot that transforms:

Messages → Understanding → Plans → Actions → Follow-through

So instead of spending the evening parsing school messages, searching for supplies, updating calendars, and preparing revision questions, parents can spend that time doing what actually matters:

being parents.

Built With

Share this project:

Updates

Submission history