Grapevine

Inspiration

Every campus is packed with specialised talent, but discovery is entirely social you only find help through who you happen to know. A student stuck on antenna simulation might sit two rooms away from someone who just finished a KiCad RF project and has nothing on for the weekend, and neither will ever know. The gap isn't a skill shortage; it's that there's zero infrastructure for matching supply to demand in real time. We surveyed 30 SUTD students to check we weren't imagining it: 87% sensed help was close by and went without it anyway, 77% reach for Google or AI before ever asking a person, and 81% find cold-asking a near-stranger too awkward. The talent is right there, there's just nothing connecting it. That's what we set out to build.

What it does

Grapevine is an AI agent that brokers help between students. You type a vague problem in plain language; the agent resolves it into a precise, matchable skill, finds the peers whose actual work proves they can help, and ranks them with a human explanation rather than a percentage score. Crucially, it doesn't just match, it detects two-sided skill trades: if the person who can teach you Rhino happens to want the pitching skills you already have, the agent flags a fair swap. Then it drafts the awkward first message for you, frames the exchange, and leaves you and the other person to settle the terms. For technical problems it also generates an accurate diagram of your setup so a potential helper understands the ask in seconds. It's not a directory and it's not a chatbot it behaves like a well-connected senior who knows everyone and makes the introduction.

How we built it

The intelligence runs on Agnes AI; the reliable logic runs in our own code, by design. A Python FastAPI backend orchestrates everything and keeps our API key server-side, with a single-page HTML/JS frontend. The agent loop is five steps: agnes-2.0-flash resolves the vague need into a precise skill (returned as structured JSON), our code filters profiles to a shortlist, Agnes ranks and explains them in a senior-student voice, our code detects reciprocal trades deterministically, and Agnes writes the brokered intro message. For visuals, agnes-image-2.1-flash generates wordless collaboration cards and skill passports. For diagrams, we chained Agnes with the open-source Mermaid.js library, Agnes's text model decides what the diagram should contain, and Mermaid renders it accurately in the browser. We kept matching and trade-detection in code rather than the LLM so the core can't hallucinate people or fumble the key feature. We also generated our 30-profile seed dataset using Agnes, built from the real skill distribution in our survey.

Challenges we ran into

The biggest was the network: the venue and campus wifi actively reset the connection to Agnes's image host, so generated images failed to download or display. We solved it by having the backend download each image and serve it locally, with a pre-saved fallback, so the demo shows an image every time regardless of the network which is also exactly the pre-loading the organisers recommended. The second challenge was discovering the hard limits of text-to-image: it can't render legible text or accurate labelled diagrams. Our first attempts at a "problem diagram" and an image-to-image "before/after" both came back as gibberish. Rather than reach for another model, we rethought the approach, wordless illustrations where image generation shines, and Agnes-plus-Mermaid where we needed accuracy. We also wrestled with the usual hackathon plumbing: SSL certificate errors, getting reliable structured JSON out of the model, and a missing static-file mount that broke local image serving.

Accomplishments that we're proud of

We got a genuinely working agent loop running end to end on Agnes, resolve, match, trade detection, broker, and visuals which is further than a single demo screen. We're proudest of the reciprocity engine: detecting and proposing two-sided trades is the thing that makes Grapevine different from every "campus skill matcher," and it's grounded in real survey data showing 81% of students prefer learning via a trade. We're also proud of the Agnes-plus-Mermaid diagram, which turns a model limitation into a clean, accurate feature using open-source rather than another frontier model. And honestly, we're proud of what we cut: we tested features that didn't work and removed them instead of shipping something broken.

What we learned

We learned where generative models genuinely add value and where they don't, text and language tasks are where Agnes shines, and image generation is great for wordless, atmospheric visuals but unreliable for anything needing legible text or accurate structure. The biggest lesson was the value of the right tool for each job: keeping deterministic logic in code, using the LLM for judgment and language, and reaching for an open-source library when neither AI modality fit. We also learned that the hard part of a matching product isn't the matching, it's trust and incentive design, which is why reciprocity and evidence-grounding matter more than the algorithm. And on the practical side, we learned a lot about working around hostile networks and building demos that don't depend on a live connection to fail.

What's next for Grapevine

Three layers we designed for but haven't built. The learn-over-time layer matches students who are "currently learning X" with peers who want to teach it, turning one-off help into ongoing peer mentoring. The belong layer clusters people who "want to learn Y" into interest groups. And async knowledge capture would turn a great help session into a reusable clip, so one-time help scales to everyone stuck on the same thing. On the product side, the next step is real opt-in GitHub onboarding to replace seed data, and supply-side load-balancing so the most-requested people don't get overwhelmed. Our go-to-market follows naturally: start with one maker-heavy course, opt-in onboarding with no cold profiles, prove the loop with real matches, then grow by word of mouth fittingly, peer to peer.