Inspiration

Designing a building is slow, and you only find out whether it works at the very end. Residential homes are fairly simple to design, but clinics and data centers are a different game: an architect takes days to turn a request like "a clinic with 6 exam rooms" into a first floor plan, and "a 20 MW AI data center" means laying out every rack, cooler and backup generator before anyone knows whether the power and cooling hold up. The questions that really matter (will patients wait too long, will nurses walk too far, will the data center go down if one cooler fails) get answered much later, when every change is expensive. AI data centers make it even harder: a single GPU rack now draws almost nine times the power of a regular air-cooled one.

We wanted to shrink that loop to minutes, and we hit the core problem immediately: a language model alone can't be trusted with geometry. Asked to draw a plan, an LLM overlaps rooms, narrows corridors, forgets the brief and claims code compliance it never checked. A constraint solver gives exact geometry, but it can't read "nurse station among the exam rooms" or "enough for 6,000 GB200s."

So we split the work by what each tool does best:

The LLM proposes. The solver proves. The simulator tells you if it works.

What it does

Type one sentence. Get a floor plan that is proven valid, simulated on a busy day and costed, for an outpatient clinic or an AI data center. NVIDIA Nemotron reads the brief, a solver proves the geometry, a simulator tests how the building performs, and a Nemotron 3 Ultra agent on Nebius Token Factory answers questions from the live numbers.

Who it's for: architects and facility planners at the earliest design stage, who need a credible first plan in minutes instead of days; clinic owners and operators, who care about patient waits and staff walking before anything is built; and AI data center developers, who need to size power, cooling, redundancy and cost for GPU halls, and see what fails, before they commit.

1. Outpatient clinic: Import → Review → Simulate → Export

A brief and a site size produce three candidate layouts (west, centre and east entrance), ranked by 9 cited plan checks (geometry, ADA 404.2.3 / 403.5.1 / 304.3, FGI, IBC 1017, boundary). Each check shows the measured value, the required value and its source.
Review in WebGPU 3D: orbit, take a guided tour that follows a patient's visit, or walk the building in first person.
Plain-language edits are re-solved: the solver holds the change and repairs the rest.
Impossible requests are proven, not faked. The conflicting rooms turn red, with the arithmetic: "Waiting Area 1 would be 35 m wide, and the building is 24 m wide."
A deterministic discrete-event simulation of patients, nurses, providers and receptionists, with walking times from real A* path lengths. Run 20 days to get a verdict (Handles it, Busy, but it copes, or Struggles), the bottleneck and the range of waits.
Export one .zip for Blender: GLB, plan.json, SVG and a build script.

2. Data Center Studio: Describe → Design → Test → Cost

One sentence becomes a full design basis. Nemotron 3 Ultra fills in what the sentence implies but doesn't state; numbers you type always win, and the UI tags anything the model added.
Three complete designs with every rack, cooler, UPS and generator placed: liquid (GB200 NVL72-class, 132 kW per rack), hybrid (HGX H200-class, 41 kW) and air (L40S-class, 15 kW).
Ten cited design checks (ASHRAE, NEC 110.26, NFPA and more), and CP-SAT proves the room layout in about 30 ms.
Break it: fail a cooler, a power path or the grid, run a 42 °C worst day, or test every part in turn to see which single failures hurt.
Cost it: build vs. running cost, an energy Sankey, cost per kW-month, cost per GPU-hour and CO₂ per year, from 14 editable, sourced assumptions.
Export to OpenUSD for NVIDIA Omniverse, with one PointInstancer per equipment kind so thousands of racks stay light.

3. An assistant that never guesses a number Docked in both apps, it reads the app's live state through tools (about 20 in the data center app, 12 in the clinic), quotes what they return, and acts through the same functions as the buttons. Tavily web search covers facts outside the app (building codes, equipment, prices), with cited links.

Try it in two minutes: https://rome101202--floorplan-intelligence.us-east.modal.run/

The first visit after a quiet spell takes a few seconds while the servers wake up, and the first plan generation can take up to a minute while the GPU loads the model. After that, it's fast.

Clinic: keep the default brief and press Generate 3 plans, then open the top candidate. In Simulate, choose Flu-season Monday and press Run 20 days.
Edit: go to Review → Edit → Ask the plan generator and type "Make the waiting room 20% bigger, keep the restrooms fixed." Then try "Make the waiting room 250% bigger" to see an impossible request proven impossible.
Data center: open /datacenter and type "20 MW AI factory, liquid cooled, N+1 cooling, 2N power." In Test, press The grid goes down, then ask the assistant "Can it survive any one failure?"

How we built it

NVIDIA Nemotron and Nebius Token Factory

