Axiom

Someone recently told me:

“Why would I use your tool? I can just upload my notes to ChatGPT.”

So I tried it.

And honestly, inside the chat the results looked great.

The equations rendered perfectly.
The derivations looked readable.
Everything seemed correct.

But then I tried copying the output.

That’s where things started breaking.

The rendered math you see in the chat UI isn’t always the same as the actual text representation you get when you copy it.

Things like:

• aligned equations lose alignment

• multi-line derivations flatten into single lines

• spacing between steps disappears

• LaTeX blocks become inconsistent

Inside the interface everything looks fine because the UI renders the math nicely.

But when you paste the result into a Markdown document, a LaTeX file, or a note-taking app, the structure often collapses.

That made me realize something interesting while building Axiom:

Digitizing handwritten math isn't only about recognizing symbols — it's about producing stable structured output that survives copying, exporting, and editing.

The problem isn’t just rendering math.

It’s preserving mathematical structure outside the interface where it was generated.

Curious if others building AI tools have run into similar issues where the UI makes something look correct, but the underlying representation tells a different story.

When I started building Axiom, I thought the hardest part would be OCR.

Turns out that was the easy part.

The real difficulty appeared when I tested the system on actual student notes.

Handwritten math is messy in ways that most software simply isn’t designed to handle.

Students draw arrows between steps.

They add corrections above equations.

They write side notes in the margins.

Tables are drawn by hand.

Sometimes half an equation appears on the next line.

Humans understand this instantly.

Computers don't.

At first I assumed existing OCR tools would solve most of the problem. But what they usually produce is something that technically contains the text, yet loses the structure that makes math readable.

I realized something important while building this:

Digitizing math isn't just a recognition problem.

It's a layout and reasoning problem.

You have to understand which steps belong together, where a derivation starts and ends, and when a block of math should stay grouped.

Once I started thinking about the problem that way, the system improved a lot.

What surprised me most while working on this project is how much information is actually encoded in the layout of handwritten notes, not just the symbols themselves.

Axiom is my attempt to preserve that structure when converting notes into LaTeX or Markdown.

Still learning a lot while building it.

Curious if anyone here has worked on document AI or handwritten recognition problems — the space is deeper than I expected.

A few months ago I ran into a frustrating problem while studying.

Most of my math, physics, and engineering notes are handwritten. On paper everything looks clean — equations aligned, derivations grouped step-by-step, tables structured clearly.

But the moment I tried digitizing them, everything broke.

I tested a lot of OCR tools, including newer AI-based ones. They could usually extract the characters correctly, but the structure was destroyed.

Typical problems looked like this:

• aligned equations lose alignment

• multi-step derivations collapse into paragraphs

• numbered problems merge together

• tables flatten into plain text

Technically the text was “recognized”, but mathematically it became almost unusable unless I manually rebuilt everything in LaTeX.

So I started building Axiom to solve that.

Instead of focusing purely on transcription accuracy, the main goal became structural preservation — keeping the mathematical layout intact during digitization.

The current pipeline looks roughly like this:

1. OCR from image or PDF

2. Structural prompting focused on:

   • math alignment

   • derivation grouping

   • table detection

   • numbered block preservation

3. Post-processing layer that normalizes LaTeX/Markdown and stabilizes layout

4. Export as compile-ready LaTeX, Markdown, or searchable PDF

One surprising thing while building this:
most of the engineering effort ended up being in post-processing and layout normalization, not the OCR itself.

Handling things like:

• aligned equation environments

• multi-line derivations as atomic blocks

• table column stabilization

• pagination that doesn't break math blocks

turned out to be much harder than simply recognizing characters.

Right now Axiom runs directly in the browser and converts handwritten STEM notes into structured output.

I'm still improving things like diagram detection and complex chemistry layouts, but the core system is working surprisingly well for math-heavy notes.

Would love to hear from others working on OCR, document AI, or math tooling — it's a surprisingly deep problem space.

I’ve been building Axiom over the past few months after repeatedly struggling with digitizing my own handwritten STEM notes.

Most OCR tools extract characters well enough. The problem is structural drift:

• aligned equations lose alignment

• multi-step derivations collapse into paragraphs

• numbered problems merge together

• tables flatten into plain text

Axiom focuses on preserving structure instead of just transcription accuracy.

The core pipeline:

1. OCR from image/PDF

2. Structural prompting tuned for alignment, derivation grouping, and table detection

3. Post-processing layer to normalize LaTeX/Markdown and stabilize layout

4. Export as compile-ready LaTeX, Markdown, or searchable PDF

The surprising part: most of the engineering effort went into post-processing and pagination logic rather than OCR itself.

Still improving diagram detection and more complex chemistry layouts.

Would love to connect with others building in the OCR / AI tooling space.