Compass

Turn any school exercise into guided practice without taking the thinking away.

Comment

Compass

Inspiration

Compass started with two memories.

The first was OpenAI’s GPT-4o launch demo. A child was working on a geometry problem and pointed to the wrong side of a triangle. Instead of simply giving the answer, the AI noticed what was happening and gently helped them correct it.

The second was my father.

He taught mathematics for more than 50 years and often spoke to me about GeoGebra. On paper, geometry can feel static. In GeoGebra, students can move a point, test an idea, and immediately see what changes—and what does not.

When I saw the OpenAI demo, I imagined combining these two ideas:

  • GeoGebra as the space where the student experiments.
  • A realtime AI companion that understands enough of that space to offer the right help at the right moment.

With the release of gpt-realtime-2.1, I felt that the time had come—and the hackathon was a good excuse to finally build it.

I called my father and told him:

“I’m going to bring your project to life.”

That became Compass.

What it does

Compass is a bilingual learning companion that helps students work through an exercise without doing the thinking for them.

The main demonstration is a guided investigation of the Varignon theorem. A student opens the activity in one click and works directly inside GeoGebra. No account or classroom code is required for this public journey.

The investigation contains nine missions. Students:

  1. Construct the four exact midpoints of a quadrilateral.
  2. Connect them.
  3. Explore convex, concave, and crossed configurations.
  4. Formulate a conjecture.
  5. Verify parallel relationships.
  6. Build a justification.
  7. Finish with a transfer question.

Compass can speak with the student or respond through text. It can ask a short question, offer a progressive hint, or point to the exact GeoGebra tool or object it is discussing.

For example, if a student does not know how to construct a midpoint, Compass can highlight the real Midpoint tool. It can explain which points to select and, when explicitly requested, perform one bounded construction using existing points.

However, Compass cannot click anywhere it wants or send arbitrary commands to GeoGebra. The application controls the available actions, their targets, and their effects.

The student also remains in control of the conversation. Speaking or manipulating the figure interrupts any response or guidance already in progress.

The student is no longer alone in front of their screen. They have a companion that helps them discover, experiment, and think at their own pace.

A clear difference between help and verification

One of the most important ideas behind Compass is that the AI does not decide whether the mathematics is correct.

Compass receives a limited description of the GeoGebra construction, but exact relationships are checked by the application.

A point placed approximately in the middle of a segment is not accepted as an exact midpoint. Compass checks the actual geometric dependency. The application also verifies supported parallel relationships and identifies the convex, concave, and crossed configurations used during the investigation.

This creates two distinct types of progress:

  • A student can explain what they tried and mark a mission as completed.
  • A compatible deterministic check can confirm that the mission has been verified.

The AI cannot award verified XP, complete a mission, or turn its own construction into student evidence.

Progressive help

Compass uses several levels of support.

It can begin with a simple question, continue with a more precise hint, and then provide visual guidance inside GeoGebra. A guided demonstration is only possible after the student has agreed to it.

I spent a lot of time thinking about when Compass should intervene.

I did not want it to react negatively to a first mistake or constantly interrupt the learner. At the same time, Compass should not simply repeat the same explanation again and again.

That is why I created an agent harness that gives Compass the ability to help—but prevents it from helping too quickly.

Compass can take limited initiative:

  • When the activity begins.
  • After the current mission changes.
  • When a repeated difficulty has been detected.

Its first response should always be the smallest useful hint, not the solution.

Teacher preparation

The repository also contains a teacher space where an activity can be prepared from:

  • A topic.
  • An existing worksheet.
  • A manually written exercise.

The generated draft is never published automatically.

The teacher can edit the statement, learning objective, missions, common difficulties, and support instructions before reviewing the real student experience.

For the Varignon investigation, the teacher can edit the wording and XP value of each mission while keeping the deterministic mathematical structure intact.

The project also includes a general workflow for reading a photograph of a school exercise. The student reviews the extracted statement before beginning. If the image is incomplete or unclear, Compass asks for clarification instead of inventing the missing information.

Conversational guidance can support different school subjects. Automatic verification, however, is only displayed when Compass has a compatible deterministic module.

Today, the complete specialist experience is the GeoGebra Varignon investigation.

Privacy and classroom reporting

Compass does not produce a school grade.

By default, the public prototype keeps media, progress, and reports in memory. Audio, transcripts, and uploaded images are not stored in the learning report.

The teacher can receive factual information such as:

  • Completed missions.
  • Verified missions.
  • Captured configurations.
  • Earned XP.
  • The highest support level used.

The student’s free-text reasoning and transfer answer are not sent back to the teacher.

I also built a limited classroom pilot with rotating joining codes, student pseudonyms, targeted assignments, and PostgreSQL.

