VolnaTry it
Voice AI DSA tutor

Your DSA tutor that never skips to the answer.

Explain the problem back. Defend your approach out loud. Watch real test cases catch what you missed. Then do it again, better.

Try itSee how it thinks
1

Understand the problem

You explain the problem back in your own words. The tutor checks that explanation against the problem's real edge cases before it lets you move on, not a vague nod that you 'got it.'

2

Find the approach

Say your brute force approach out loud first and defend it. The tutor grades it against an authored explanation of why it falls short, then walks you up a hint ladder toward the optimal approach, one level at a time.

3

Write & defend your code

Type real code in the editor. The tutor asks why you made specific decisions while you're mid-thought, then runs your code against real test cases, including the edge cases most people forget.

How it actually thinks

A state machine grading real answers, not a chatbot guessing what to say next.

This is the actual LangGraph running the tutoring session: every phase is a node, every transition is a conditional edge reading structured output, and the LLM never chooses its own next step. Hover any node to see what it really does, drag one to rearrange the graph, and scroll to watch it come alive.

ready to advancebrute force describedoptimal approach foundsubmit via data channelall tests passgaps foundstuck 2+ turnstests failedINTROCOMPREHENSION_CHECKCOMPREHENSION_REMEDIATIONAPPROACH_DISCUSSIONBRUTE_FORCE_ANALYSISHINT_LADDERCODINGEXECUTINGFEEDBACKITERATIONCOMPLETE
forward transitionloop / branch back
  1. 01

    INTROEntry node

    Introduces the problem in our own wording. Nothing here is scraped LeetCode text.

  2. 02

    COMPREHENSION_CHECKLLM-graded gate

    Grades your explanation against the problem's real edge cases, not vibes.

  3. 03

    COMPREHENSION_REMEDIATIONRemediation loop

    Surfaces one authored loophole at a time until you actually see it, then sends you back to explain again.

  4. 04

    APPROACH_DISCUSSIONDiscussion node

    You describe an approach out loud before a single line of code gets written.

  5. 05

    BRUTE_FORCE_ANALYSISLLM-graded gate

    Grades your brute force against an authored 'why it's insufficient,' never an improvised excuse.

  6. 06

    HINT_LADDERAuthored hint ladder

    Hints are pulled verbatim from an authored ladder. The model only decides when you've earned the next level.

  7. 07

    CODINGEditor node

    You write real code in the editor while the tutor asks why, referencing your actual diff.

  8. 08

    EXECUTINGSandbox call (Piston)

    Your code runs in a real sandbox against real test cases. Nothing here is simulated.

  9. 09

    FEEDBACKVerdict narration

    Narrates Piston's actual result. It explains a verdict, it never invents one.

  10. 10

    ITERATIONIteration router

    Failed a test? Back to coding for another pass. A separate route back to the hint ladder for 'still fundamentally stuck' isn't wired yet, so it always retries through coding for now.

  11. 11

    COMPLETETerminal node

    All test cases pass against the real sandbox. Done, for real this time.

Problems we hit building this

The honest version, not the highlight reel.

Piston's sandbox went whitelist-only mid-build

The public Piston API we planned around started requiring a whitelisted key partway through the build. We're working through the access process instead of pretending it was never a problem.

Near-zero-cost, on purpose

Groq covers the model and the speech-to-text. Deepgram covers voice. LiveKit's free tier covers the room itself. The budget was $0, and the architecture had to fit that, not the other way around.

The model doesn't get to invent a hint

Every hint, every edge case, every explanation of why the brute force falls short comes from an authored problem bank. The model only judges your answer against it and narrates the verdict, it never makes one up.

Authored, not improvised

The hint ladder is a file, not a guess.

Every hint the tutor delivers is written ahead of time by us and pulled verbatim. The grading prompt explicitly tells the model to ignore its own memorized version of the problem and judge only against what's in the file.

problems/two_sum.py
# problems/two_sum.py: authored, not scraped from LeetCode
hint_ladder = [
    Hint(level=1, text=(
        "What if you didn't have to re-scan the array "
        "for every number?"
    )),
    Hint(level=2, text=(
        "A hash map turns 'have I seen this value before' "
        "into an O(1) lookup."
    )),
]
 
GRADE_PROMPT = (
    "Grade solely using the context below. "
    "Ignore your own memorized knowledge of this problem."
)
A real session, captured

This is the actual product. Every line below is real.

A genuine connection to the real voice worker, a real duplicate-value edge case surfaced before the explanation was accepted, and a real submission graded against a real sandbox. Nothing on this page is staged.

volna · tutor/two-sum
A real Volna tutoring session for Two Sum: the problem panel, a real submitted hash-map solution, a real all-passing Piston test run including duplicate-value, negative-number, and zero-value edge cases, a genuine connected voice session, and the real tutor conversation that led to the solution.
  • Real sandboxed execution against test cases
  • Hints gated until you're actually stuck
  • Grading grounded in an authored problem bank
  • No scraped problem text

Pick a problem. Explain it back. Defend your approach.

No account, no setup. Just a problem, a hint ladder you have to earn, and real test cases waiting to catch what you missed.

Try it