NovaEducation

• 

  Logo

Inspiration

Every child deserves a patient, personal tutor. But private tutoring is expensive, internet access is not always available, and many AI learning tools require children’s conversations and personal data to be sent to the cloud.

NovaEducation was born from a simple conviction:

A child should be able to learn with an intelligent tutor without a single byte of personal data ever leaving the device.

NovaEducation brings private, on-device AI education to Spanish-speaking children using Apple’s Foundation Models framework without external servers, cloud inference, telemetry, or a permanent internet connection.

Privacy is not only a promise in NovaEducation. It is enforced by the architecture.

What it does

NovaEducation transforms a compatible iPhone into a personal AI tutor that works completely offline once Apple Intelligence is enabled and ready on the device.

It helps students:

• Learn across 12 academic subjects, including mathematics, physics, chemistry, natural sciences, language, English, history, geography, and more.
• Receive patient, step-by-step explanations adapted to their education level.
• Solve mathematics, physics, chemistry, and grammar problems through deterministic solvers before the AI generates the explanation.
• Visualize difficult concepts through on-device educational image generation and interactive 3D models.
• Practice with personalized quizzes and learning activities.
• Stay motivated through XP, achievements, daily quests, progress tracking, and focus mode.
• Continue learning without Wi-Fi or cellular connectivity.

For STEM problems, NovaEducation does not ask the language model to guess the answer.

The exact solver calculates the result first.

The AI then focuses on what it does best: explaining the reasoning in a clear, age-appropriate, and educational way.

This combination produces answers that are both accurate and easy to understand.

Most importantly:

No cloud inference. No external servers. No telemetry. No student conversations leaving the device.

Language: Spanish-first by design

NovaEducation v1 ships Spanish-only by design. The UI, all 12 subject tutors, voice (recognizer and text-to-speech), and the deterministic solvers are Spanish-first, not partially translated. This is a deliberate product decision: the app is built for Spanish-speaking children, especially those without reliable internet access.

Full English/Spanish bilingual support (system language by default plus an in-app runtime toggle, applied across UI, prompts, voice, and interceptors) is fully specced and planned, but intentionally deferred. It enters validation only after the Spanish v1 is stabilized, so a second language never destabilizes the safety- and correctness-critical Spanish path.

How we built it

NovaEducation is built with Swift, SwiftUI, SwiftData, and Apple’s Foundation Models framework.

The application follows an MVVM architecture with a dedicated Service Layer and local-only persistence.

AI inference runs entirely on-device through Apple Intelligence and the Apple Neural Engine. The application does not depend on a remote AI service, external inference API, or cloud-hosted student profile.

The system was designed around three core principles:

1. Privacy by architecture
2. Safety by default
3. Correctness before explanation

Every student interaction passes through a layered safety pipeline before a response is shown.

The pipeline includes:

• Input sanitization and anti-obfuscation Unicode normalization
• Personally identifiable information detection
• Harmful-content validation
• Jailbreak and prompt-injection detection
• Structured prompt isolation
• Education-level adaptation
• Deterministic routing to exact academic solvers
• Safety-bounded agentic tool execution
• Output validation before presentation

Agentic capabilities such as educational image generation, quiz creation, and knowledge storage are exposed only through explicitly defined tools with constrained inputs and validated outputs.

Educational images are painted entirely on-device using Apple’s ImagePlayground framework (ImageCreator with the .illustration style) — there is no cloud image API. Image generation is invoked two ways: autonomously by the model through Tool Calling, and deterministically by the RenderPipeline’s image mode when a visual request has no 3D primitive but the subject supports images. Every generated image carries a persisted pedagogical accessibility description and is redrawn, encoded, and saved off the main thread (2048×2048 cap, disk-space guard, complete file protection), always with a guaranteed 3D-primitive fallback if image painting fails.

Speech recognition is also restricted to recognizers that explicitly support on-device processing. If the operating system cannot guarantee local recognition, NovaEducation rejects the operation rather than allowing a network fallback.

This means the privacy guarantee is enforced technically, not merely described in a privacy policy.

How we used Codex and GPT-5.6

Codex, powered by GPT-5.6, was central to transforming NovaEducation from a functional prototype into a release-candidate product.

We used Codex as an engineering partner, not simply as a code generator.

We provided high-level product and quality goals, and Codex helped coordinate multi-agent review sessions focused on accessibility, offline reliability, privacy, safety, and automated testing. These reviews ran in parallel while preserving the architectural decisions and product direction defined by our team.

Hardening privacy and offline guarantees

Codex helped strengthen several behaviors that directly affect user trust.

It:

• Ensured message-based achievements count only successful student interactions.
• Prevented study streaks from increasing simply because the application was opened.
• Hardened speech recognition so the application checks whether the recognizer truly supports on-device processing.
• Added stronger validation for personal addresses and personally identifiable information.
• Blocked unsafe or overly sensitive information from being stored in the student’s local memory.
• Reviewed critical flows for accidental network-dependent behavior.

