Inspiration

Most production software is old, and the hard part of modernizing it is not generating a new service, it is knowing what you are allowed to cut, in what order, and what security boundary you just destroyed.

Medicare-scale claims systems, mainframe CICS regions, and decade-old Java forums all share the same shape: a dependency graph of programs, copybooks, transactions, screens, batch jobs, controllers, and auth gates. Teams still “modernize” that graph by chatting with a model over a zip. The model invents a plan that would fit any codebase, then the cutover fails because step 18 ran before the copybook it still shares was wrapped.

I built Fever because legacy modernization is graph surgery. A chatbot makes a plan that fits any repo ("respect dependency order") and cannot say which edge is real, which step is illegal, or which security boundary disappears when that program becomes REST.

What it does

Upload a legacy codebase. Fever emits typed edges — COPY, CALL, LINK, XCTL, FILE, JOB, TRANS, SCREEN, plus controllers, interceptors, and persistence — and draws them in 3D.

Every claim is labeled. Measured is a parser hit or a logged Nemotron call with file:line. Predicted is a projection (illegal order, post-migration risk). Candidate is dead code I refuse to call live.

  • Plan. Name a target (Quarkus, Spring, ASP.NET + Azure SQL, or anything you type). Nemotron searches the web for that stack, then rewrites each wave: title, why, vuln, and a coding-agent prompt. Steps are graph edits with requires / unblocks, not prose.
  • Play. Coordinator, Analyst, and Prover run on the step. A legal cut retires nodes and edges on the canvas. An illegal one is rejected and names the missing step.
  • What-if. "Step 18 before 3" fails closed and flashes the edges that would break.
  • Cyber horizon. Orange: a transaction or controller becomes REST with no authz gate. Purple: a FILE/JOB path goes real-time with no TLS. Citations follow the source language, so a Java repo never gets mainframe docs.
  • Ask. Graph tools scope the edges first. Nemotron Omni reads the canvas only when the question is visual (colors, clusters, Play glow).

How I built it

Next.js and React Three Fiber on the front, FastAPI on the back, SQLite for the Nemotron cache and call trace.

Parsers run first and stay deterministic. Nemotron never invents an edge. It only rewrites, judges, scopes, explains, and looks. One gateway sends every role to Nemotron, caches the reply, and logs role, model, host, tokens, and latency. A role is only assigned a model after that host has actually answered a normal completion, a JSON object, and a tool call.

Why Nemotron. A migration is not one prompt. It needs structured steps a prover can reject, tools against a real graph, and a vision model that can see the canvas. Nano does the text seats. Omni does the picture. Same family, so I did not split the swarm across vendors.

repo
  → parser
  → measured graph
  → Plan:    web research → Nemotron planner (5 steps at a time) → waves with prerequisites
  → Play:    coordinator → analyst → prover → retire edges  or  reject and name the missing step
  → What-if: reorder → prover → flash the edges that break
  → Ask:     graph tools → Nemotron answer
             canvas capture → Omni, only if the question is about colors / clusters / glow
  → Cite:    fetch the doc page → quote a passage (OWASP, Spring, Quarkus, ASP.NET, Azure SQL)

Tools run before the model writes. The planner gets live docs for the stack you named. The prover only accepts a real file:line. Ask resolves "API related" to measured edges before the sentence. Omni is not allowed to override that. Generic filler ("respect dependency order") is thrown out and replaced with a cited page.

Why Vultr. Those seats fire together: several planner chunks, then coordinator + analyst + prover, while Ask can land in the middle. One NVIDIA key turns that burst into a queue, and the wait stops being the model. Vultr's GPU endpoint runs the same Nemotron prompts for the parallel seats. NVIDIA keeps Omni (the vision call) and is the fallback. Same prompt, second pipe, so hosting is not what the demo waits on.

probe host (completion + JSON + tool call must succeed)
  → gateway
      → NVIDIA:  Omni vision, fallback text
      → Vultr:   planner chunks, Play loops, mappers   (same prompt, GPU fan-out)
  → bench: same ping at 1, 2, 4, 8 threads
           new cache key every call, so a hit cannot look like a speedup
  → workflow page: wall time, calls/sec, threads used vs capacity

Challenges I ran into

Nemotron described a Java repo as a CICS region and linked a COBOL sample README, because the first risk copy was written for mainframes. Fix was a hard filter: sources and sentences must match the source language. Prompting it to "be careful" did not stick.

Switching Quarkus to .NET reused the old step titles until I wiped the previous plan and required every new title to name the stack just picked.

Ask, answered from the screenshot alone, returned a one-node cluster called api. Scope now has to touch the measured graph before Nemotron writes the sentence.

Accomplishments that I'm proud of

The swarm can refuse a cut. Play only retires the graph when the order is legal. What-if shows the fault when it is not. That is an agent executing a task, not a model describing one.

Parsers own the topology. Nemotron plans, proves, scopes, explains, and sees, with a trace per call. Vultr is why those calls run side by side, and the concurrency chart is the evidence. The same loop runs on whatever legacy tree you upload.

What I learned

The model is useful only after you decide which claims it is forbidden to make. Inventing an edge, answering from a screenshot, and reusing the last plan all looked like good Nemotron output. The product got simpler once those were out of bounds: parsers own what is true now, agents own what happens after the cut, and every sentence on screen has to say which one it is.

What's next for fever

  • Land a Play step's coding-agent prompt as a real patch and re-parse the diff, so the graph updates from the code, not only from the planned cut.
  • Save the Vultr-versus-NVIDIA concurrency run as a fixture, so "hosting is not the bottleneck" is a chart to analyze the computational cost.

Built With

Share this project:

Updates

Submission history