AWS Builder Center

Builder Center

AIdeas: Ivy - The World's First Offline-Capable, Proactive AI Tutoring Agent

AIdeas: Ivy - The World's First Offline-Capable, Proactive AI Tutoring Agent

Ivy is AI tutoring agent with on-device inference and Interactive Immersive Agentic Learning. When online, it runs Claude through AWS Bedrock with 21 agentic tools. When offline, it runs a quantized open-source language model under 600 MB entirely on the student's phone. No internet. No server. Just a $120 Android phone and the Socratic method.

Natnael Getenew Zeleke

Founder of Ivy & HomeStand AI | Amazon Nova Hackathon Winner
App Category : Social Impact
A 14-year-old girl in rural Tigray opens her textbook under a single lightbulb. She's preparing for the national Grade 10 exam the test that determines whether she advances or her education ends. Her school has one teacher for every 70 students. Private tutoring costs more than her family earns in a month. She has a phone, an old Android , but the internet cuts out every few hours.
She's not an edge case. She's the average Ethiopian student.
There are 35 million students in Ethiopia. Millions face exactly this: overcrowded classrooms, zero access to tutoring, unreliable connectivity, and high-stakes national exams. I built Ivy OS because I believe an AI tutor shouldn't sit passively in an app waiting for a student to show up. It should chase them down. It should call them on the phone. It should work even when the internet doesn't.
Ivy OS is, to the best of my knowledge, the world's first proactive autonomous AI tutoring system with on-device inference and Interactive Immersive Agentic Learning. When online, it runs Claude Sonnet 4 through AWS Bedrock with 21 agentic tools. When offline, it runs a quantized open-source language model , under 600 MB , entirely on the student's phone. No internet. No server. Just a $120 Android phone and the Socratic method.
It doesn't just respond. It initiates. It monitors. It intervenes. And learning never stops , connected or not.

My Vision

I'm a solo developer from Addis Ababa, Ethiopia. I grew up watching the gap between students who could afford extra support and those who couldn't. The difference was never intelligence it was always access.
The name "Ivy" comes from the plant. Ivy grows everywhere on walls, up buildings, across fences. It doesn't need perfect conditions. It just needs a crack to grow through. That's what education should be.
My vision: every Ethiopian student gets a patient, bilingual, always-available AI tutor that speaks their language, understands their curriculum, works with or without internet, and critically refuses to give up on them when they stop showing up.
Most AI education tools are reactive. You open the app, you ask a question, you get an answer. Then you navigate to a separate screen to take a quiz. Another screen for flashcards. Another for your study plan. The conversation is disconnected from the learning. The student is constantly switching contexts, losing momentum.
Ivy inverts the entire paradigm with two foundational innovations:
1. Interactive Immersive Agentic Learning The AI agent doesn't just return text. It returns interactive educational components quizzes, flashcard decks, step-by-step explanations, study plan timelines, progress dashboards that render as rich, tappable widgets directly inside the conversation. The student never leaves the chat to learn. The chat IS the classroom. The AI decides in real-time which component to generate based on the student's needs, creating a continuous adaptive learning loop with zero navigation friction.
2. Proactive Autonomous Intervention Ivy tracks your study schedule. She detects when you miss a session. She escalates urgency as exams approach. And if you've been gone too long, she initiates an outbound voice call with a personalized script generated in real time by Amazon Bedrock.
Not a push notification. A real phone call. With a real AI voice.
No other AI education platform on Earth does either of these. Ivy does both.

Why This Matters