These were important because an application cannot claim to be private or offline while silently permitting edge-case fallbacks.

Finding real product defects

Codex also helped us identify bugs that were not merely cosmetic.

During automated UI and accessibility audits, it surfaced issues such as:

• Transient SQLite BUSY and LOCKED errors being incorrectly classified as permanent data corruption.
• Temporary database failures causing the local store to be unnecessarily quarantined.
• A decorative onboarding indicator being announced by VoiceOver as if it were interactive.
• Generated educational images using generic accessibility labels instead of persistent pedagogical descriptions.
• Real contrast failures.
• Text truncation and layout breakage at extreme Dynamic Type sizes.
• Statistics cards becoming unreadable when accessibility text sizes were enabled.
• A weekly progress chart requiring a more accessible scrollable layout.

Each issue was corrected without disabling or bypassing the underlying accessibility checks.

Building verifiable release gates

Codex helped establish automated quality gates instead of relying only on manual review.

It helped us:

• Create a real UI-test target.
• Run performAccessibilityAudit() across the main application screens.
• Extend UI-test coverage across all five primary tabs.
• Validate navigation, content visibility, accessibility labels, and layout behavior.
• Adapt interfaces for extreme Dynamic Type settings.
• Preserve accessibility requirements rather than suppressing audit failures.

The automated test suite has since grown to:

413 automated tests — 409 unit tests across 38 suites plus 4 UI accessibility-audit tests, all passing.

The project also completed a clean build targeting iPhone 17 running iOS 26.5.

Codex accelerated the development process dramatically, but the core product decisions privacy architecture, deterministic computation, safety boundaries, educational behavior, and user experience remained deliberately designed and reviewed by us.

Challenges we ran into

Building a general AI chatbot is difficult.

Building one intended for unsupervised use by children introduces a much higher standard.

The hardest problems were not simply generating answers. They involved guaranteeing predictable, private, and safe behavior under imperfect real-world conditions.

Some of the main challenges included:

• Handling unpredictable child input that could unintentionally resemble prompt injection.
• Preventing jailbreak attempts from altering the tutor’s educational boundaries.
• Eliminating hallucinated calculations in factual STEM problems.
• Constraining autonomous tool calling to a small, validated set of educational actions.
• Ensuring speech recognition never silently falls back to cloud processing.
• Disciplining a small (~3B) on-device model against greedy-decoding repetition loops.
• Managing the limited 4,096-token context window of the on-device model.
• Preserving useful learning memory without storing unsafe or unnecessary personal information.
• Maintaining full functionality during cold starts and airplane-mode use.
• Designing layouts that remain usable with VoiceOver and extreme Dynamic Type settings.
• Distinguishing temporary persistence failures from actual database corruption.

These challenges required deliberate engineering rather than relying on prompt instructions alone.

What we learned

The most important lesson was that privacy and safety are strongest when they are enforced by system design.

A privacy policy can describe an intention.

An architecture can make a privacy violation technically impossible.

We also learned that language models and deterministic computation are stronger together than either is alone.

The deterministic solver provides mathematical and scientific correctness.

The language model provides context, patience, adaptation, and understanding.

This separation allows NovaEducation to avoid using the model as a calculator while still benefiting from its ability to teach.

Another major lesson was that accessibility testing should be treated as a release gate, not a final checklist.

Automated accessibility audits uncovered concrete functional defects that manual testing had missed. They improved not only accessibility, but also layout resilience, data handling, navigation clarity, and overall product quality.

Finally, we learned that on-device AI changes the relationship between the user and the product.

When inference, memory, safety checks, and personalization remain local, privacy is no longer dependent on trust in a remote service. It becomes a property of the application itself.

What’s next

Our next goal is to complete NovaEducation’s full on-device validation matrix.

This includes:

• VoiceOver
• Voice Control
• Switch Control
• Extreme Dynamic Type
• Cold-start airplane-mode testing
• Low-storage and interrupted-persistence scenarios
• Additional device and performance validation

We also plan to add:

• English/Spanish bilingual support
• More advanced deterministic STEM solvers
• Collaborative learning experiences between students
• Secure progress export
• Expanded interactive 3D educational content
• More personalized learning paths
• Additional tools for parents and educators that preserve the same local-first privacy model

NovaEducation demonstrates that advanced AI education does not need to choose between intelligence, accessibility, safety, and privacy.

A personal tutor can be helpful without monitoring the student.

It can be intelligent without sending conversations to a server.

It can be personalized without building a cloud profile of a child.

We believe the future of education will not only be AI-powered. It should also be private by default.

NovaEducation is our step toward that future.

Note: NovaEducation works completely offline once Apple Intelligence has been enabled and the required on-device models are ready on the device.

Built With

• codex
• gpt-5.6
• ios
• on-device-ai
• swift
• swiftdata
• swiftui