Inspiration

Imagine making a payment for something important, only to discover that you've been charged twice. Now imagine that the money taken from your account was the last money you had. Duplicate transactions are something many of us have experienced, and we know how frustrating they can be. Sometimes, getting your money back takes days, and while you're waiting, you may need that money for food, transportation, or other essential expenses. For us, this wasn't just a technical problem. It was a real-world frustration that made us wonder why these errors happen and what we could do to help prevent them. As software developers, we understand that even a small mistake in an application's code can have consequences for the people using it. A duplicate transaction, an incorrect refund, or a monetary precision error might look like a simple bug to a developer, but to the person affected, it can mean financial stress, inconvenience, and a loss of trust.

That's what inspired us to build RootCause AI. We wanted to explore how artificial intelligence could help developers identify and repair the underlying software errors that contribute to these problems. But we also asked ourselves an important question: What if AI could do more than suggest a fix? What if it could actually test whether that fix works? That question became the foundation of RootCause AI. By combining NVIDIA Nemotron, Nebius Token Factory, automated testing, and isolated Nebius Sandboxes, we built a prototype that investigates financial software bugs, generates proposed repairs, and verifies them through testing. Our goal is to help developers catch and correct errors before they affect more people. Because behind every failed transaction isn't just a line of broken code. There's a real person who may be depending on that money. To explore this idea, we decided to focus on financial software errors, particularly duplicate transactions, incorrect refunds, and monetary precision issues.

What it does

RootCause AI is an AI-powered debugging system that investigates financial software bugs, identifies their root causes, and generates proposed code repairs using NVIDIA Nemotron through Nebius Token Factory. Unlike tools that only suggest fixes, RootCause AI validates the generated patches and tests them in isolated Nebius Sandboxes to determine whether they actually resolve the problem. Our prototype demonstrates this across three financial debugging scenarios: duplicate transactions, incorrect refunds, and monetary precision errors, with all 18 tests passing after repair.

How we built it

We built RootCause AI using Python, NVIDIA Nemotron, Nebius Token Factory, Nebius Sandboxes, and Streamlit. We started by developing financial debugging scenarios and automated tests that would help us determine whether a proposed repair actually corrected the problem. Next, we integrated NVIDIA Nemotron through Nebius Token Factory to investigate bugs, identify potential root causes, and generate proposed Python code repairs. However, we didn't want our system to simply accept whatever code the model generated. We implemented structural patch validation to check proposed repairs before testing them. We also developed a feedback and retry mechanism so that when a proposed repair failed validation or verification, the agent could use that feedback to make another attempt. To verify repairs, we integrated Nebius Sandboxes, allowing us to execute automated tests in isolated environments and compare the original code with the repaired version. Finally, we built an interactive Streamlit dashboard that allows users to select debugging scenarios, follow the investigation process, examine proposed code changes, and review verification results.

Challenges we ran into

Building RootCause AI came with both technical and personal challenges.

Working Remotely Across Different Cities One of our biggest challenges was that we lived in different cities and had different schedules. There were times when one of us was available to work on the project while the other was busy with other responsibilities. This meant a lot of going back and forth, waiting for responses, coordinating tasks, and finding time when we could both work together. Sometimes, something that might have taken a few minutes to resolve in person required several messages or a scheduled call. To make things easier, we tried to hop on calls whenever possible, especially when we needed to troubleshoot problems, discuss technical decisions, or understand what the other person was working on. We also learned to communicate our progress clearly so that even when we couldn't work at the same time, the project could continue moving forward.
Building More Than an AI Code Generator

Making RootCause AI do more than generate a plausible-looking code fix. We needed to build a workflow that could investigate a bug, generate a proposed repair, validate the code, execute tests, and determine whether the repair was successful. Connecting these stages required careful debugging and testing. We also had to think about what should happen when the AI generated an invalid patch or when a proposed repair failed verification. This led us to implement structural validation and a feedback-driven retry mechanism.

