Intent

• 

  Build what you mean. Turn a rough idea into a clear build brief.

• 

  Start with your words. Describe what you want to make.

• 

  Resolve what matters. Answer focused questions that turn ambiguity into decisions.

• 

  Keep every requirement grounded. Trace decisions back to your exact words.

• 

  Define the boundaries. Make the core flow, exclusions, and success criteria explicit.

• 

  Confirm the understanding. Review and approve the brief before moving forward.

• 

  Take your brief with you. Export source-linked instructions for a coding agent.

• 

  See the connected plan. Explore how your vision, architecture, and work packages fit together.

• 

  Shape your project notes. Edit Markdown alongside the connected graph.

• 

  Purposeful model routing. Nemotron models handle extraction, review, and brief compilation through Nebius Token Factory.

• 

  See a live clarification. A recorded Nano/Super turn asks for the next missing detail.

• 

  Explore the example. A labeled, prebuilt habit tracker illustrates the handoff preview.

Inspiration

Coding agents build what you type, and what you type is rarely what you mean. Vague words and unmade decisions get filled in silently, and you find out after the build. I wanted a tool that treats clarity as something you can measure, and that won't hand work to an agent until the intent holds up.

What it does

Intent turns a rough software idea into an approved plan a coding agent can build from. It asks one build-changing question at a time and proposes drafts you can accept or edit, so you don't need to be an expert. Every requirement traces to an exact quote from you.

Six North Star fields must each pass a rubric, and two independent readers must agree on what the text means (Krippendorff's alpha ≥ 0.80). Decisions come from where candidate builds diverge. You approve concrete scenarios, then Intent generates a phased plan, an interactive project graph and a hashed instruction bundle. Codex or Claude Code workers can run from that bundle.

How we built it

• Stack: FastAPI and Pydantic backend, Next.js and React frontend, SQLite storage.
• Models: all inference runs on three Nemotron tiers through Nebius Token Factory. Nano handles high-volume narrow passes, Super handles critics and planning, and Ultra compiles the brief.
• Control: models only return validated deltas. The application owns IDs, source checks, budget limits and the readiness gate, and a failed pass keeps the gate closed.
• Pace: 195 commits in 5 days, with 853 backend tests passing and evals that cap live spend.

Challenges we ran into

• Structured planning: all 8 live planning attempts failed validation or hit a provider error, each in a different way. These included missed requirements, a wrong phase reference, and a repair that fixed two fields but duplicated a task block.
• Thinking and token limits: Nano's reasoning counts against the output limit, so calls hit 4096 tokens, once with no usable output. Raising the limit to 8192 then caused timeouts, so those calls got 120 seconds.
• Thinking tradeoff: turning thinking off cut a rubric pass from about 23s to 7s, but the judge then wrongly rejected "I" as a named user in 3 of 3 runs.
• Disappearing text: North Star fields were re-extracted every round, so answers moved between fields or vanished. Fields now persist.

Accomplishments that we're proud of

• The gates held. Eight failed attempts never became a fake plan, and all history and spend stayed on record.
• Reader agreement produced real signal in live runs, with alpha ranging from 0.0 to 1.0 per field.
• Ultra compiled a live brief on its first call, and Super's verification found nothing rejected or missing.
• Worker runs on Windows are sandboxed with an allowlist and no network.

What we learned

Valid JSON proves very little. Offline tests prove the protocol works, not that the model is good, and I learned to label those separately. Fixing the latest failure repeatedly was also a trap: I had to walk every later acceptance check, and move those checks inside the repair loop.

What's next for Intent

Getting a full live session through the gate comes first, then a complete live plan, then a real plan run through coding agents. That means live-testing constrained field repair, using smaller per-field calls, and adding overload retries for clarity and critic passes.

Built With

• claude-code
• codex-cli
• d3-force
• docker
• fastapi
• fly.io
• git
• github-oauth
• nebius-token-factory
• nemotron
• next.js
• openai-sdk
• playwright
• pydantic
• pytest
• python
• react
• ruff
• sqlite
• typescript
• uv
• uvicorn
• vitest