How I won Best Developer Tool at Cornell's AI Hackathon

Most security tools stop at the scary part. They hand you a list of vulnerabilities, a severity score, and a link to a CVE, and then the actual work, understanding the bug, writing the fix, opening the PR, still lands on a human at 5pm on a Friday.

Dispatch doesn't stop there. It finds the vulnerability, files it, writes the patch, and opens a pull request you can review and merge. We built it in 36 hours at the Cornell AI Hackathon in NYC, where it won Best Developer Tool.

More: GitHub repo · Pitch and demo

Give Dispatch a repo. It reads the code, attacks the running app, files the issue, and writes the fix PR, with a concrete artifact at every stage.

The whole loop, not half of it

The pitch is one sentence: find → report → fix → PR, with a chat interface on top.

• Find. An agentic scanner explores a target application and surfaces real vulnerabilities, not just a lint report of theoretical ones.
• Report. Each finding becomes a Linear issue with context, so it lands in the tracker your team already lives in instead of a PDF nobody opens.
• Fix. For each finding, an agent writes an actual patch and opens a ready-to-merge GitHub PR. This is the step everyone else skips, and it's the one that turns a scanner into a tool.
• Ask. A Slackbot triggers scans on demand and answers RAG queries over past findings, so a teammate can ask "have we seen this before?" and get a real answer instead of grepping old tickets.

The insight the whole thing is built around: a vulnerability report is a to-do item, but a pull request is a decision. Turning the first into the second is where the leverage is.

Every scan still produces a full report (risk score, severity breakdown, endpoint coverage), but the report is the to-do. The PR is the part that actually closes it.

Architecture

Under the hood it's a small fleet of agents, not one big prompt:

• Mastra + OpenRouter for multi-agent coordination and model routing. Different steps in the pipeline want different models, and OpenRouter lets us pick per-step without rewiring anything.
• Blaxel sandboxes for execution. You do not want an agent that pokes at vulnerabilities and runs generated code doing that on your own machine. Every scan and every candidate fix runs in an isolated, disposable sandbox.
• Datadog middleware that ingests live application logs, detects anomalies, and kicks off worker diagnostics automatically. This is what makes Dispatch reactive: a spike in the logs can start a scan on its own, no human trigger required.
• Linear + GitHub APIs to close the loop into the tools a team actually ships from.

The sandboxing decision shaped everything. Once you accept that the agent has to run untrusted, self-generated code to verify a finding and test a patch, isolation stops being a nice-to-have and becomes the substrate the rest of the system sits on.

Why closing the loop is the hard part

Anyone can wire an LLM to a scanner and print findings. The moment you commit to opening a mergeable PR, the bar jumps:

• The fix has to actually apply against the real repo, not a hallucinated version of it.
• It has to be scoped to the vulnerability and not casually rewrite half the file.
• It has to survive a human reading it, because a PR nobody trusts is worse than no PR at all.

That constraint, "would a maintainer actually merge this?", is a much sharper spec than "is this output plausible?" It forces the whole pipeline to be grounded in the real codebase at every step, which is exactly the discipline you want in a security tool.

Takeaway

The demo that won wasn't the scanner. Scanners are a solved, commoditized thing. What landed was watching a vulnerability go from "discovered" to "here's a PR that fixes it" without a human in the middle, and knowing that every step ran sandboxed so the tool couldn't hurt the thing it was protecting.

Agentic tooling gets interesting the moment it stops producing reports and starts producing changes you can accept or reject. A report asks you to do more work. A pull request asks you to make a decision. Dispatch is a bet that the second one is what developer tools should be aiming for.

Credits

Dispatch was built at the Cornell AI Hackathon NYC 2026 by Arsh Singh, Mateo del Rio Lanse, Diya Sheth, and Jimmy Mulosmani. The code is on GitHub.