Get It. Turns a Text-Based PDF into a Mastery Map You Can Measure

The gap Get It. claims to fill: depth over surface area

The README opens with a blunt premise. The student already has the PDF, and does not need another summary. What is missing, in the project's framing, is a way to see the parts a textbook does not draw and a way to prove comprehension concept by concept rather than page by page. The stated complaint against existing tools is that they measure surface area: flashcard ratings capture recall in the moment, mind maps capture how much you drew, summaries capture how patient the model was. The question the project puts at the centre is whether you would survive a question you have not seen before. That framing tells you who this is for. It is for someone working through a dense, text-heavy document (anatomy, physics, chemistry, legal articles, named papers appear in the renderer list) who wants an artifact that changes as their understanding changes. It is not for someone who wants a chat window bolted onto a file. The distinction matters because the whole architecture follows from it: tagging, rendering, graphing and scoring are all built around the document rather than replacing it.

The intake gate: text-based PDF or Markdown only

Get It. accepts a digital, text-based PDF, or a Markdown file, which the README says it renders to a clean document on the way in. The gate is explicit: the app checks the file up front and turns away scans or image-only documents with a clear message, because it reads text and not pictures. This is the single hardest constraint in the project and it is worth stating plainly, because it disqualifies a large share of real study material. Photocopied chapters, scanned textbooks, handwritten notes and slide exports that are images inside a PDF wrapper will not clear intake. If your course material arrives as a scan, this tool is the wrong shape for it, and no configuration setting in the README changes that. The upside of the gate is that everything downstream can assume extractable text, which is what makes per-page concept tagging and inline tag placement feasible at all.

How the pipeline runs: three processes start at once

Once a file clears intake, the README describes three things starting simultaneously. First, a concept-detection agent walks every page and plants inline tag pills on words that would benefit from a picture. Each tag carries a renderer choice, and the list is specific: 3D scene, 2D animation, formula walkthrough, plotted graph, or cited source. Second, the right pane fills in. Clicking a tag renders its visualization, with Three.js named for anatomy and molecules, Canvas for physics and chemistry animations, KaTeX for formulas, a plot engine for functions and distributions, and authoritative quotes for legal articles and named papers. Ready tags are marked so you can distinguish what already exists, and a setting renders every tag automatically as you read. Third, a knowledge graph builds itself: six to twenty-five concept nodes, typed edges, sized by mastery and coloured by progress, clickable for a four-axis breakdown plus the evaluator's note. The error path is worth noting. When a sandbox crashes, the README states the agent reads its own error and re-emits a fix, and the student sees a repairing state rather than red text. That is a design decision about failure visibility, and it cuts both ways: a learner is spared a stack trace, but also does not see how many repair cycles a given visualization needed.

Four study tools feeding one journal, and the evaluator that reads it

The loop closes through a journal. Four tools write to it. Chat measures recall references and paraphrases, multi-turn and multi-thread, scoped to a single document. Flashcards measure open recall under self-grade with Again, Hard, Good and Easy on every card. Quizzes measure forced-choice discrimination with one correct answer and three plausible distractors. Feynman has the agent play a curious eight-year-old while you teach, which the README calls the strongest comprehension signal. After every completed session, the evaluator agent reads the journal end to end and updates four scores per concept node: memory, comprehension, structure and application, each 0 to 100. This journal-as-single-source design is the most defensible part of the project. The scores are not computed from a single interaction type, they are derived from the accumulated record across four different modes of evidence, and the evaluator reads the whole thing rather than the last message.

The monotone clamp is the design choice to argue with

The README states that each of the four scores is monotone non-decreasing by a runtime clamp, and that the student can only progress, never regress. The project frames the four numbers as the difference between a study app and a measurement instrument. That framing and the clamp sit awkwardly together. A measurement that cannot go down is not measuring the same thing a measurement that can go down is measuring. If you take a week off, or if a concept you thought you had turns out to be shaky under a new question, the graph will not show it. The node keeps the high-water mark. For motivation this is a reasonable choice, and the README is not hiding it. For anyone who wants the graph to function as a diagnostic of current state rather than best-ever state, the clamp is the first thing to inspect in the code before trusting the numbers. The README does not describe an option to disable the clamp, and it does not describe a decay function, so as documented the scores are cumulative evidence of exposure and success, not a live estimate of retention.

