Sprout

Paste a syllabus or a topic list and Sprout maps the course: concepts, prerequisites and the exam date.
Each course opens on your mastery for every concept, weakest first, with a countdown to the exam.
Ask a question mid-session and Sprout answers it first, then offers to get back to the lesson.
Lessons are written for the concept you're weakest on, in the format that has worked best for you.
Flashcards come from each lesson. Mark whether you knew it and Sprout adjusts what comes next.
Diagnostic and check questions find out what you already know before Sprout teaches it.
Every answer updates your mastery with Bayesian Knowledge Tracing. This right answer moved it from 20% to 47%.
The journey map shows where you are in the prerequisite chain and what you can learn next.
Your garden on sproutlearn.tech: every concept is a plant that grows from seed to flower as you master it.
All your courses in one place, sorted by the soonest exam, with what's due for review.
Start a live game from the chat and your friends join on their phones with the room code.
The host screen shows the question and timer while everyone answers on their phone.
The podium and the topics the room missed. Everyone's answers update their mastery too.
Arcade games use questions from your own course. In Meteor Blaster you shoot the meteor with the right answer.
Quiz Runner and Meteor Blaster, played solo at your own pace with a shared high score board.

Inspiration

We're all college students and a lot of how we study right now is opening ChatGPT and asking it to explain something, which works fine until you realize it has no idea what you already know. Every new chat starts from nothing, so you end up re-explaining your class, re-reading stuff you already understand, and never really getting pushed on the topics you're actually weak at. A real tutor remembers what you struggled with last week and brings it back before your exam, and we wanted something like that inside the chat app people already use instead of another website to sign up for. We also wanted studying to be something you could do with your friends, so games ended up being a big part of it.

What it does

Sprout is a group of AI agents you talk to in ASI:One. You paste your syllabus, a list of topics, or just tell it what class you're taking, and it builds a map of the course with all the concepts, what each one depends on, and where you should start.

After that it teaches you. It gives you short lessons, flashcards, and quiz questions focused on whatever you're weakest at, and every answer you give updates how well Sprout thinks you know each concept. All of that is saved, so if you close the chat and come back a few days later it picks up where you left off and brings back concepts for review before you forget them. It also keeps track of how many days you have until your exam.

When you want to study with friends you can start a live game where everyone answers on their phone against a timer, kind of like Kahoot, or play an arcade game like Quiz Runner or Meteor Blaster that uses questions from your own course. Every right answer grows your garden, which is a visual map of your progress across all your classes.

How we built it

Sprout is built with Fetch.ai's uAgents framework, hosted on Agentverse, and talks to students through the Agent Chat Protocol in ASI:One. There's a main orchestrator agent called Sprout that figures out what the student wants and passes it to the right specialist: a Curriculum agent that turns syllabi into concept maps, a Tutor agent that teaches and quizzes, and Arcade and Garden agents for the games and progress views.

Everything a student knows is stored in a SpacetimeDB database instead of in the chat, which is what lets Sprout remember you across conversations. The database handles the learning logic too, including deciding what you should study next.

To track mastery we used Bayesian Knowledge Tracing. Each concept has a probability P(L) that the student has learned it, and every answer updates that probability using Bayes' rule while accounting for the chance of guessing right P(G) and the chance of slipping up on something you know P(S):

$$ P(L \mid \text{correct}) = \frac{P(L)\,(1 - P(S))}{P(L)\,(1 - P(S)) + (1 - P(L))\,P(G)} $$

$$ P(L \mid \text{wrong}) = \frac{P(L)\,P(S)}{P(L)\,P(S) + (1 - P(L))\,(1 - P(G))} $$

After that we add the chance that the student learned the concept just from practicing it, P(T):

$$ P(L_{t+1}) = P(L \mid \text{obs}) + \big(1 - P(L \mid \text{obs})\big)\,P(T) $$

We treat a concept as solid once it's above 0.7 and mastered once it's above 0.95. On top of that we use SM-2 spaced repetition to decide when a concept should come back for review, and a bandit algorithm that learns which format (lessons, flashcards, worked examples) works best for each student.

The cards that show up in the chat, like the progress bars, the journey map, game invites, and the podium, are images we generate on the fly with a service we deployed on Vercel. The live game and arcade site is also on Vercel and reads game state directly from SpacetimeDB so every player's screen updates at the same time. The arcade games are adapted from Kaplay game templates and run inside a sandboxed frame, where questions get sent in and answers get sent back to the database to be scored.

