Cadence

logo

Inspiration

The idea started with a specific kid, not a general problem. Picture an eleventh grader with dyslexia, good at biology, who still takes three times as long as his classmates to get through a chapter. Not because he doesn't understand the science. Because the page itself is the obstacle: long unbroken paragraphs, dense vocabulary, no room to breathe.

We looked at what already exists for this. Tools like Immersive Reader change fonts and spacing, which helps, but they don't touch the actual density of the writing. On the other end, general purpose text simplifiers do reduce density, but they tend to flatten the science while they're at it. "Sister chromatids are drawn to opposite poles by the spindle apparatus" turns into "the cell splits in two." Easier to read, and now missing the exact mechanism that's actually going to be on the test.

Nobody seemed to be doing both at once: real restructuring, and a real guarantee that the science survives it. That gap is what we built Cadence for.

What it does

You upload a PDF chapter or paste in text, and Cadence rebuilds it into short, readable chunks, each one carrying a single idea instead of three tangled together. Every technical term gets flagged and defined using how it's actually used in that passage, not a generic dictionary entry. Click a term and want more than a one line definition, and Cadence pulls in real background on the spot through the Wikipedia API, without you ever leaving the page.

The part we're most proud of is the accuracy check. After the text is restructured, a second, independent model call compares the rewrite against the original and flags anything where meaning may have drifted. If it catches something, you can see exactly what changed side by side, and either keep the original wording or ask Cadence to repair the rewrite and re-check it.

Read-aloud runs through ElevenLabs, with four real voices to choose from, so it doesn't sound like a GPS reading your textbook to you. There's a chat panel for asking about any passage, and answers are grounded strictly in the original text, so the AI won't invent something outside what the chapter actually says. A concept graph maps out how the chapter's key terms connect to each other, which turned out to be a genuinely useful way to see the shape of a topic before diving into the text itself. You can also generate a short quiz grounded in the chapter to check what actually stuck, and export the whole restructured chapter to Markdown to study offline.

How we built it

The frontend is React and TypeScript on Vite, styled with Tailwind, built specifically for a laptop screen since this is a desktop reading tool, not a mobile app. The backend is Node and Express, and it's the layer that actually talks to every external API, so no key or model call is ever exposed to the browser.

We split the AI work across two different providers on purpose. Gemini handles the restructuring and the contextual glossary generation. DeepSeek handles the accuracy check and the grounded chat, and it never sees the instructions the restructuring step was given, only the original and restructured text side by side. That separation matters a lot, more on that below. OpenRouter sits underneath both as a fallback router, so a single provider hiccup during a demo doesn't take the whole thing down.

For storage, we went with a local SQLite database instead of a hosted service like Supabase. There's no signup and no login wall. A device just gets a random id stored in the browser, and every query is scoped to it, so someone can open the app and start reading immediately, which matters a lot when the person opening it is a judge with two minutes and zero patience for a signup flow. PDF text extraction happens client side with pdf.js, so the document itself never has to leave the browser before it's already plain text.

Challenges we ran into

The hardest problem was trust, not code. If you ask a model to simplify a passage and then ask the same model whether its own simplification is faithful, it tends to agree with itself. We had to design the accuracy check as a genuinely separate call, one that never sees the restructuring instructions and only ever receives the original and restructured text as a pair. Getting that checker to actually fire on real drift, and stay quiet on faithful rewrites that just happen to be shorter, took several rounds of testing against deliberately corrupted examples before we trusted it.

Character offsets for term highlighting were another one. Models are confidently wrong about exactly where a term sits in a string, so we had to write a repair step that re-locates every flagged term in the actual rendered text and drops anything that doesn't really match, rather than trusting the model's claimed position outright.

Wiring ElevenLabs in for natural sounding read-aloud, with word level timing that stays in sync as the voice speaks, took more tuning than we expected too. Getting the highlighting to track the audio smoothly across different chunk lengths and different voices wasn't something we got right on the first pass.

And honestly, time itself was the biggest challenge. Building a working pipeline, a real accuracy checker, a concept graph, voice synthesis, and a Wikipedia integration inside one hackathon window meant constantly deciding what could wait and what couldn't.

Accomplishments that we're proud of

The accuracy checker actually works, and we didn't just take that on faith. We built a small verification suite of known faithful and known drifted passage pairs and ran the real checker against them before trusting it anywhere near a demo. It catches genuine drift and leaves faithful rewrites alone, and on real textbook chapters it came back with zero false positives, which only means something because we already know it fires when it should.

We're also proud that the chat feature knows what it doesn't know. Ask it something the passage doesn't cover, and it says so plainly instead of guessing, because it's grounded in the original text and nothing else. That felt like the right bar to hold ourselves to for a tool a student might actually rely on before a test.

What we learned

The biggest lesson was that an AI feature is only as trustworthy as its weakest verification step, and that verification has to be a real, separate check, not the same model asked to grade its own work. We also learned a lot about how much design work goes into something that looks simple on the surface. Getting line length, spacing, and color right for a dyslexia focused reading tool took real research, not guesses, and small choices like avoiding pure white backgrounds turned out to matter more than we expected going in.

What's next for Cadence

We'd like to expand beyond single chapters to full textbooks, with the concept graph stretching across an entire course rather than one chapter at a time. Supporting more subjects beyond biology, with subject specific handling for things like chemical notation and math, is high on the list too. We'd also like to let a teacher assign chapters directly and see, in aggregate, which concepts a class is actually struggling with, based on real quiz results rather than guesswork. And longer term, we want to explore letting students save their own notes and questions alongside a chapter, so Cadence becomes something they build on over a semester, not just a one time reading pass.