Ethiopia's student-to-teacher ratio in rural areas reaches 1:70. The national average isn't much better. Private tutoring , the lifeline that middle-class families rely on, costs 2,000–5,000 birr/month. For a family earning 3,000 birr total, it's impossible.
But mobile penetration is exploding. A student who can't afford a tutor can often access a smartphone shared with family, borrowed, or their own.
The missing piece was never hardware. It was software engineered for three specific constraints:
  1. Intermittent connectivity three layers of offline capability: pre-cached study packs, on-device AI inference with a quantized edge model, and a roadmap for school-level edge nodes via AWS IoT Greengrass
  2. Amharic as the primary language not a translation layer, but native bilingual architecture with 250+ localized strings across every screen, notification, quiz prompt, and system message
  3. Voice-first interaction students who are more comfortable speaking than typing get a real-time conversational AI voice interface. This is a multi-agent autonomous tutoring system with 21 specialized AI tools, a proactive intervention engine, an interactive immersive UI rendering engine, on-device AI inference, spaced repetition memory science, gamified retention mechanics, and a voice pipeline that operates at sub-second latency.
How I Built This - Complete Technical Architecture
The Development Environment:
Agentic IDE and CLI: Kiro To accelerate the development of Ivy’s 21-tool agentic framework, I used the Kiro agentic IDE and CLI. Kiro was instrumental in architecting the complex logic between the Claude-powered reasoning engine and the local quantized inference on-device. By leveraging Kiro’s agentic capabilities, I was able to rapidly prototype the proactive voice-calling trigger and ensure the offline-to-online state synchronization remained seamless.
Ivy OS is built on a deep AWS-native architecture spanning 7 AWS services that handle all reasoning, data persistence, deployment, and orchestration.
The system comprises 6 major subsystems, each with its own data flow and orchestration logic.

System Architecture Overview

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
┌─────────────────────────────────────────────────────────────────────────────┐
│ IVY OS — SYSTEM ARCHITECTURE │
│ Proactive Autonomous AI Tutoring System │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────────────────────────────────────────┐ │
│ │ MOBILE APP │ │ AWS CLOUD INFRASTRUCTURE │ │
│ │ React Native │ │ │ │
│ │ + Expo │────▶│ ┌────────────────┐ ┌─────────────────────┐ │ │
│ │ │ │ │ AWS APP RUNNER │ │ AMAZON BEDROCK │ │ │
│ │ • 5-Tab UI │ │ │ (Auto-scaling) │───▶│ Claude Sonnet │ │ │
│ │ • AI SDK v4 │ │ │ Node.js + AI │ │ Cross-Region │ │ │
│ │ • Gemini Live │ │ │ SDK v4 Backend │ │ Inference (us.) │ │ │
│ │ • Offline SRS │ │ │ 19 AI Tools │ │ ReAct Multi-Step │ │ │
│ │ • Bilingual │ │ │ REST Streaming │ │ maxSteps: 6 │ │ │
│ │ (EN + AM) │ │ └───────┬────────┘ └─────────────────────┘ │ │
│ └──────────────┘ │ │ │ │
│ │ ▼ │ │
│ ┌──────────────┐ │ ┌────────────────┐ ┌─────────────────────┐ │ │
│ │ GEMINI LIVE │ │ │ AMAZON │ │ AMAZON S3 │ │ │
│ │ WebSocket │ │ │ DYNAMODB │ │ Audio Storage │ │ │
│ │ Native Audio │ │ │ 6 Tables: │ │ Course Materials │ │ │
│ │ Sub-second │ │ │ • ivy-progress │ │ Generated Assets │ │ │
│ │ Voice │ │ │ • ivy-memory │ └─────────────────────┘ │ │
│ │ Aoede Voice │ │ │ • ivy-courses │ │ │
│ └──────────────┘ │ │ • ivy-schedule │ ┌─────────────────────┐ │ │
│ │ │ • ivy-nudges │ │ AMAZON ECR │ │ │
│ ┌──────────────┐ │ │ • ivy-gamific. │ │ Container Registry │ │ │
│ │ PROACTIVE │ │ └────────────────┘ │ Versioned Images │ │ │
│ │ ENGINE │ │ │ (v27 current) │ │ │
│ │ 5-min Cron │ │ ┌────────────────┐ └─────────────────────┘ │ │
│ │ • Missed │ │ │ AWS IAM │ │ │
│ │ Sessions │ │ │ Instance Roles │ ┌─────────────────────┐ │ │
│ │ • Overdue │ │ │ Service Roles │ │ AMAZON CLOUDWATCH │ │ │
│ │ SRS Cards │ │ │ Access Policies│ │ Logs & Metrics │ │ │
│ │ • Exam │ │ └────────────────┘ │ Error Tracking │ │ │
│ │ Proximity │ │ │ Latency Monitoring │ │ │
│ │ • Outbound │ │ └─────────────────────┘ │ │
│ │ Voice Calls│ │ │ │
│ └──────────────┘ └──────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────┐ │
│ │ AI TOOL ORCHESTRATION LAYER │ │
│ │ 19 Specialized Tools with ReAct Multi-Step Reasoning (maxSteps: 6) │ │
│ ├──────────────┬──────────────┬──────────────┬─────────────────────────┤ │
│ │ KNOWLEDGE │ ASSESSMENT │ PLANNING │ ENGAGEMENT │ │
│ │ • search_kb │ • gen_quiz │ • study_plan │ • track_progress │ │
│ │ • explain │ • flashcards │ • schedule │ • set_goal │ │
│ │ • solve_step │ • get_due │ • exam_tips │ • get_profile │ │
│ │ • translate │ • srs_stats │ • resources │ • gamification │ │
│ │ • mnemonic │ • gen_image │ │ • execute_code │ │
│ └──────────────┴──────────────┴──────────────┴─────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘

