-
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
Inspiration
Bloom's famous Two Sigma Problem showed the extraordinary potential of one-to-one tutoring: when a student has a good personal tutor who understands them, is patient with them, adapts to how they learn, identifies where they are struggling, and guides them individually, their learning outcomes can improve dramatically.
The problem is that this does not scale.
It is simply impossible to give every student a truly great personal teacher—especially across communities where good educational resources, strong teachers, reliable internet access, and even computing power may already be limited.
As an aspiring educator myself, I have always thought about the absence of practical, real-world applicable learning in African education. And as a machine-learning enthusiast, I kept thinking about the same question:
What if technology could give every student that kind of deeply personal educational companion?
That idea became Muta.
Muta is our attempt to bring the promise behind Bloom's Two Sigma Problem closer to reality: an Education AI companion that can meet a student at their level, patiently teach them, adapt to them, and remain available even when the internet is not.
And importantly, we are building it for the realities of African students, not only for classrooms with perfect connectivity and expensive hardware.
What it does
Muta is an offline-first educational AI application built around an AI model with strong capabilities in high school STEM education, while also extending into arts and commerce.
A student can ask Muta a question naturally and receive an explanation, continue asking follow-up questions, work through mathematical and scientific reasoning, view interactive visualizations, use audio, and communicate in more than 30 supported languages.
But something is extremely important to us:
Muta is not the model.
The AI model is one component of Muta, and we deliberately designed the system so that the underlying model can be changed as better models become available.
Our long-term moat is instead the deeply integrated educational intelligence layer around that model.
We envision Muta understanding not only a student's latest question but also increasingly understanding the relationships between:
student → teacher → parent → school → curriculum → assessment → learning outcomes → best career. Muta will be the perfect education-to-career platform guiding every African student.
Over time, Muta should understand what a student knows, what they misunderstand, what they have forgotten, how they learn best, what their teacher is currently teaching, what their curriculum expects from them, and what they should learn next.
The underlying AI model may be replaced.
The accumulated education graph, learner context, institutional relationships, workflows, and learning intelligence cannot be replaced nearly as easily.
That is the Muta we are building toward.
How we built it
Muta is composed of five major systems:
- The Muta Frontend
- The Muta Backend
- The Inference Engine
- The AI Model
- The Muta Fleet Manager
We designed Muta as real installable desktop software rather than simply another web interface connected permanently to a cloud model.
The frontend is built with React, HTML, and CSS, while the backend is written in Python with FastAPI, providing an asynchronous interface between the application and Muta’s local services. Application data is persisted locally using SQLite, with PostgreSQL support for larger deployments.
The most demanding engineering work was context and user-state management. Muta must reconstruct multi-turn conversations while fitting system prompts, tutoring modes, personas, learner preferences, learning-twin data, retrieved resources, images, web context, reasoning, and responses within a finite context window. This required:
- intelligent history trimming without modifying stored conversations;
- preservation and resumption of interrupted streams;
- persistent conversations, messages, attachments, citations, preferences, and mastery data;
- strict per-user data isolation;
- authentication, sessions, permissions, CSRF protection, and secure uploads;
- reliable and complete account deletion.
The backend also:
- coordinates concurrent learners through fair request queues, cancellation, reconnection, and replayable streams;
- supervises and restarts the local llama.cpp inference engine;
- dynamically manages RAM, KV cache, context capacity, and model slots;
- safely degrades vision, speech, or session capacity under memory pressure;
- integrates RAG, PDF processing, image understanding, speech, mathematical verification, and sandboxed tools behind a stable API.
For distribution, the Python backend is packaged for each operating system using PyInstaller, while Tauri bundles the complete desktop application for our three primary targets:
- Windows
- macOS
- Linux
The result is a system designed to run securely, privately, and reliably without installation complexity, a dedicated GPU, or continuous internet access.
For local AI inference, Muta supports llama.cpp, allowing the model to execute directly on commodity CPUs. Rather than carrying unnecessary parts of the larger native stack, we compile the components Muta needs and use FFmpeg for our media-processing requirements.
And because running AI locally means that every CPU, battery, and amount of RAM is different, we built Muta to understand the machine it is running on.
Muta can inspect the available system resources and adjust how much work it safely performs. Its memory-management system determines how many simultaneous conversations the machine can support and how much context can safely be allocated to each one.
We also built Muta Power Optimization. When a student is running on battery, Muta can enter Eco Mode, bounding automatic reasoning and using shorter responses where appropriate to reduce unnecessary computation while preserving full reasoning budgets when the task genuinely requires them.
Muta also includes Host Mode, allowing one computer running Muta to privately serve other users on the same local network. This is particularly important to where we believe Muta can go: a school should not necessarily need a powerful computer—or an internet connection—for every single student before local AI becomes useful.
Finally, we built the Muta Fleet.
Muta itself is capable of operating offline, but whenever an installation reaches the internet, the Fleet allows us to receive pseudonymous application heartbeats, understand deployment health, track versions and platform characteristics, improve the product from real-world usage, and provide the foundation for safely distributing future updates.
The cloud therefore supports Muta.
It does not define whether Muta works.
Challenges we ran into
Our first challenge was surprisingly fundamental:
What exactly does "low-resource" mean in education?
At first, it is tempting to define the problem only as a lack of textbooks, teachers, internet access, or powerful computers.
But we quickly discovered that the problem is much wider.
A student can have a textbook and still lack someone who can patiently explain it. A school can have internet access but not have enough bandwidth for every student to continuously use a cloud AI service. A student can have a laptop, but it may have only a few gigabytes of usable RAM and no dedicated GPU. A learner can understand English and still understand a difficult concept much better when it is explained in the language they think in.
So our challenge became not simply building an AI model.
It became building an educational system that can operate across different levels of hardware, connectivity, language, learning ability, and educational support.
The second major challenge was the engineering trade-off between intelligence and resources.
Every improvement in reasoning, context size, parallel conversations, visual interaction, or model capability has a computational cost. We constantly had to measure memory usage, CPU utilization, inference speed, model size, and response quality and ask:
How much intelligence can we deliver inside the machine the student already owns?
That question influenced everything from our inference runtime and model choices to Eco Mode, memory limits, and how many conversations Muta allows to generate simultaneously.
The third challenge was turning an AI experiment into an actual product.
Supporting one development computer is very different from shipping software across Windows, Linux, and macOS. Native dependencies, application packaging, local inference, media handling, updates, operating-system differences, and resource detection all had to work together.
We wanted Muta to be something someone could actually install and use—not merely something that worked on our own machines.
Accomplishments that we're proud of
In the short span of roughly two months—and an almost unreasonable number of sleepless nights—we went from an idea to software that real people could install and use.
We are especially proud that Muta is not simply a browser demo whose intelligence disappears when the internet connection disappears.
Muta runs its AI locally on the user's own machine.
We successfully built and shipped Muta across the three major desktop operating systems: Windows, Linux, and macOS. That means the same educational experience can reach students using very different computers without requiring them to buy specialized AI hardware.
We built interactive visualizations because sometimes an explanation should not only be read. A student learning vectors, geometry, physics, or another spatial concept should be able to see and interact with what is being explained.
We added audio because education should not be restricted to typing and reading alone.
And we added support for more than 30 languages, with particular attention given to African languages, because we believe intelligence should not suddenly become less accessible because a student's strongest language happens to be Igbo, Hausa, Yoruba, Kiswahili, isiZulu, or another African language.
We are also proud of the systems behind the visible product: local inference, dynamic resource management, parallel conversations, power-aware reasoning, offline operation, local-network hosting, cross-platform packaging, and the Muta Fleet that allows us to maintain a growing installation base without making those installations dependent on the cloud.
Most importantly, we have already put Muta in the hands of early users.
Their feedback has validated the problem we are trying to solve while simultaneously showing us just how much work remains.
Our mission remains simple:
Meet every African student at their level.
What we learned
The most fascinating thing we learned was how much a product changes once real people begin using it.
In the beginning, there was naturally a fear that external feedback would undermine what we had built. Instead, the opposite happened.
Our early testers found bugs our late nights could not find. They asked questions we had never considered. They used features differently from how we expected. Some of their frustrations forced us to reconsider assumptions that had seemed completely reasonable while developing Muta ourselves.
And with every round of feedback, our confidence increased—not because users told us everything was perfect, but because they showed us that the problem was real enough to keep solving.
That process has already taken Muta through three versions.
We also learned that constraints can create features.
Limited battery life led us to think seriously about power-aware reasoning.
Limited RAM forced us to build adaptive memory management.
Limited internet access reinforced our decision to make local inference fundamental rather than optional.
The possibility that several students may need access while only one suitable machine is available led us toward local-network Host Mode.
The realities we originally saw as limitations increasingly became part of the architecture of Muta itself.
What's next for Muta
Muta is not stopping with the student.
Our goal is much larger than building a chatbot that answers homework questions.
Remember our moat:
Muta is the deeply integrated educational intelligence layer connecting students, teachers, parents, institutions, and curriculum—accumulating context, workflows, relationships, and learning intelligence over time.
The next stage is to begin turning that vision into infrastructure.
We want Muta to build a persistent understanding of each learner: the concepts they have mastered, the misconceptions they repeatedly encounter, the explanations that work for them, what they are likely to forget, and what they should learn next.
We want teachers to understand where an entire class is struggling without having to individually inspect hundreds of conversations.
We want the teacher's lesson, the student's learning, the assessment, the curriculum, and eventually the wider institution to stop existing as disconnected pieces of information.
We want them to become one connected educational graph.
And we’re building it to work without internet access—over a local area network. It’s a difficult engineering challenge we’re choosing deliberately, so Muta can reach even the lowest-resourced learners and institutions.
Moreover, because the AI model underneath Muta is deliberately replaceable, improvements in AI should strengthen this system rather than make the entire product obsolete.
A new model can make Muta smarter.
It should not replace everything Muta has learned about the learner and their educational journey.
This is also where Muta connects to the broader vision behind UDO.
Muta begins with perhaps the most fundamental part of that journey: helping a young person learn, understand, develop their abilities, and discover what they are capable of.
Our ambition is not merely to give African students access to AI.
It is to build technology that understands the educational journey around them well enough to genuinely help them move forward.
From understanding today's lesson, to mastering a subject, to discovering their strengths, to eventually navigating what comes after school.
Muta starts with the lesson. The vision goes much further.
Built With
- ai
- bash
- c++
- css
- docker
- githubactions
- google-cloud
- html
- huggingface
- javascript
- lang-graph
- lora
- macos
- maths
- optimization
- postgresql
- python
- pytorch
- rag
- sql
- ssh
- tauri
- transformers
- ubuntu
- windows
Log in or sign up for Devpost to join the conversation.