It is separate from the public one-click demonstration and is not intended to be a complete learning management system.

How I built it

I used Codex throughout the project as an engineering and review collaborator.

It helped me turn each product idea into a small implementation slice, keep specifications and runtime contracts aligned, write tests, and challenge the project from technical, educational, accessibility, and product perspectives.

Compass uses GeoGebra under its Non-Commercial License, so the GeoGebra code remains subject to GeoGebra’s license. I contacted the GeoGebra team, and they confirmed that I could use GeoGebra for this hackathon.

Compass is a Next.js and TypeScript application built around three separate AI responsibilities:

  • gpt-5.6-terra reads a student’s exercise image and converts it into a strict structured format. The image is processed in memory, without tools, using store: false.
  • gpt-5.6-luna can create one editable teacher draft from a topic or learning objective. It does not publish anything and does not receive tools.
  • gpt-realtime-2.1 provides low-latency voice and text tutoring over WebRTC.

Everything else is controlled by the application.

Challenges I ran into

Defining what the AI should be allowed to do

The hardest challenge was deciding what the AI should be allowed to do.

Giving a model unrestricted access to GeoGebra would have made the demonstration easier to build, but it would also have made the result difficult to trust.

Instead, I created a closed set of semantic actions.

Compass can refer to a midpoint, a line, or an existing point, while the application chooses the actual command, validates it, and can roll it back.

Separating conversation from proof

Another challenge was separating conversation from proof.

An encouraging AI response is useful, but it is not mathematical evidence.

I had to ensure that the model could never:

  • Validate its own answer.
  • Award verified XP.
  • Transform an assistant-created object into student work.

Handling realtime interruptions

Realtime interruption was also more difficult than I expected.

If the student moves a point while Compass is speaking, the current response may already refer to an outdated figure.

Compass therefore cancels the response and waits for the construction to become stable before continuing.

Knowing when helping becomes interrupting

Finally, I had to decide when helping becomes interrupting.

Compass needed to be proactive enough to feel present, but patient enough to let the student try.

This part can still be improved, but the current experience already feels surprisingly alive.

Accomplishments that I’m proud of

The moment I am most proud of was when my father called me and said:

“It’s amazing—and you’re not even a mathematics teacher!”

I told him:

“Codex helps me. I’m the coach!”

I am also proud that Compass does more than place a chatbot next to GeoGebra.

The companion can:

  • Understand a limited geometric world.
  • Point to real controls.
  • Follow the student’s progress.
  • Act inside the exercise without taking ownership of the work.
  • Discuss mathematical demonstrations.
  • Adapt the level of the conversation to the student.

The agent harness was an especially important achievement for me.

It feels as though someone is actually beside the learner, reacting to what is happening instead of repeating generic instructions.

I am equally proud that the project states its limits clearly.

Compass does not claim to:

  • Correct every exercise.
  • Understand every subject deterministically.
  • Replace a teacher.

What I learned

I learned that building useful educational AI is not only about making the model more capable. It is also about deciding where its authority should stop.

The model can be excellent at listening, explaining, and encouraging.

Verification, rewards, and irreversible actions require stronger guarantees.

I also learned that good tutoring often means doing less. A short question at the right moment can be more helpful than a complete explanation.

Finally, Codex helped me understand the value of keeping product decisions, implementation, and tests connected.

When I changed an educational rule, I could follow that decision through the contracts, interface, and browser journeys instead of treating it as prompt wording alone.

What’s next for Compass

I joined this hackathon to:

  • Turn a personal idea into something real.
  • Help make AI useful in education.
  • Honor my father’s 50 years as a mathematics teacher.

Varignon is the first complete specialist investigation, not the final destination.

The next step is to create a reusable system where teachers and contributors can add other validated geometry investigations without rebuilding the entire runtime.

I would also like to test Compass in a real classroom with a teacher and a small group of students.

That would help me understand:

  • When students accept proactive guidance.
  • When they prefer silence.
  • What information is genuinely useful to the teacher.

I intend to make the source code available to the GeoGebra community so that educators and developers can continue improving it.

Compass currently uses GeoGebra under its Non-Commercial License and is intended for accessible, educational, and non-commercial use.

If Compass wins first or second place, I will use 20% of the cash prize to fund API credits for a school and support a real educational pilot.

Realtime AI has a cost—and the long testing sessions with my father definitely hurt my bank account!

No student should lose access to foundational learning because they cannot afford individual help.

Built With

  • codex
  • geogebra
  • next.js
  • openai-gpt-5.6
  • openai-realtime-api
  • playwright
  • react
  • typescript
  • vercel
Share this project:

Updates