Subsystem 1: The Cognitive Core - Amazon Bedrock with Claude Sonnet

At the heart of Ivy is an autonomous AI agent powered by Amazon Bedrock running Claude Sonnet 4 with cross-region inference (us.anthropic.claude-sonnet-4-20250514-v1:0). This is not a simple prompt-and-response system. The agent operates in ReAct (Reasoning + Acting) mode with maxSteps: 6, enabling multi-turn tool orchestration where the model autonomously decides which tools to invoke, in what sequence, and how to synthesize results.
19 custom AI tools are registered via the Vercel AI SDK v4 tool() API with Zod-validated schemas:
CategoryToolsFunction
Knowledge Retrievalsearch_knowledge_base, explain_concept, solve_problem_step_by_step, translate_content, create_mnemonicSemantic search over uploaded course content, multi-step problem solving with the Socratic method, EN↔AM translation
Assessment & Generationgenerate_quiz, generate_flashcards, get_due_flashcards, get_student_srs_stats, generate_image, execute_codeQuiz generation with difficulty scaling, SM-2 spaced repetition card management, E2B sandboxed Python execution
Planning & Schedulingcreate_study_plan, get_student_schedule, get_exam_tips, suggest_resourcesGenerates study plans and persists sessions to DynamoDB, exam strategy based on proximity and readiness
Student Contexttrack_progress, get_student_profile, set_learning_goalContinuous learning event logging, goal tracking, profile-aware personalization
The agent uses the Socratic method as its core pedagogical strategy - never giving answers directly, always guiding through questions. Every interaction receives the full student profile (name, grade, subjects, exam) via request body injection, ensuring the agent never asks "what grade are you in?" it already knows.
Tool chaining example: A student asks "Help me prepare for my biology exam next week." The agent autonomously:
  1. Calls get_student_profile → retrieves grade, subjects, exam date
  2. Calls search_knowledge_base → finds relevant biology content from uploaded courses
  3. Calls get_student_srs_stats → checks flashcard mastery levels
  4. Calls generate_quiz → creates a diagnostic quiz on weak areas
  5. Calls create_study_plan → generates a 7-day plan and persists sessions to DynamoDB
  6. Returns a unified response with interactive UI components rendered inline

Subsystem 2: The Memory Layer - Amazon DynamoDB

