Inspiration

Debugging is one of the most time-consuming parts of software development. A single error can lead to hours of searching through documentation, examining stack traces, and repeatedly changing code without knowing whether the fix will work.

We wanted to explore a better approach: what if an AI assistant could do more than explain an error? What if it could analyze the problem, propose a fix, run tests, learn from failed attempts, and provide evidence that its solution works?

That idea inspired NviTech, an AI-powered debugging and code-repair agent designed to help developers spend less time chasing bugs and more time building useful software.

What We Learned

This project explores the difference between a conventional AI coding assistant and an agent that follows a structured problem-solving workflow.

We aim to learn how to integrate NVIDIA open-source language models with Nebius infrastructure, design multi-step AI workflows, generate structured code changes, and evaluate those changes through automated testing.

We also recognize that generating code is only one part of reliable software development. A useful AI repair system must handle unsuccessful attempts, avoid claiming that untested code works, and provide clear evidence for its recommendations.

How We Built It

NviTech is designed as a Python-based web application with an interactive interface for submitting code, error messages, and test instructions.

The application uses an NVIDIA Nemotron model accessed through Nebius Token Factory to analyze errors and generate proposed code repairs.

Its workflow consists of several stages:

Analyze: Examine the supplied code, traceback, and relevant context to identify the likely root cause.
Plan: Develop a repair strategy and determine which parts of the code need modification.
Generate: Produce a minimal patch with an explanation of the proposed changes.
Test: Execute the relevant tests in a restricted environment and capture their results.
Iterate: If tests fail, feed the failure information back into the repair workflow for a limited number of additional attempts.
Report: Present the proposed patch, test outcomes, reasoning, and remaining issues to the developer.

The interface is intended to make the entire process transparent, allowing developers to inspect the changes before deciding whether to use them.

Nebius Token Factory provides the model inference component, while the Python application coordinates the repair workflow and testing process.

Challenges We Faced

A central engineering challenge in this project is making AI-generated code dependable. A patch can look correct while introducing new errors or failing to address the original problem.

Another challenge is building a useful feedback loop between the AI model and the test runner. Test failures must be captured and interpreted correctly so that subsequent attempts address the actual issue rather than repeatedly generating similar code.

Safe code execution is also important. Since user-submitted code can contain destructive operations, the test runner needs appropriate isolation, resource limits, and restrictions on access to the host system.

Our approach is to combine constrained code generation, automated tests, bounded retry attempts, and transparent reporting. These mechanisms are intended to make the system more reliable and easier to evaluate.

What's Next

We plan to expand NviTech to support multi-file projects, repository-level analysis, regression testing, and more detailed repair reports.

Future versions could also compare different repair strategies, track recurring failure patterns, and help developers understand why a particular change succeeds or fails.

Our broader goal is to explore how AI agents can become practical engineering partners—not simply generating code, but testing their work and communicating the limits of their results.

NviTech represents our effort to bring reasoning, automated validation, and transparent AI-assisted development together in one workflow.