Inspiration
We started from the Brevan Howard problem statement, but the conversations we had with the sponsor independently influenced us to focus on building a research agent who's outputs and ideas could be trusted. The hypotheses an AI researcher generates often doesn't make sense when further examined, and when they do, the tests chosen can be unsuitable. We wanted an AI researcher whose ideas, and the way it tests them, hold up to being scrutinised.
What it does
The AI researcher takes a "why" question about NBA games, such as "Why do home teams win by more points than away teams?", and carries it through to a conclusion. It first checks whether the question/premise is valid based on the phenomena of the dataset. It then proposes ideas as to why that premise is true, and tests each one against nearly two decades of game results and closing betting odds. Every hypothesis gets a verdict, which seperates fact from chance, backed by a trail of evidence. The whole investigation appears as a live graph, so you can see what the agent tried and why it tried it.
Our AI researcher can take a "why" question about NBA games. For example, "Why do home teams win by more points than away teams?"
First, it determines whether or not the dataset is sufficient for answering your question. After generating a few methods for forming an answer, and acquiring statistics for the answer, it tests itself against $\approx$ two decades of game results & closing betting odds. For every explanation, it gives a verdict. This could be that the result is just down to luck, that there is a real pattern but bookmakers have already accounted for it, or that there is a pattern that the betting market has not fully recognised.
It can then show the entire investigation as a live graph, so you can follow what the AI is testing, what it finds and how it reaches its final conclusion.
How we built it
To reduce our scope, and add some personal investment, we built our researcher agent around a basketball dataset, which combined both game data and betting data.
Since we also wanted to build trust in the output, we used LangGraph to implement a suite of statistical confidence tools that critique & inform our agent's sub-steps. These include and aren't limited to: quantifying uncertainty, significance and market uncertainty (a.k.a odds). By using these tools to decide on a final verdict, we remove LLM bias from our findings, and increase defensibility, and provide room for improvement in tooling.
To drive research we used the Gemini API; it pre-registers each test before running it, explores ideas based on tool output, and is reviewed by a supervisor and judge. These encourage the Gemini driver to seek out new ideas, and prevent reward-hacking.
To share our tool, we developed a FastAPI backend which streams events over WebSockets to a React Flow harness, which renders our reasoning graph, node inspection and final report. Finally, we deployed the application to the web using Railway.
Challenges we ran into
Running an investigation from question to conclusion takes many LLM calls, so we had to cut token use and keep each step's context small without losing what the agent needed to reason well. Refining the tool suite was just as hard. The tools had to be flexible enough for the agent to explore, but strict enough that the output stays defensible. That meant enforcing pre-registration, sealing the holdout, and counting every exploratory test toward multiple-testing correction. Additionally, when we initially made our tools, we found that our agent would attempt p-hacking where it would occasionally pick the tool that gave the best looking metric, rather than the most appropriate metric for the scenario.
Accomplishments that we're proud of
We built a complete working product from raw data to a live research graph. We're especially proud that the system can tell a real effect from one that only looks real. For example, it finds that teams on a back-to-back lose by about three points more, but that betting markets already price this in, so there is no edge to exploit. The gate, not the model, makes that call, and a sealed holdout keeps it honest.
What we learned
We learned a lot about DevOps and about building a clean real-time UI with React Flow and WebSockets. We learned how to use LangGraph for agent orchestration, and more broadly how to design a system that lets an agent act autonomously while staying grounded in rules it can't override. We also learned how to manage project scope and avoid scope creep under hackathon time pressure.
What's next for Ball Knowledge
We want to let the agent write its own tools in a sandbox, so it can analyse the data in ways our fixed tool suite doesn't anticipate. We also want a stronger tool suite, such as models trained on similar data. We could also make human-in-the-loop control more flexible, so users can redirect the agent mid-investigation. Furthermore, we'd like to make the system dataset-agnostic, letting it pick a suitable dataset (from Kaggle, for example) for any question, and to make runs persistent so an investigation can be resumed where it left off.