Orno treats every curriculum as a directed graph of dependencies, not a linear playlist. Learners see what unlocks what, an AI mentor anchors to the current node, and progress is structural — measured by the topology you've earned, not the videos you've watched.
Learning platforms ship a syllabus. A syllabus is a list. The world is not a list — concepts depend on other concepts, and the moment you skip a dependency the entire path collapses into noise. We built Orno as the opposite — every curriculum is a directed graph of lesson dependencies, every node carries an AI mentor anchored to its scope, and progress is measured by which dependencies you've unlocked, not which videos you finished. The result is a product where a learner can see the shape of what they're learning, not just the next item on the queue.
Every learning product is shaped by the same assumption. Concepts are arranged into chapters, chapters into modules, modules into a course. The user advances forward through that list. If they fall behind, the product nags. If they finish, the product congratulates. The metaphor is the playlist.
It works for the easy cases — a four-week intro to React, a thirty-minute knife-skills video — because in those cases the dependencies are weak enough that a linear order is at least defensible. It collapses immediately the moment the subject is dense. Try learning calculus this way. Try learning macroeconomics, or distributed systems, or auction theory. The dependencies between concepts are not linear; they fork, merge, recur, and a syllabus is the lowest-resolution approximation of that real shape.
“A syllabus is the lowest-resolution approximation of how a real subject is structured. We wanted to ship the structure itself.”
The cost shows up as boredom dressed as failure. Learners drop off not because they couldn't have understood the material but because the product gave them no map of where they were. They could not see what they had earned. They could not see what was a prerequisite they'd skipped. The chapter list was a flat fluorescent hallway with no doors visible until the next click. Every modern syllabus-shaped LMS we tried — Coursera, Khan, Udemy, the in-house tools at three Series-A startups — failed the same way at the same depth.
So we asked the inverted question. What if the curriculum *is* the dependency graph? What if you can see every prerequisite, every branch, every parallel path? What if a mentor knows where you are in the graph, not just what page you opened?
The curriculum *is* the dependency graph. Locked nodes grey out, completed nodes glow, and the next-best step pulses.
Orno is a Synara product, not a client engagement. We built it because we kept watching learners — including our own engineers onboarding into unfamiliar stacks — collapse against linear curricula. The pattern was consistent enough that we believed the structural rethink was worth a product, not just a blog post.
Graph-shaped learning needs craft in three places simultaneously: the rendering layer (a graph people can actually navigate without going dizzy), the AI layer (a mentor that knows the *local* topology, not just the page they're on), and the data layer (a backend that can describe arbitrary dependency shapes without forcing them into a hierarchy). We're a design + engineering studio that does all three on the same team, in the same codebase. That alignment is the actual unlock for Orno.
Every curriculum is authored as a DAG of lesson nodes with named dependency edges. Nodes glow when completed, grey when locked, pulse when the next-best step is identified. Built on XYFlow with Dagre layouts — pan, zoom, click to focus, double-click to enter a lesson.
Ask a question and the mentor doesn't just see the current lesson — it sees the chain of dependencies you've already unlocked and the next-best concepts in front of you. Responses are anchored to where you are, not where the lesson assumes you are. Powered by Gemini with structured context injection.
Instead of "4 of 12 modules complete," Orno shows you the *fraction of the graph you have unlocked* — and surfaces which downstream concepts are now reachable. Progress is a property of the topology, not the playlist.
Curriculum authors define lessons and dependencies in a focused builder — drag to connect prerequisites, drop in a lesson body, link to media. The graph layout is computed automatically via Dagre, so authors spend zero time arranging nodes.
Magic link by default; GitHub and Google OAuth one click away. WorkOS handles SSO, MFA, and the boring parts. We never see a password, and enterprise SSO is a deploy-config switch when a customer asks.
Trial → active → past-due → cancelled, with a re-activation flow that doesn't lose history. Built on a clean billing module so adding course-level pricing or enterprise seats later is config, not surgery.
The mentor knows where you are in the graph — not just which page is open. Responses are anchored to your local topology.
MethodologyLatency numbers measured against the production staging environment over the most recent four weeks at the time of writing. Mentor responses are evaluated against a fixed-prompt benchmark internally; the streaming time-to-first-token is the user-perceived metric we optimize for.
Orno is the first learning product where I could see the shape of what I was learning — and where I'd already been. Every other LMS I've used is a list pretending to be a course.
Per-cohort branching — different paths through the same graph for different learner archetypes (junior vs. senior, theory vs. applied). A public marketplace of community-authored graphs. And a deeper mentor mode that proactively flags weak prerequisites *before* a learner gets stuck downstream — a teacher's intuition, encoded.
If you're shipping internal training, technical education, certification programs, or any curriculum where prerequisites matter — the graph model isn't a UX gimmick, it's the correct primitive. We can scope a private Orno deployment or build a graph-native learning surface on your stack.