LearnHarness is an open-source desktop app that points AI agents at one job: teaching you something hard. The repository by Amos Blomqvist was trending on GitHub this week, gaining about 1,451 stars since October 16 and now showing roughly 1.5k stars and 250 forks. The pitch, from the README: "an agent harness for learning." Instead of dumping an explanation, it measures what you understand, plans a path, teaches one step at a time, drills you, and remembers.
This post covers what it does, how it is built from the user's side, what it costs, where the privacy lines are, and how it compares with the other kinds of harnesses we cover.
Quick answers
| Question | Answer |
|---|---|
| What is it? | A desktop app that runs teaching and practice agents |
| License and price | AGPL-3.0, free; you pay your model providers directly |
| Bring your own key? | Yes; 30+ provider options including OpenAI, Anthropic, Google, DeepSeek, OpenRouter |
| Platforms | macOS (Apple Silicon), Windows x64 (unsigned), Linux x64 (AppImage, .deb) |
| Where is data stored? | Locally, as plain files; model requests still go to your providers |
| Is it offline? | No. Local storage does not mean offline processing |
| Proven to work? | Design is documented; we found no published learning-outcome study |
What does a LearnHarness session actually do?
The project site and README describe a four-stage loop.
- Measure. Before teaching, the agent probes the ideas your goal depends on to find where your understanding ends. The site's example is physics: from "does light travel in a straight line?" through the double-slit experiment to photon self-interference. Your answers, your confidence and your free-text reasoning show it where to start.
- Plan. It builds a minimal dependency map from what you already understand to your goal. You can see the plan as a lesson map, and it adapts if your understanding turns out different from the first guess.
- Teach. One reasoning step at a time: you predict the next move, see it explained, then answer a check question. Confusions are repaired before anything is built on them. The stated aim is for the goal to feel obviously true, not merely familiar.
- Practice. Separate sessions pose varied problems that require the right knowledge to come to mind without being named first. Hints are small and adapt to your reasoning.
A distinctive feature is the "thinking fields." You explain your reasoning, uncertainties and reactions in your own words, by typing or dictation, so the agent gets a picture of how you think rather than a right-or-wrong record. The agent can also research in the background, create visual explanations and build interactive demonstrations.
What is the knowledge graph?
What you are taught accumulates as propositions and reasoning chains: individual claims and the premises leading to them. The graph links back to the source sessions, and you can import notes. Future teaching sessions read the graph instead of starting from scratch, and practice sessions draw material from it. The README stresses it stores ideas and their connections, "not ratings of your ability."
For builders this is the interesting design choice. Persistent, inspectable memory is what separates a learning harness from a one-off chat. It echoes the memory-heavy designs we have covered in jcode's swarm and memory harness and the planner-worker patterns in our agent harness DAG planner write-up, but aimed at the learner's mind rather than a codebase.
How do I try it?
- Download from learnharness.ai or the GitHub Releases page. On macOS (Apple Silicon) it is a signed, notarized DMG. On Windows run the installer and expect an "unknown publisher" or SmartScreen warning because it is currently unsigned. On Linux make the AppImage executable or install the .deb.
- Add a provider API key and choose your models.
- Start a session with what you want to understand, for example: "I want to understand why attention scales quadratically and what linear attention gives up."
- Answer the probes honestly, including what you are unsure about. The planner is only as good as the signal you give it.
Developers can run from source: npm install, then npm run dev (serves on port 3000) and npm test, which the README says is deterministic with no LLM and no network. The repo also ships a skills/learnharness folder and an AGENTS.md, so it is built to be driven by coding agents too.
What does it cost and where does your data go?
There is no subscription or markup. You pay providers for usage, and a live cost meter shows model spend. A tutoring loop that probes, plans and drills will use many calls, so pick models deliberately: a cheaper model for practice problems, a stronger one for planning and explanation. Our guide on how to pick between frontier models is a useful starting point.
On privacy the README is candid. Chats, the graph, settings and API keys live on your machine, and learning records are plain files you can inspect. System prompts are visible and editable. But requests send the context needed for each task to your chosen providers, and web research and dictation call separate services. "Local storage does not mean offline processing." If you study anything sensitive, check what your provider retains.
The license is AGPL-3.0. That is fine for personal use, but anyone planning to embed or host a modified version as a service should read its network-use clause first. The maintainers add that the app is "free and open forever," and that any future charge would be for convenience such as managed keys or hosting.
How does it compare with other AI tutors?
| Approach | Strength | Gap |
|---|---|---|
| Plain chat model | Instant, flexible explanations | No model of what you know; no memory by default |
| Hosted tutors such as Khanmigo-style products | Polished, curriculum-aligned | Closed, fixed content, subscription |
| Melo, explainx.ai's learning copilot | Guided inside explainx.ai pathways | Tied to our content |
| LearnHarness | Open, any topic, graph memory, your keys | Setup effort, API costs, unproven outcomes |
On evidence, the broader picture is mixed. A Dartmouth AI tutor study reported gains when tutoring was designed around pedagogy, while research on unrestricted AI help found a learning penalty on exams. LearnHarness's design choices, asking you to predict and explain before it explains, line up with the pedagogy side. Whether it delivers measurable gains is untested publicly.
Who is it for, and who should skip it?
It suits self-directed learners with a specific, difficult target: a proof technique, a physics concept, a statistics method, a new framework's internals. The measure-then-plan loop pays off most when a topic has a clear dependency structure, where missing one prerequisite makes everything after it fall apart. The thinking fields reward people willing to write out half-formed reasoning, which many learners find uncomfortable but useful.
It is a poorer fit if you want a quick answer, if you cannot spare an API budget, or if you need an accredited curriculum. Teachers evaluating it for a class should note that it is a single-user desktop app with local storage, not a classroom platform with rosters and reporting. Developers who like the concept can read the architecture and development guides in the repo and the skills/learnharness folder to see how the teaching and practice agents are structured, and borrow the pattern of a persistent claim-and-premise graph for their own agent products.
What people are asking
Can I use a local model? The README lists 30+ provider options, and OpenRouter-style routing is among them, but it does not say here which local runtimes are supported. Check the docs folder before assuming offline use.
Will the graph get messy? Because it stores claims and the premises behind them, with links back to source sessions, you can trace a belief to the lesson that created it. That also makes it possible to spot and correct a wrong claim, which is the main defence against a weak model teaching you something false.
Does it replace a textbook? No. Treat it as a guide that finds your gaps and drills you, and keep primary sources open for anything you plan to rely on.
Honest limitations
- No outcome data. We found no benchmark or study; claims about understanding "feeling obviously true" are the author's aim.
- Quality depends on the model. Poor probing or wrong explanations from a weak model will mislead you, and the graph will store those mistakes.
- Cost can creep. Many agent calls per session add up with premium models.
- Windows is unsigned. Expect warnings and verify the download source.
- Early project. A fast star count says interest, not maturity; check the issue tracker before depending on it.
Prompts to get more out of it
- State a concrete goal: "I want to be able to derive the backprop update for a two-layer network without notes."
- Write real thinking: "I think the gradient flows through the sum because... but I'm unsure about the bias."
- Import your own notes so the graph starts from your material.
- Use practice sessions a day later; the harness is designed for recall that succeeds with effort.
- Edit the system prompts if the tone or pacing does not suit you, since they are visible and editable.
Bottom line
LearnHarness is a thoughtful take on what an agent harness for learners should look like: measure, plan, teach, practice, remember, all on your machine with your keys. Its traction suggests developers want tutoring tools that model the learner, not just answer questions. Try it on one hard topic, watch the cost meter, and judge it by what you can do without it afterwards. Also see where it sits among open and closed agent harnesses.
Repository stats and features are as of October 25, 2026, taken from the project's README and site. Check the repo for current releases and license terms.