Integrating NVIDIA Nemotron and Nebius Sandboxes Another challenge was connecting the different technologies into one functioning system. We needed NVIDIA Nemotron, accessed through Nebius Token Factory, to generate structured repair proposals that our Python application could process. We also needed to connect those proposals to our validation and sandbox verification workflow. Getting these components to communicate correctly required repeated testing, debugging, and adjustments.
Testing, Deployment, and Debugging Our Own Application Building a debugging tool also meant spending a lot of time debugging our own code. We encountered issues while testing the different financial scenarios, integrating backend components, and preparing the Streamlit dashboard. Even after getting the application working locally, deploying it and ensuring that others could access the demonstration introduced additional challenges. We worked through these issues by testing individual components, checking results, making changes, and trying again.

Accomplishments that we're proud of

One of our biggest accomplishments is building RootCause AI into a working autonomous debugging prototype that goes beyond identifying bugs or suggesting code fixes. We developed a system that investigates financial software errors, generates proposed repairs, validates those repairs, and independently verifies whether they work. We're particularly proud of successfully integrating NVIDIA Nemotron through Nebius Token Factory with Nebius Sandboxes to create an automated debugging and verification workflow. We also implemented a feedback mechanism that allows the agent to retry when a proposed repair fails validation or verification.

Another major milestone was successfully demonstrating RootCause AI across three financial debugging scenarios: duplicate transactions, incorrect refunds, and monetary precision errors. Across these scenarios, our system improved the test results from 10 passing tests to 18 out of 18 passing tests after repair.

We also built an interactive Streamlit dashboard that makes the debugging process transparent by displaying the AI's investigation, proposed code changes, verification results, and execution logs.

Finally, we're proud that we were able to bring these components together as a two-person team and deploy a working application that others can explore. Seeing RootCause AI move from an idea to a functioning system that generates and verifies real code repairs has been one of the most rewarding parts of this hackathon.

What we learned

Looking back, one of the most valuable parts of this hackathon wasn't just learning how to integrate AI models and sandbox environments. It was learning how to work together under imperfect circumstances. We learned that good communication matters just as much as technical ability, especially when you're collaborating remotely. We learned to ask for help, support each other, and stay flexible when things didn't go according to plan. And most importantly, we learned that building something meaningful doesn't require everything to go perfectly.

What's next for ROOT-CAUSE AI

Our long-term vision for RootCause AI is to build a developer tool that makes debugging financial software more reliable, transparent, and easier to verify. While our current prototype successfully demonstrates automated debugging and repair verification across three financial scenarios, we want to expand its capabilities and make it useful for real-world development teams.

Support More Applications and Bugs Currently, RootCause AI works with three predefined financial debugging scenarios: duplicate transactions, incorrect refunds, and monetary precision errors. Our next goal is to allow developers to upload their own Python calculation modules and test suites. Instead of being limited to our existing scenarios, RootCause AI could investigate bugs in different financial applications and generate repairs based on the code provided.
Make Our AI More Reliable Through Extensive Testing Although our prototype successfully verified repairs across all three scenarios, we recognize that real-world software contains more complex and unpredictable bugs. We plan to evaluate RootCause AI against a wider range of errors, including bugs in programs it has never encountered before. We also want to introduce mutation testing, where we deliberately insert errors into working code to evaluate whether our system can detect and repair them. By developing repeatable testing benchmarks, we can better measure how consistently RootCause AI performs and identify areas for improvement.
Give Developers More Control Over AI-Generated Repairs We want RootCause AI to work alongside developers rather than make changes without their oversight. In future versions, developers would be able to review and approve proposed repairs before applying them. We also plan to maintain version histories of generated patches and integrate RootCause AI into continuous integration (CI) pipelines. This would allow teams to incorporate automated debugging and verification into their existing software development workflows.
Strengthen Security and Prepare for Real-World Use Because RootCause AI works with financial software, security and accountability are especially important. We plan to introduce user authentication, stronger isolation between debugging sessions, usage limits, and detailed audit trails that record the actions taken during each investigation and repair. These improvements would help make the system safer, more accountable, and better suited for use in professional development environments.

Our Bigger Vision We want RootCause AI to become more than an AI tool that suggests code fixes. We envision a system that helps developers understand why software fails, evaluates possible solutions, and provides clear evidence that a repair works. Our goal is to make AI-assisted debugging more explainable, testable, and trustworthy.