Bring your own engine: four providers, one local option, no metering layer

The AI side is deliberately not monetised. The README states there is no Get It. server, no shared key pool, no per-message metering, no credits wallet and no second subscription, and that there is no plan to ship one. You sign in once with an account or key you already have, through that vendor's official CLI bundled with the app, and every agent runs against your own tier. Four engines ship side by side: OpenAI Codex (a ChatGPT Plus, Pro, Team, Enterprise or Edu account, or an OpenAI key), Anthropic Claude (a Claude Pro or Max subscription, or an Anthropic key), Google Gemini via API key, and bring-your-own, meaning any OpenAI-compatible endpoint including a fully local model through Ollama. You can switch engines from the setup wizard, and the README says the app picks the conversation back up mid-document. Data locality is stated concretely: documents and study journal never leave the computer, there is no cloud sync and no document upload, and the only outbound traffic is an anonymous open and update ping carrying a random install id, the app version and the OS. Setting GETIT_DISABLE_ANALYTICS=1 turns that off. The work-context journal is described as a single JSON file on disk, downloadable in one click from the right-pane menu. Rate limits belong to your provider: the README says the app shows a countdown banner, stops cleanly, saves your work, and does not retry in a loop, and you resume by re-clicking a concept or hitting Retry on a tool.

Running it, and what the README does not give you

The only concrete runtime instruction in the supplied material is the environment variable GETIT_DISABLE_ANALYTICS=1. The stack is declared in badges (Next.js 16, Electron 33, React 19, TypeScript 5.x, Tailwind CSS 4, Three.js r184, pdf.js 5.x) and the primary language is JavaScript, but the README excerpt does not include a clone, install or start command, so there is no verified way to state one here. Treat the setup wizard as the documented entry point for engine selection and sign-in, since that is the flow the README describes. The practical consequence is that a first-time evaluator should expect to read the repository for the build and run steps rather than the README. The release history is the other maintenance signal available: v1.3.0 on 2026-06-09, v1.4.0-preview on 2026-06-12, and v1.4.0 on 2026-06-29, with a last push timestamp of 2026-06-29. That is a compressed release window consistent with a hackathon project (the README names GDG AI Hack Milan 2026 and the Learn Different track) that continued shipping after the event. It also means the project is young, and the API surface of the journal JSON, the graph node schema and the evaluator prompt are all plausibly still moving. The licence is Apache-2.0, which permits commercial and private use and modification, and includes an explicit patent grant; the README excerpt does not carry a NOTICE file listing or any attribution requirement beyond the licence text itself, and nothing here is legal advice.

Where it sits against Anki plus a chat assistant

The obvious alternative is the combination most students already run: Anki for spaced repetition and a general chat assistant for explanation. The difference in approach is structural. Anki schedules reviews from a deck you author or import, and its unit of work is the card, which you write yourself. Get It. derives its units from the document: the concept-detection agent picks the tags, the knowledge graph picks the six to twenty-five nodes, and the four scores come from an evaluator reading a journal you never hand-curate. That is the trade. You do less authoring, and you accept the agent's judgement about what counts as a concept and how many nodes your document deserves. A chat assistant can explain anything, but the explanation is not anchored to a page position in your file and does not feed a persistent per-concept record. Get It.'s inline tag pills and the cited-source renderer are what a chat window cannot reproduce: the visualization sits on the word that needed it, inside the document you are already reading. The cost of that anchoring is the intake gate. Anki accepts a photograph of a page as an image card. Get It. does not accept the same page as input at all.

Editorial conclusion

Adopt Get It. if you study from digital, text-based PDFs or Markdown and you already pay for an OpenAI, Anthropic or Gemini tier, or you can run a local model through Ollama and want the journal to stay on disk. Do not adopt it if your material is scanned or image-only, since the README states the app turns those away at the gate, and do not adopt it if you want a score that can fall when your recall does. Before committing, verify three things: that your engine of choice signs in through the bundled CLI, that the four-axis scores behave the way you expect given the monotone non-decreasing runtime clamp, and that the journal JSON exported from the right-pane menu contains the per-concept history you need.

Official sources

1. beltromatti/get-it on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases