Graph used right & built fast: Neo4j at HackwithBay 3.0

AWS Builder Loft, San Francisco · July 7, 2026 · Theme: “Thoughtful Agents for Productivity”

Last Tuesday, roughly 200 builders packed into the AWS Builder Loft on Market Street for HackwithBay 3.0, presented by Devnovate. Less than five hours of build time, ~50 submissions, one theme — thoughtful agents for productivity — and a partner stack that Neo4j was proud to be part of alongside RocketRide, Butterbase, Daytona, Nebius, and Opsera.

A graph database was in the required toolset, so everyone used one. That makes the interesting question not whether the winners used a graph, but how well — and all three top teams did something genuinely smart with it. None treated Neo4j as a bucket to dump nodes into; each made the graph the part of the system the agent could be trusted with — a typed, constrained, queryable source of truth — and used its structure to keep an autonomous agent honest.

There’s a second thread worth pulling. Every one of these teams built with coding agents against the clock, so the graph had to be something an agent could stand up, model, and reason over in an afternoon. That’s where the stack paid off: Neo4j Aura’s managed instances (reachable over both the driver and the HTTP Query API v2), Butterbase’s MCP-native functions, and RocketRide’s portable .pipe pipelines meant a coding agent could wire graph + agent pipeline + sandbox together with almost no glue code. Ease of integration wasn’t a nice-to-have here — under that clock, it was the whole game.

Here’s what the top three built, and how each one used the graph well.

🥇 First Place — VeriGraph

Team: Ali Amjad · Siddharth Reddy · Dileep Kumar Sharma · Sanmukh Sain Karri

🔗 Live demo · GitHub

Turn research papers into executable evidence. Most paper tools stop at a summary or a code stub. VeriGraph closes the whole loop: paste an arXiv link, and it extracts the paper’s claims and methods into a knowledge graph, shows you where papers contradict each other (the dashed amber edges above), then lets you press ▶ RUN on any method — it writes the experiment code, executes it in an isolated Daytona sandbox, and writes the outcome back into the graph as a VALIDATES (green) or REFUTES (red) verdict with the exact measured metrics attached.

The flagship demo reproduces a surprising 2017 result (Wilson et al.): Adam, the optimizer most people default to for training models, can actually generalize worse than plain gradient descent. VeriGraph runs both live on the paper’s test case — gradient descent gets 0% of examples wrong, Adam about 43% — and writes that verdict into the graph as evidence.

The smart bit: verdicts are edges, not fields. A Run node connects to the claims it tested with VALIDATES / REFUTES relationships whose values are computed from measured metrics against explicit thresholds — the model literally cannot write a verdict the numbers don’t support. Only deterministic Python (curator.py, graph.py) ever writes to Neo4j; the agent reads via natural-language-to-Cypher but never writes. Node IDs are stable, human-readable slugs (wilson2017-c2, run-wilson2017-m1–20260707T…) so the agent can cite exact evidence, and because the Aura instance was shared, deletes are scoped to the project’s own labels. Idempotent MERGE throughout keeps the whole loop safe to re-run mid-demo.

How the stack fit together:

• Neo4j Aura is the memory — every paper, claim, conflict, run, and verdict is a node or edge, and only deterministic Python writes evidence, so the graph stays trustworthy.
• RocketRide powers the research agent: ask “which claims now have executable evidence?” and it translates the question to Cypher and answers with real run IDs and exact numbers.
• Butterbase serves every LLM call through one AI gateway (no OpenAI key in the project) and hosts the deploy.
• Daytona runs every generated experiment in a fresh, isolated sandbox.

“Butterbase enabled fast backend + frontend deploy, RocketRide powered our multi-step agent pipeline, and Neo4j stores verifiable evidence graphs. VeriGraph turns research papers into executable, inspectable result chains for scientists.”

🥈 Second Place — Constructor

Team: Ramis Hasanli · Sid · Rohan Chavan · Logan Rud

🔗 Live demo · GitHub

A live knowledge graph for semiconductor research. Hardware researchers evaluating edge-AI accelerator techniques — quantization, sparsity, weight streaming — drown in scattered papers and one-off scripts. Constructor is an autonomous research assistant that scouts sources, runs real experiments, and grows a live Neo4j graph on its own. You set the goal — “find promising techniques for improving TOPS/W under thermal and memory constraints” — and watch the agents work.

Two buttons drive it. Scout ingests sources into the graph node by node, so you literally watch it grow. Analyze pulls every technique’s tradeoffs out of the graph, spins up an isolated Daytona sandbox per technique to run a real Monte-Carlo simulation, computes the Pareto frontier, and writes a new experiment run back into the graph — kept as history, never overwritten, so you can watch the frontier shift as evidence accumulates.

The smart bit: the graph is treated as an append-only ledger, not app state. Every Analyze run writes a fresh ExperimentRun/ResultArtifact instead of mutating the last, so the graph becomes a time series you can watch the Pareto frontier move across. The schema is fully typed — Technique, Metric, Finding, Source joined by semantic edges like IMPROVES/HURTS/TESTS/PRODUCES — and every Scout tick is an idempotent MERGE, so re-running ingest is a harmless no-op once the source pool is exhausted. The frontend never touches the database directly: Butterbase serverless functions — deployed and managed over MCP — are the only surface, talking to Aura through its HTTP Query API v2, with RocketRide orchestrating the Scout→Daytona→write-back hop.

How the stack fit together:

• Neo4j is the single source of truth — Technique, Metric, Finding, Source, and ExperimentRun nodes. Every Scout tick and Analyze run is a real Cypher write; nothing on screen is faked.
• Butterbase is the backbone — serverless functions are the only surface the frontend talks to, and they host the deployed app.
• Daytona is where the real computation happens — one isolated sandbox per technique, actual Monte-Carlo, not a lookup table.
• RocketRide is the orchestrator between Scout and Analyst, turning “click a button” into a real multi-step agent pipeline.

“Most agent demos show a chatbot bolted onto a UI. Constructor’s agents write to a real graph and trigger real computation… the graph you watch grow is the same graph the next analysis reads from.”

🥉 Third Place — The Ultra Super Social Passport

Team: Johnny Sheng · Teri Shim

🔗 Live demo · GitHub

Sign up to a party, and a passport writes itself. Built for a real 193-guest LA creatives’ party, this one leans on the graph in the most human way possible — it connects people, not tags. Everyone fills a Luma-style form with one extra question (“what do you think it means to be creative?”) and gets back a personalized passport: the two people they’d click with tonight (one who shares their work, one who shares their values), each with a receipted reason, a hidden scavenger prompt, a “magic inference” about something they never typed, and a gradient generated from who they are. The AI is deliberately invisible — no chatbot, just a gift that happens to know things.

The smart bit: this is the graph at its most human. The app runs community detection to group all 193 guests into six “value clouds” from what they believe and care about, then does live graph traversal to write each passport — variable-length Cypher paths that walk from a person, through shared interests and experiences, to the two people they’d most click with tonight: one who shares their work, one who shares their values.

How the stack fit together:

• Neo4j Aura is the relational layer — a graph of Person→Person edges the app actively traverses with variable-length Cypher to connect people through shared interests and experiences, plus community detection into six value clouds. Not a key-value store.
• RocketRide hosts the deployed inference pipeline the app calls for its “magic inference.”
• Butterbase is the backend, the OpenAI-compatible AI gateway (every LLM and embedding call), and the deploy target.

“The two people you’d click with tonight — one who shares your work, one who shares your values — and one thing it somehow knew about you.”

Three ways to reach Aura

Here’s a detail we loved: across just three apps, the teams connected to the same Neo4j Aura in three genuinely different ways — each the right tool for where the code runs.

• The Bolt driver (neo4j+s://, routing-aware) — the official Neo4j drivers, used wherever there’s a real server process. VeriGraph’s Python FastAPI backend (GraphDatabase.driver(…)) and the Passport’s Node app (neo4j.driver(…).executeQuery(…)) both talk to Aura this way.
• The HTTP Query API v2 (POST /db/<db>/query/v2, Basic auth) — a plain fetch with a {statement, parameters} body, for edge/serverless runtimes where the Bolt driver’s native dependencies can’t load. Constructor’s entire backend is Butterbase Deno-edge functions, so every one of them reaches Aura this way.
• RocketRide’s db_neo4j provider — RocketRide’s built-in Neo4j component, wired straight into the agent pipeline as a natural-language→Cypher tool. VeriGraph is the one that showcases this — and it did it the right way: the component is configured read-only (allow_execute: false), so the conversational agent can query the graph and cite exact evidence, but can never write an unverified verdict back. Writes stay on the deterministic code path.

Same database, three access patterns, chosen by runtime and role. That flexibility — a driver, a REST-style HTTP API, and a first-class pipeline component — is a big part of why coding agents could wire these apps up so fast.

They built winners with graph — fast

Three very different products — a scientific evidence engine, a hardware research assistant, and a party icebreaker — built on Neo4j Aura in less than five hours, with coding agents — which is the other half of the story. A managed Aura instance, an HTTP Query API and driver an agent already knows how to drive, MCP-native backend functions, and portable pipeline definitions meant the integration surface nearly disappeared. The teams spent their hours on modeling and product, not plumbing.

Huge congratulations to all three teams, and thank you to Devnovate, the AWS Builder Loft, and our fellow partners for a fantastic day. To the ~50 teams who shipped at AI speed, we’ll see you at the next one.

Want to build your own graph-backed agent fast? Spin up a free Neo4j Aura instance and start connecting the dots.

Screenshots captured from the teams’ live deployed demos. Team member names sourced from the official HackwithBay 3.0 submissions.

---

Graph used right & built fast: Neo4j at HackwithBay 3.0 was originally published in Neo4j Developer Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.