Challenges we ran into

The biggest problem was speed. Every time one hosted agent sent a message to another it added 5 to 10 seconds, and a single tap on a card was taking around 22 seconds to get a response, which is way too long when you're in the middle of a quiz. We fixed this by running the Tutor and Curriculum logic directly inside the main Sprout agent instead of sending messages between agents, which brought it down to about 9 seconds.

Deploying was harder than we expected because hosted agents are edited through a browser code editor, and a few times a save didn't actually go through, so the old code kept running while we were trying to debug the new code. We started checking a hash of every file after saving to make sure what was running matched what we wrote.

Accomplishments that we're proud of

We're proud that Sprout actually remembers you. You can close ASI:One, come back days later, and it still knows which concepts you've mastered, what's due for review, and how many days you have until your exam. We're also proud that five separate agents work together without the student ever noticing the handoffs, so it feels like talking to one study partner instead of a bunch of bots. And we're really proud of the games. You can start a live game from the chat, your friends join on their phones with a room code, and everyone's answers feed back into their own mastery and garden, which made studying feel a lot more like something you'd actually want to do with friends.

What we learned

We learned that every hop between hosted agents on Agentverse costs real time. Sending a student's tap from Sprout to the Tutor agent and back took about 22 seconds, and when we timed it, about 4 seconds of every reply is Agentverse overhead that we can't control. Running the Tutor and Curriculum logic inside the main Sprout agent instead of messaging between agents got a tap down to about 9 seconds, and having the Tutor write the next quiz question in the background while the student is still reading feedback on the last one made "Next question" feel close to instant. So now we only give something its own agent when it really needs to run on its own.

We learned how ASI:One cards actually work. A tapped button doesn't call your agent directly. It comes back as a normal chat message containing JSON like {"selection": {...}}, and every older card in the chat can still be tapped later. That meant we had to send each tap to whichever agent owns that button's action, instead of to whichever agent sent the most recent card. Card images also have to be a public http(s) URL, so all the progress bars, journey maps, game invites and podiums are rendered as images on Vercel and linked into the card.

We learned a lot about SpacetimeDB from building the live games on it. Each question ends on a scheduled reducer that runs on the server instead of a timer on the host's laptop, so every phone flips to the answer at the same moment no matter whose computer is hosting. The correct answers live in a private table, so players can't read them from the public data their phones subscribe to. Arcade games run in a sandboxed frame and only send back which answer the player picked, and the database does the scoring, so editing the game in the browser doesn't change your score. Reading data back over SpacetimeDB's SQL HTTP API also taught us that optional values come back encoded as [0, value] or [1, []], which we had to decode on our side.

We learned not to trust model output as-is. asi1-mini sometimes returned the course as a plain string instead of an object, added exam dates that weren't anywhere in the syllabus, or put raw LaTeX into quiz questions. The Curriculum agent now validates and normalizes every concept map, only keeps an exam date if the syllabus actually mentions one, and the Tutor converts LaTeX into plain text before it shows a question.

We also learned where Bayesian Knowledge Tracing works well and where it falls short. With only four numbers per concept it reacts fast, and one right answer on a heap question moved that concept from 20% to 47%, which feels right for a student who clearly knew it. But BKT on its own assumes you never forget anything, which is why we paired it with SM-2 to schedule reviews, and its default parameters treat every concept the same, which is why fitting them per concept is next on our list. Table No. 67

What's next for Sprout

First we want to make Sprout faster. A tap still takes several seconds, and since about 4 of those are platform overhead, the next step is caching lessons so two students studying the same concept don't both wait for the model to write it.

Next we want to fit the BKT parameters for each concept from real answers instead of using the same defaults everywhere. One of our teammates already wrote the code that fits them with pyBKT, and the database reducer that stores them is written, so what's left is collecting enough answers and running it.

We also want getting a course into Sprout to be easier, by letting students upload their syllabus as a PDF or import it from Canvas instead of pasting text, and we want Sprout to message students in ASI:One when a concept is actually due for review instead of waiting for them to open the chat.

Longer term we want a class mode. The live game results already show which questions the room missed, so a teacher could start a game for the whole class, see which concepts most students are weak on, and have Sprout send everyone a review on exactly those concepts. We also want to add more arcade games beyond Quiz Runner and Meteor Blaster.