Ivy maintains 6 purpose-built DynamoDB tables forming a complete student knowledge graph:
TablePurposeAccess Pattern
ivy-progressLearning events, topic mastery scores, time-series analyticsStudent ID + timestamp range queries
ivy-memoryPersistent conversational context, student preferencesStudent ID lookup, conversation threading
ivy-coursesStructured curriculum data from ingested PDFs, photos, YouTubeStudent ID + course ID, topic-level queries
ivy-scheduleStudy sessions with subject, date, time, completion statusStudent ID + session ID, date range scans
ivy-nudgesProactive notification queue with urgency levels, call scriptsStudent ID + status index, TTL-based expiry
ivy-gamificationXP events, streak tracking, level progression, achievementsStudent ID, daily aggregation queries
DynamoDB's single-digit-millisecond latency is critical - the agent pulls full student context mid-conversation without perceptible delay. The proactive engine scans these tables every 5 minutes to detect intervention triggers.

Subsystem 3: The Proactive Intervention Engine

This is the core innovation that makes Ivy fundamentally different from every other AI education tool.
A background cron process executes every 300 seconds (5 minutes), scanning all active students across three intervention dimensions:
Dimension 1: Missed Session Detection
  • Queries ivy-schedule for sessions with start_time within a 2-hour past window and status !== 'completed'
  • Generates a nudge with urgency proportional to exam proximity
  • If the student has missed 3+ consecutive sessions, escalates to outbound call
Dimension 2: Overdue SRS Card Detection
  • Queries ivy-courses for flashcards where next_review_date < now()
  • Calculates "decay score" - how many days overdue × card difficulty factor
  • High decay scores trigger immediate review nudges
Dimension 3: Exam Proximity Escalation
  • Computes days remaining until registered exams
  • Milestone-based urgency: 14 days (gentle), 7 days (firm), 3 days (urgent), 1 day (critical)
  • At each milestone, generates a personalized study recommendation based on current mastery gaps
Outbound Voice Calls:
When push notifications are insufficient (student has been unresponsive for 48+ hours with an exam approaching), the engine triggers an outbound voice call:
  1. Amazon Bedrock generates a personalized call script based on the student's specific situation
  2. TTS synthesizes the script into natural speech
  3. The mobile app receives the call trigger, activates the full-screen incoming call UI with ringtone vibration
  4. On accept, the student enters a real-time voice session with Ivy
This is not a pre-recorded message. It is a dynamically generated, contextually aware voice conversation initiated by the AI.

Subsystem 4: The Voice Pipeline - Bedrock-Driven,

The voice system uses a hybrid architecture where Amazon Bedrock drives all reasoning and script generation,
Real-time Voice (Sub-second Latency):
1
2
3
4
5
Student speaks → M4A recording (expo-audio)
→ POST /transcribe ( transcription on server)
→ Text sent to Live WebSocket
→ PCM audio chunks streamed back
→ WAV assembly → expo-av Audio.Sound.createAsync() → Speaker
Outbound Calls (Bedrock + TTS):
1
2
3
4
5
6
Proactive Engine detects trigger
→ Amazon Bedrock generates personalized script
→ synthesizes to natural speech (Aoede voice)
→ Audio stored in Amazon S3
→ Push notification triggers full-screen call UI
→ Student accepts → Real-time voice session begins
The voice interface features the Aoede voice model - warm, natural, and specifically chosen for educational conversations. The system supports both English and Amharic voice interaction.

Subsystem 5: Interactive Immersive Agentic Learning (IIAL) Engine

