Inspiration
Software can remain unchanged and still become wrong.
APIs evolve, SDK contracts drift, and provider behavior changes outside a repository. Teams often discover that change only after production breaks. We built Refresh to reverse that pattern: start with current external evidence, understand what changed, and prove a safe repair before adoption.
What it does
Refresh is an evidence-first maintenance agent for API- and SDK-heavy systems.
It follows five accountable steps:
- Detect — identifies external contract drift.
- Research — uses Tavily to retrieve current, authoritative documentation.
- Repair — uses NVIDIA Nemotron through Nebius Token Factory to propose a tightly bounded change.
- Prove — reproduces the defect against an unchanged baseline, then evaluates the candidate in a disposable workspace.
- Decide — checks behavior and execution controls before recommending adoption or human review.
Every important claim leaves a receipt: source URLs, content hashes, provider request IDs, model identity, token usage, patch hash, test results, and the final decision.
Try the live Refresh experience
View the public MIT-licensed repository
How we built it
Refresh is implemented in Python with strict typed contracts and a dependency-free health and report API.
Tavily Search and Extract retrieve current provider documentation and preserve both successful and failed extraction results. The evidence is converted into a narrow, source-linked behavioral claim and regression check.
NVIDIA Nemotron 3 Nano, running through Nebius Token Factory, receives the official evidence, affected adapter, and a bounded repair contract. Its output is treated as untrusted until it passes validation and behavior testing.
The evaluator uses:
- An immutable baseline
- A disposable candidate workspace
- Allow-listed file boundaries
- Structured subprocess commands
- Restricted Python syntax
- Stripped provider credentials
- Original and source-linked regression checks
- Fail-closed safety decisions
The public experience is deployed independently through GitLab CI/CD and GitLab Pages. We also built the submission video with Remotion, using the sanitized evidence from a verified live run.
Challenges we ran into
The hardest problem was not generating a patch. It was proving that the patch understood the external change.
Our demonstration uses Tavily Extract's mixed-result contract: a response can contain successful results and failed URLs simultaneously. The seeded adapter interpreted HTTP 200 as complete success and silently discarded the failed URL.
We also had to separate three different kinds of confidence:
- A model believes a repair is correct.
- Tests demonstrate that behavior improved.
- Infrastructure controls demonstrate that execution was sufficiently isolated.
Refresh refuses to collapse these into one green indicator. In our verified run, every behavioral check passed, but host-level network isolation remained unproven. The system therefore returned needs_review instead of overstating safety.
Accomplishments that we're proud of
- Completed a genuine Tavily Search and Extract run with recorded request identities
- Ran NVIDIA Nemotron through Nebius Token Factory with recorded model and completion evidence
- Reproduced the defect against an unchanged baseline
- Generated a bounded, one-file repair
- Preserved all original behavior while passing the new source-linked regression check
- Recorded
1,499model tokens and an estimated model cost of$0.00015762 - Preserved the patch SHA-256 and complete experiment outcome
- Built a public, MIT-licensed repository with visible GitLab pipeline history
- Deployed an interactive judge-facing experience through GitLab Pages
- Kept the final recommendation honest: repair proved, human review required
What we learned
The future of software maintenance is not simply more autonomous code generation. It is better-grounded autonomy.
A useful maintenance agent needs to show:
- What changed
- Which source supports that conclusion
- How the source became a behavioral check
- What code was changed
- Which behavior was preserved
- What remains unproven
- Why a human should—or should not—approve the result
We also learned that model confidence is not behavioral proof. The most valuable agent is not the one that changes the most code; it is the one that reduces uncertainty while preserving human control.
What's next for Refresh
Next, we want to expand Refresh from a focused contract-repair slice into a continuous maintenance system that can:
- Monitor approved documentation and changelog sources
- Prioritize drift by repository impact
- Support more API and SDK ecosystems
- Run candidates inside fully network-isolated sandboxes
- Open evidence-rich merge requests for human review
- Track recurring provider changes over time
- Measure avoided incidents and maintenance effort
- Learn organization-specific adoption policies without weakening safety gates
Our long-term vision is simple:
Most coding agents start with a prompt. Refresh starts with evidence that the world changed.
Log in or sign up for Devpost to join the conversation.