Inspiration
When an engineer moves to another project or leaves a team, the next person often inherits the code without the context: which components matter, how a failure travels through the system, and what still needs to be verified.
DevRelay AI explores how AI can help preserve that context. The goal is not to let a model change software on its own. It is to give the receiving engineer a grounded investigation plan and a reviewable handoff.
What it does
DevRelay AI analyzes an authorized synthetic repository using bounded, read-only static analysis. For the Northstar incident in the demo, NVIDIA Nemotron, accessed through Nebius Token Factory, helps produce an investigation plan from selected source evidence.
The application validates the plan structure and checks its source citations against the analyzed files. It can then prepare a plan-only handoff for human review, including findings, evidence, and open questions.
The model’s plan is a recommendation. DevRelay does not apply or execute code, and runtime validation is reported as not run. Mock evaluations are separate from genuine Nemotron inference.
How we built it
The application uses a Python FastAPI backend and a React/Next.js frontend. Repository analysis is static and restricted to configured repository IDs. The inference layer supports a deterministic mock provider and an explicitly enabled Nebius provider for NVIDIA Nemotron.
Plans are checked against a structured schema and analyzed source references before they are returned. The handoff keeps recommendations, verified citations, assumptions, and human decisions distinct. Inference history records sanitized usage metadata and estimated cost when provider usage is available; it is not an account billing statement.
Challenges we ran into
Structured model output can be incomplete, malformed, or cite source locations that were not supplied as evidence. DevRelay therefore rejects truncated or invalid plans and reports unsupported citations instead of treating them as verified.
We also had to distinguish what static checks can establish from what requires executing tests. No trusted isolated executor is configured in this build, so runtime validation remains not_run; repository code is not run by the application.
Accomplishments we're proud of
We built a working engineering-handoff workflow around a realistic synthetic pipeline incident. It connects repository analysis, live Nemotron-assisted planning, citation checks, plan-only handoff, and human review while keeping code execution outside the workflow.
In a separately recorded live run, Nemotron returned a plan with five verified citations and no unsupported citations. The demo’s offline/mock evaluation is reported separately and is not presented as live model output.
What we learned
A useful engineering handoff needs more than a summary. It needs traceable evidence, visible uncertainty, and a clear next step for the receiving engineer.
We also learned that model output and verified repository facts must be presented separately. Human review remains essential, especially when a recommendation depends on a policy decision the source code cannot answer.
What's next
The current build focuses on read-only analysis and investigation handoff. Broader repository support, durable team-wide knowledge, and trusted isolated runtime validation are future work; they are not capabilities of this demo.
Built With
- ai-agents
- fastapi
- git
- github
- nebius-token-factory
- next.js
- nvidia-nemotron
- pytest
- python
- react
- typescript