This is the second core innovation and the one that fundamentally changes how AI tutoring feels.
Every AI education app today Khanmigo, Duolingo Max, Quizlet Q-Chat uses the same broken UX pattern: you chat in one screen, navigate to a separate quiz screen, then a separate flashcard screen, then a separate study plan view. The conversation is disconnected from the learning activities. Every screen switch is a context switch. Every context switch is lost momentum. For a 14-year-old studying alone, that friction is the difference between staying engaged and closing the app.
Ivy eliminates this entirely. The AI agent renders interactive educational components directly inside the conversation as rich, animated, tappable widgets that the student can engage with without ever leaving the chat.
How it works the rendering pipeline:
1
2
3
4
5
6
7
8
9
Student asks question
→ Amazon Bedrock (Claude Sonnet 4) reasons about the best response
→ Agent decides which interactive component(s) to generate
→ Agent returns structured JSON in ```ivy-ui``` code blocks
→ Client-side parser extracts component specs
→ React Native renderer inflates animated interactive widgets
→ Student interacts (taps answer, flips card, follows study plan)
→ Interaction events emit back to the conversation
→ Agent sees the result and adapts its next response
6 interactive component types, each with full animation and interactivity:
ComponentWhat It DoesInteraction
Quiz CardMultiple-choice question with options, difficulty badge, subject tagStudent taps answer → immediate feedback with explanation → agent sees result
Study Plan TimelineMulti-day study plan with sessions, subjects, durations, exam date countdownStudent can tap sessions to start, view schedule at a glance
Explanation CardStep-by-step concept breakdown with numbered steps, icons, hintsExpandable steps, follow-up question buttons that feed back into chat
Flashcard PreviewDeck of cards with front/back, subject tag, topic name3D flip animation on tap, swipe through deck
Progress CardSubject mastery percentage, topics completed, streak infoVisual progress ring, motivational framing
Motivation CardPersonalized encouragement with emoji, action buttonTap action feeds a new prompt back to the agent
The critical innovation: These components are not pre-built screens. They are dynamically generated by the AI agent in real-time based on the conversation context. The agent decides what to show, when to show it, and what data to populate it with. A single conversation might flow like this:
  1. Student: "I'm struggling with photosynthesis"
  2. Ivy responds with text (Socratic question) + Explanation Card (step-by-step light reactions)
  3. Student reads the explanation, taps "Test my understanding"
  4. Ivy generates a Quiz Card inline 4 options about chlorophyll's role
  5. Student taps wrong answer → Ivy sees the mistake → generates a simpler explanation
  6. Student gets it right on retry → Ivy generates Flashcard Preview with 5 cards to reinforce
  7. Ivy generates a Motivation Card: "You're getting it! Want to try the Calvin cycle next?"