Nemotron 3 Ultra on Nebius Token Factory (nvidia/Nemotron-3-Ultra-550b-a55b) runs every live language task in the hosted app: the assistant in both apps and the data center brief reader. Our FastAPI server streams OpenAI-format tool calls over SSE, so API keys never reach the browser. With its reasoning pass turned off for tool calls, a call comes back in about 0.7 s.
Nemotron Nano 9B v2, fine-tuned by us: QLoRA (r = 32, α = 64) on 400 plans, then GRPO on 500 prompts with four verifiable rewards (format, no overlap, connectivity, regulatory checks). It's published on Hugging Face as a merged BF16 model and GGUF builds. The 5.5 GB Q4_K_M build runs on an Apple Silicon laptop or a small serverless cloud GPU, with grammar-constrained decoding so every line it writes is valid.
NVIDIA Omniverse / OpenUSD: data center designs export as USD, and the rack classes are modelled on NVIDIA hardware (GB200 NVL72, HGX H200, L40S).

The pipeline

Draft: the fine-tuned Nemotron Nano writes the room program in FML, our floor-plan language, under a GBNF grammar in llama.cpp.
Lay out: a synthesizer places the program on a double-loaded corridor in three entrance variants.
Repair: Google OR-Tools CP-SAT on a 100 mm grid enforces no overlap, keeps locked rooms and minimises movement. If a request is infeasible, it returns a conflict core naming the rooms in the way.
Check: a rule checker runs the cited rules and ranks the candidates.
View: a TypeScript and three.js app (WebGPU, with WebGL2 fallback) derives walls, windows, furniture and a walkable grid, then runs the simulation, editing and export.

Stack: Python 3.12, FastAPI, Pydantic v2, OR-Tools and llama.cpp; TypeScript, Vite and three.js; glTF, OpenUSD and Blender export. We have 67 pytest tests, 154 Vitest unit and golden tests, and Playwright end-to-end tests. The simulator is seeded and deterministic, so golden files freeze its exact numbers.

Challenges we ran into

Without a grammar, the fine-tune ignored its own training format. It wrote R1 TYPE EXAM ROOM, chained doors from room to room and dropped the corridor. Grammar-constrained decoding made every line valid.
Even with the grammar, the geometry was wrong. The room program was reliable, but room sizes didn't fit the site and one corridor came out 18.3 m wide. Rather than hide this, we made the pipeline program-first: Nemotron decides what to build, and CP-SAT decides where.
Reasoning tokens. Nano's chat template turns reasoning on, which used up the token budget; /no_think fixed it. Nemotron 3 Ultra ignores /no_think, so we turn its reasoning off with chat_template_kwargs: {enable_thinking: false}.
Two coordinate systems. The generator uses a top-left origin with y pointing down, and the viewer a bottom-left origin with y pointing north. The adapter flips every room and door, and we test it on all 500 dataset plans.
A checker bug that failed good plans: egress was measured to the site corner instead of the exit door.

Accomplishments that we're proud of

A published, GRPO-tuned Nemotron Nano 9B v2 that runs locally, with no data leaving the machine.
Impossible requests are proven impossible, with the rooms and the arithmetic to show it.
One pipeline, two very different buildings: a new building type is a configuration, not a new product.
An assistant that answers from live numbers and acts through the same functions as the buttons.

Measured results

With the fine-tuned Nemotron on: three checked candidates in about 16 s warm on a cloud GPU (about 47 s on an M4 Pro laptop). In our live test, all three solved OPTIMAL and passed 9/9 checks.
Nemotron 3 Ultra on Token Factory: about 0.7 s per tool call. Turning reasoning off gave the same answers about 2× faster, with a quarter of the tokens.
The simulator separates layouts: on a simulated flu-season Monday, the centre-entrance plan had the lowest average wait (11.5 min vs. 13.4 and 14.6) and cut nurse walking from 2.0 km to 1.4 km a day.
Impossible requests: 5/5 answered with a conflict core instead of a fake plan.
Data center layout proof: about 30 ms, OPTIMAL on all six reference designs.
Deterministic fallback (model off): 20/20 feasible briefs accepted in 0.04 s (p50), so the app keeps working even without a model.

What we learned

Use each tool for what it's good at: an LLM for language and intent, a solver for geometry, a simulator for performance.
Measure, don't claim. Our checker reports "passes N of M implemented checks", never "compliant". This is not a licensed design or code sign-off, and the thermal model is labelled as an estimate, not CFD.
Verifiable rewards make GRPO practical for a narrow domain language.
For agents, latency is a product feature: turning off reasoning for tool calls made the assistant feel instant.

What's next for Floorplan Intelligence: Brief In, Building Out

Serve our fine-tuned Nemotron on Nebius Token Factory, next to Ultra, and speed up generation with a shorter program format and caching.
Domain packs as configuration, opening the way to schools, offices, labs and hospitals.
Multi-storey and non-rectangular sites, windows and exterior walls in the solver, and DXF export.
Richer Omniverse output, with live sync of failure states into a digital twin.
Staffing optimisation: find the cheapest staffing that still "Handles it".