Compass

Where the Dread Started

I've watched university applications turn into a second job for everyone who's gone through them and I was no exception. Dozens of tabs, half-trusted forum threads, requirements that change without warning, and the constant low-grade fear of missing something that mattered. The frustrating part isn't that the information doesn't exist. It's that finding it, verifying it, and tracking it all in one place is exhausting in a way that has nothing to do with the actual hard work of getting in.

I wanted an agent that didn't just answer questions once and disappear, but actually watched the process the way a mentor would: quietly, in the background, only stepping in when it mattered. That idea became Compass.

The Shortcut

Compass is an autonomous research agent for university and grant applications. You start with one of two paths: tell it exactly where you want to apply (up to 50 universities, plus degree level), or let it build the list for you through a short wizard - fields of interest, region, budget, whether to include grants, and preferred program language.

From there, it keeps working. It researches candidate universities and grants, rates its sources by trust level, and asks you to confirm before anything joins your comparison table. That table grows over time: country, price, program, requirements, all in one view. Click into a university and you get a full detail page with its sources, an editable admission checklist, and curated prep material (courses, books, practice tests, both free and paid).

The part I'm most attached to is the sonification layer: the agent's state (faced an error, needs your intervention, found new information or finished working) is mapped to distinct sounds, so you can sense what's happening without staring at a dashboard. It's a small thing, but you won't have to constantly keep an eye on the agent and do your work while Compass does its.

Solo Build, Moving Ground

Solo build, no team. The frontend is React, built and iterated on in Base44, which I later migrated off of its built-in auth/data/LLM stack so it could talk to a custom FastAPI backend instead. I wanted full control over how the agent reasoned and logged its actions, not a platform's opinion of it.

The backend runs the agent loop, source-trust scoring, and the confirmation-before-add logic for the comparison table. Firestore holds the data. Model access runs through Google AI Studio's free tier, the backend is hosted on Render's free tier, and scheduled research runs are triggered by GitHub Actions cron rather than Cloud Scheduler.

I also built two watchdog layers on top of the core agent: one that tracks steps, tokens spent, repeated actions, and elapsed time to catch and break stuck loops automatically logging the incident and letting the agent continue and a second that monitors the agent's actions so it can't act outside its intended scope. Every action the agent takes is written to a diary log, so nothing it does is invisible.

Where It Almost Fell Apart

The infrastructure plan changed under me partway through: I'd designed around Vertex AI and Cloud Run, but without a usable Google Cloud billing account (a declined card closed that door), I had to re-architect onto free-tier alternatives (AI Studio, Render, GitHub Actions) while keeping Firestore as the one Google Cloud piece that still worked. That meant redoing scheduling and deployment assumptions I'd already built around.

Migrating off Base44's built-in auth and data layer, after having already built the frontend inside it, was its own puzzle - untangling what the platform had been quietly handling so the custom backend could take over cleanly.

The agent-safety pieces were the hardest design problem, not the hardest code problem: deciding how strict the watchdog should be without making the agent too timid to be useful, and figuring out what "stuck" and "out of scope" should actually mean for an agent that's supposed to act somewhat independently.

What I'd Point To First

Getting the confirm-before-add flow to actually feel respectful rather than naggy: that one small interaction pattern is doing a lot of the trust-building work in the whole product. I'm also proud of shipping the full expanded concept rather than trimming it down to a minimal slice: onboarding wizard, growing comparison table, detail pages, checklists, prep material, sonification, and both watchdogs, all built solo in the hackathon window.

Rebuilding the infrastructure plan mid-build without losing time to panic is its own small win. The free-tier stack ended up simpler to reason about than the original one.

What Stuck With Me

That the safety layer isn't a bolt-on. Designing the watchdogs early forced me to think much more precisely about what the agent is actually allowed to do, which made the rest of the architecture cleaner. I also learned that a good non-visual signal (the sonification) can carry more trust than another notification ever could; people don't want more things to read, they want to sense that something reliable is happening.

And practically: build your infrastructure plan with a fallback from day one. The free-tier pivot cost me time I hadn't budgeted for, but it also made the system more portable than the original design would have been.

Where Compass Goes From Here

I'd also like to add chat as a core interaction layer - one general chat, plus a dedicated chat inside the comparison table and inside each individual report. Everything the user asks or shares there would feed into a shared memory, so the agent never loses context or has to be re-briefed.

And longer term, I want Compass to be a full standalone app both for a smartphone or a computer so the agent can keep working in the background while you go about your day, and reach you with a push notification (paired with its own sonification cue) the moment there's something you actually need to know. Wherever you are, Compass stays in touch with you.

Built With

• firestore
• github
• javascript
• python
• react
• render
• vercel