All of this happens inside one scrollable chat thread. Zero navigation. Zero context switching. The learning loop is continuous, adaptive, and feels like a conversation because it IS a conversation.
Technical implementation:
  • Parser (jsonrender/parser.ts): Regex extraction of \``ivy-ui` JSON blocks from AI response text
  • Component Catalog (jsonrender/catalog.ts): 6 component type definitions with prop schemas
  • Registry (jsonrender/registry.tsx): Animated React Native implementations with Animated.spring, Animated.timing, haptic feedback
  • Emit system: Components emit actions (e.g., follow_up with a question) that feed back into the chat as new user messages, creating a closed-loop interaction cycle
  • Zod-validated: All component specs validated on the server side before streaming
Why this matters pedagogically: Educational research consistently shows that active recall (testing yourself) and interleaving (mixing question types) dramatically outperform passive reading. By embedding interactive assessment directly into the conversation flow, Ivy creates an active learning environment that adapts in real-time to the student's understanding without requiring the student to do anything except keep chatting.
I call this paradigm "Interactive Immersive Agentic Learning" and to my knowledge, no other AI education platform implements it at this depth.

Subsystem 6: The Engagement & Retention Engine

Gamification System:
  • XP Economy: 9 event types with calibrated rewards (chat: 5 XP, quiz_perfect: 35 XP, course_upload: 25 XP, streak_bonus: 15 XP)
  • Level Progression: level = floor(sqrt(totalXP / 50)) exponential curve requiring increasing effort
  • Ethiopian-Themed Level Titles: ጀማሪ ተማሪ (Beginner Student) → የኢትዮጵያ አይንስታይን (Ethiopia's Einstein)
  • 9 Achievement Badges: First Steps, Quiz Master, Streak Champion, etc.
  • Level-up celebrations: Full-screen confetti animation with haptic feedback
Spaced Repetition (SM-2 Algorithm):
  • Industry-standard SM-2 algorithm with per-card difficulty factors (2.5 default, adjusts based on grade)
  • Interval calculation: interval = previous_interval × easiness_factor
  • Grade-based adjustment: Grade 0-2 resets interval, Grade 3+ extends with increasing multiplier
  • Offline caching: AsyncStorage persists due cards locally for zero-connectivity review

Infrastructure & Deployment

ServiceRoleConfiguration
Amazon BedrockAI reasoning engineClaude, cross-region inference (us-west-2), 21 tools, maxSteps: 10
Amazon DynamoDBStudent data persistence6 tables, on-demand capacity, single-digit ms latency
Amazon S3Binary storageAudio files, course materials, generated images
AWS App RunnerCompute & auto-scalingNode.js container, auto-scales 1–25 instances, 1 vCPU / 2GB
Amazon ECRContainer registryVersioned Docker images (currently v30), automated builds
AWS IAMSecurity & access controlInstance roles (IvyAppRunnerInstanceRole), service roles, least-privilege policies
Amazon CloudWatchObservabilityApplication logs, error tracking, latency metrics, proactive engine health
Deployment Pipeline:
1
2
3
Code change → Docker build → ECR push (tagged vN) → App Runner update
→ Health check (/health) → Zero-downtime deployment
→ CloudWatch log stream begins

The Client: React Native + Expo

The mobile application is a full-featured educational platform, not a thin chat wrapper:
  • 5-tab interface: Home (dashboard + daily goals), Chat (AI-powered with interactive components), Quiz (Duolingo-style with lives/streaks), Review (SRS flashcards with 3D flip), Profile (achievements + settings)
  • AI SDK v4 integration with expo/fetch for real-time token streaming Live WebSocket direct connection for sub-second voice
  • Full Amharic localization: 250+ strings, RTL-aware layouts, Ge'ez script rendering
  • Offline capability: SRS cards cached in AsyncStorage, chat history persisted
  • Rich animations: IvyCharacter mascot with blinking/floating/talking states, ThinkingDots, LevelUpModal with confetti physics, VoiceButton ambient glow, spring-animated tab bar

The Two Innovations That Set Ivy Apart

I want to be specific about this claim. I have surveyed every major AI education platform Khan Academy's Khanmigo, Duolingo Max, Quizlet Q-Chat, Photomath, Socratic by Google, Century Tech, Squirrel AI.
None of them initiate outbound communication when a student goes silent. They all wait. Ivy doesn't.
None of them render interactive learning components inside the conversation. They all separate chat from activities. Ivy fuses them.

Innovation 1: Interactive Immersive Agentic Learning

Every competitor treats chat as chat and activities as separate screens. Ivy treats the conversation as a living classroom where the AI agent dynamically generates interactive quizzes, flashcards, explanations, and study plans as tappable widgets inline. The student never leaves the conversation to learn. The closed-loop emit system means student interactions feed directly back into the agent's reasoning, creating a continuous adaptive teaching loop.
This is not a UI feature. It is a pedagogical architecture one that eliminates the context-switching friction that causes students to disengage.

Innovation 2: Proactive Autonomous Intervention

The proactive engine is not a simple reminder system. It is an autonomous intervention system that:
  • Runs continuous background analysis across multiple data dimensions
  • Generates contextually aware, personalized intervention scripts using Amazon Bedrock
  • Escalates through multiple channels (in-app nudge → push notification → voice call)
  • Adapts urgency based on exam proximity, mastery gaps, and engagement history
  • Initiates real voice conversations, not pre-recorded messages
Together, these two innovations mean: Ivy comes to the student, and when the student is there, learning is seamless and immersive. This is what a tutor who cares looks like, encoded in software.

Innovation 3: Offline-First Learning + On-Device AI Inference

In rural Ethiopia, internet is intermittent. Students lose connectivity for hours -sometimes days. 60% of Ethiopia's population lacks reliable internet access. Most AI education platforms become completely useless the moment the connection drops.
Ivy doesn't. And here's where it gets extraordinary.

Layer 1: Intelligent Pre-Caching (Built and Deployed)

While connected, Ivy's proactive engine generates personalized offline study packs quizzes, flashcards, step-by-step explanations, and study tips tailored to each student's weak areas, upcoming exams, and spaced repetition schedule. These packs are cached locally on the device using AsyncStorage. When the connection drops, learning doesn't stop.
The same Interactive Immersive Agentic Learning components that render online work identically offline. The student sees the same tappable quiz cards, flippable flashcards, and guided explanations. XP is tracked locally and synced when connectivity returns.
Spaced Repetition works offline by design. The SM-2 algorithm runs entirely client-side. Cards are cached with their scheduling metadata. A student in a village with no internet can still maintain their daily review streak.

Layer 2: On-Device AI Inference (Edge Module)

This is the part that changes everything.
Recent advances in model quantization have made it possible to run capable language models entirely on mobile hardware. A 1B-parameter instruction-tuned model, quantized to INT4, compresses to under 600 MB small enough to fit on a budget Android phone with 3 GB of RAM. The inference runs on the device's GPU via an optimized on-device ML runtime. No internet. No server. No API calls.
I engineered Ivy's edge inference module (mobile-edge/) to exploit this a native Android application built in Kotlin that handles the complete on-device AI pipeline:
1
2
3
4
5
6
7
8
9
10
11
12
Student's Phone ($120 Samsung A14)
├── Ivy OS (React Native) ← Full experience when online
│ ├── Claude Sonnet 4 via AWS Bedrock (21 agentic tools)
│ ├── Interactive quizzes, flashcards, study plans
│ └── Pre-cached offline study packs (AsyncStorage)
│
└── Ivy Edge (Native Kotlin) ← AI inference when offline
├── Quantized 1B-parameter model (INT4, <600 MB)
├── On-device ML runtime with GPU acceleration
├── Socratic tutor system prompt (EN + Amharic)
├── Streaming token-by-token response generation
└── Zero internet required
The architecture I designed handles the full lifecycle: model loading with automatic file discovery across device storage, engine initialization with configurable GPU/CPU backends, conversation management with Ivy's Socratic tutor system prompt baked in (both English and Amharic variants), streaming inference with real-time token callbacks for fluid UI updates, and performance instrumentation (tokens/sec, time-to-first-token, memory usage).
The same patient, Socratic personality. The same Amharic language support. The same educational philosophy. Just running locally on a phone that costs $120.
When online, students get the full power of Claude Sonnet 4 via AWS Bedrock with 21 agentic tools, interactive UI, handwriting grading, web search, and proactive interventions. When offline, the edge module runs the Socratic method locally. The student's learning never stops.

Layer 3: School-Level Edge Nodes (Roadmap - AWS IoT Greengrass)

The offline sync protocol I built today is the foundation for something larger. Phase 3 of Ivy's architecture envisions edge inference nodes deployed in Ethiopian schools. A single low-cost GPU server (an NVIDIA Jetson Orin Nano, ~$250) running a fine-tuned open model, orchestrated by AWS IoT Greengrass, could serve an entire school's Ivy instances without internet connectivity. The same DynamoDB sync protocol that handles offline flashcard caching today will handle edge-to-cloud synchronization tomorrow.
Ethiopian schools already have computer labs. They lack connectivity, not hardware. An edge node running a fine-tuned model could provide personalized Socratic tutoring to 200+ students simultaneously, syncing progress to AWS when a connection becomes available.
Three layers of offline capability from cached content to on-device inference to school-level edge nodes managed by AWS IoT Greengrass. This is the path from "AI tutor app" to national cognitive infrastructure.

Demo

Chat interface with interactive quiz card rendered inline
Interactive Immersive Agentic Learning
explanation → inline quiz card → flashcard preview → motivation card, all rendered as interactive widgets without leaving the conversation
Incoming call screen - Ivy calling, accept/decline,
Proactive engine data flow - DynamoDB scan → intervention trigger → Bedrock script generation → voice call
On-device inference architecture - edge module loading quantized model,
Ivy tracks your study schedule. She detects when you miss a session. she manages your schedule
Offline study mode - pre-cached quizzes and flashcards
Built for Scale, Priced for Impact (For under $200 total AWS Cost)
Ivy was architected with a 'Zero-Waste' cost strategy to ensure accessibility. The entire global infrastructure runs for under $200 on AWS.

What I Learned

App Runner doesn't support WebSocket. My original architecture assumed persistent WebSocket connections. I discovered the limitation after deployment and had to pivot to REST-based streaming using AI SDK's toDataStreamResponse(). The result actually works better students see real-time token streaming over long-lived HTTP responses with automatic reconnection.
Bedrock credential detection on App Runner is not automatic. The @ai-sdk/amazon-bedrock provider doesn't auto-detect instance role credentials the way boto3 does. I spent hours debugging silent auth failures before discovering I needed explicit environment variables. Small detail, enormous headache.
I rewrote the entire backend from Python to Node.js mid-competition. The original backend was Python (FastAPI). It worked but real-time streaming was clunky, and the Vercel AI SDK ecosystem for Node.js was significantly more mature for multi-tool orchestration. The rewrite was the right decision the Node.js backend handles streaming, tool calls, and ReAct reasoning loops with a fluidity that Python couldn't match.
Claude Sonnet 4 handles Amharic better than expected. Amharic uses the Ge'ez script (ፊደል), underrepresented in most LLMs. Testing revealed that Claude via Bedrock handles Amharic conversation, question answering, and Socratic dialogue with quality high enough for real educational use. It's not perfect, but it's good enough that students can learn in their mother tongue. That matters more than any benchmark score.
The SM-2 algorithm was non-negotiable. There are a hundred ways to show flashcards. Most are educationally worthless. SM-2 is backed by decades of cognitive science on optimal review intervals. Implementing it properly with per-card difficulty factors, interval calculations, grade-based adjustments was more complex than expected, but it's what separates Ivy from a toy.
Live rejects M4A audio. The BidiGenerateContent WebSocket only accepts raw PCM (16kHz, 16-bit, mono). Android records M4A by default. The solution: a hybrid pipeline where M4A is transcribed server-side , then the text is sent to native audio response. This adds ~200ms but avoids PCM format conversion on-device.

Where This Goes

Ivy OS is live. But this is the foundation.
Immediate roadmap:
  • Integrate the Ivy Edge native module into the main React Native app via native bridge, enabling seamless online/offline mode switching
  • Expand curriculum coverage to all Grade 10 national exam subjects
  • Add Oromiffa and Tigrinya language support
  • Partner with Ethiopian schools for pilot programs with school-level edge inference nodes
  • Build a teacher dashboard for aggregate learning analytics
Long-term vision:
The architecture - proactive AI tutoring, voice-first interaction, on-device inference, deep localization -dem is country-agnostic. It applies anywhere education access is limited. Sub-Saharan Africa. South Asia. Rural communities worldwide. The system is designed to be deployable per-country with only localization and curriculum changes.
The on-device inference module means Ivy's marginal cost per student approaches zero. No server costs. No API calls. A one-time 554 MB model download, and the student has an AI tutor for life. That's the economics that make national-scale deployment possible.
But it starts here. With the 14-year-old in Tigray with one lightbulb and a phone. With giving her a tutor who never gets tired, never judges, works without internet, and never stops showing up.
Ivy grows everywhere. That's the point.
Built by a solo developer from Addis Ababa, Ethiopia, for the AWS 10,000 AIdeas Challenge.
Powered by Amazon Bedrock , Amazon DynamoDB, Amazon S3, AWS App Runner, Amazon ECR, AWS IAM, and Amazon CloudWatch.
#aideas-2025 #social-impact #EMEA
# aideas-2025# social-good# ai-agents# EMEA# social-impact
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article