Rung: AI Task Routing Planner

Inspiration

When planning software with AI coding agents, not every task needs the same level of reasoning. A small, contained change and a feature spanning several connected parts of an app can call for different capabilities. I wanted to make those choices easier to inspect and adjust, rather than sending every task down the same path.

What it does

Rung turns a Markdown product requirements document into a reviewable AI task-routing plan. It extracts up to 20 task candidates locally, so builders can edit, add, or remove tasks before analysis.

When the builder starts live analysis, Rung sends only the reviewed task IDs, titles, and descriptions to its configured provider. It recommends a Light, Standard, or Frontier capability tier for each task, with effort, confidence, score breakdowns, and a rationale. Deterministic review flags highlight uncertain or complex recommendations without silently changing them.

Builders can override a recommendation and export the plan as Markdown. The original AI recommendation remains visible alongside the chosen tier.

Rung is a planning tool; it does not execute coding tasks or check which models are available inside a coding editor. It does not promise savings. Cost estimates remain unavailable until verified prices and assumptions are configured.

How I built it

I used the Devpost Learn Skill Pack to narrow the idea into a route-only proof of concept, then created scope.md, prd.md, and spec.md to guide the implementation.

Rung is built with Next.js, React, and TypeScript. Markdown task extraction happens in the browser. Live analysis runs through a server-side API that uses OpenRouter when configured, with NVIDIA NIM as a fallback. Provider output is requested in a structured format and validated before recommendations are shown. API keys stay server-side, and Rung does not save PRDs or require an account.

Challenges we ran into

The main challenge was making recommendations inspectable and safe to act on. A tier label by itself is not enough, so Rung also shows confidence, effort, scores, rationale, and review flags. The server checks that the provider returns a valid decision for every submitted task; incomplete or malformed responses produce an error instead of fabricated routes.

Cost claims were another challenge. Prices and token usage can vary, so Rung shows costs only when its model prices and assumptions have reliable sources. Otherwise, the estimate is clearly unavailable.

Accomplishments we’re proud of

Rung supports an end-to-end flow: paste or upload a PRD, review the extracted tasks, analyze them with a configured AI provider, inspect or override the recommendations, and export a Markdown routing plan.

The final plan preserves both the AI recommendation and the builder’s choice, keeping the workflow useful while leaving control with the human.

What we learned

The Devpost Learn Skill Pack’s planning steps helped turn a broad AI-agent idea into a smaller project with a clear boundary. Writing the scope, PRD, and spec first made it easier to decide what belonged in the proof of concept and what should wait.

We also learned that AI-assisted planning needs validation and honest limits: explain why a recommendation was made, make uncertainty visible, and avoid claiming cost savings without evidence.

What’s next

Next, we’d like to evaluate recommendations against more real PRDs, add sourced model-price profiles, and explore integrations that can make model availability easier to verify. Any future routing or coding-agent execution would remain optional and under the builder’s control.

Built With

• next.js
• nvidia-nim
• openrouter
• react
• typescript