One message fills the brief; the agent researched Islamabad's CDA rules with Tavily and cites them
Start from your own drawing: the vision agent read 27 rooms on 2 floors
Concepts: four exteriors to choose from, or let Naqsha choose
The plan after the fixer agents: failing checks 34 → 0, every bylaw check passes
The 3D model assembles live in the browser
Concept match: a vision agent checks the 3D model against the concept, feature by feature (93%)
Photos from four angles, each made from the 3D model
Walk through room by room, with a minimap
Pin a comment on any wall
Share a link so family can view and comment, no account needed
A family member leaves a note from her own browser
Every note in one place, arriving live
The revision agent's changes: a wider window and a kitchen island, with the rules checked again
Or type a change: "Make the drawing room a bit wider"

Inspiration

In Pakistan, and in most places around the world, a family builds a house once in a lifetime, and it is usually the largest investment they will ever make. Yet the way homes are designed has barely changed in decades. It starts with a contractor's sketch and weeks of back-and-forth with a draftsman. Nobody checks the plan against the development authority's bylaws until the authority sends it back, and nobody in the family can see the house, let alone walk through it, until the walls are up and every change costs real money.

A home is also a decision the whole family makes together. Parents need a bedroom on the ground floor, someone wants a larger kitchen, someone else wants a balcony. Each request means another visit, another drawing and another week, so good ideas go unexplored and design mistakes are found on site.

We set out to bring an architect's first pass, a bylaw compliance check and a 3D visualisation studio together in one agentic system that anyone can use. Describe the home in a sentence, or upload a drawing. Agents research the local rules, design a plan that passes them and build it in 3D. The whole family can walk through it, comment on any wall and get a revised, re-checked design in minutes. Families see exactly what they are paying for before construction starts, and architects and builders get a verified starting point for every client.

What it does

In short: you describe the home you want in one message, or upload a photo of an existing drawing. Naqsha's agents look up your city's building rules, show you exterior concepts, design a floor plan that passes those rules, build the house in 3D and make photographs of it from every angle. You walk through it room by room and share a link so family members can pin comments on any wall. The agents turn those comments into a new version and check the rules again. The first design takes about ten minutes, and nobody needs an account to try it.

Step by step

The brief. A setup agent reads your message and fills in the brief: plot size and location, floors, rooms, who lives where, and style. It only asks about what's missing.
Rules for your city. Lahore's rules ship hand-checked. For any other city, a research agent searches the web with Tavily, reads the authority's regulations and turns them into a rule pack (setbacks, coverage, height and storeys by plot size), citing where each number came from.
Start from a drawing (optional). A vision agent reads an uploaded floor plan room by room, and the architect designs from that layout, changing only what the rules require.
Concepts. Four photoreal exteriors to choose from, or let Naqsha choose. Once a plan exists, concepts are drawn from the house's own elevation and plan, so the picture matches the design.
A plan that passes the checks. The architect agent drafts four plans at once, each adapted from a proven layout for that plot size. A rules engine scores every draft against the bylaws and livable-home rules. Two fixer agents then repair the best drafts in parallel, one small edit at a time. Each edit is tested against the rules before it is kept, and the better plan wins. On our Islamabad run, the failing checks went 34 → 22 → 15 → 7 → 3 → 0.
The house in 3D. The architect builds the 3D model part by part from a checklist of features read off the chosen concept: cladding, fins, balconies, railings, the gate. A vision agent then compares the model with the concept, feature by feature, and the parts of the facade that don't match are rebuilt. On the same run the match rose from 86% to 93%.
Photos, night view and walk-through. The app captures the model from the road, the street corner, the garden and the air, and an image model turns each view into a photograph without moving a wall. Switch to night to see every room lit, or walk through in first person.
Comments and revisions. Pin a note on any wall, or share a link so relatives can comment from their own phones; their notes arrive live. A revision agent reads every comment, changes the design, checks the rules again, answers each comment and saves a new version. A typed request works the same way.

The agents behind it

Naqsha is a team of agents that plan, use tools, check their own work and fix it. All of them run on NVIDIA Nemotron through Nebius Token Factory.

Setup agent (Nemotron 3 Super) holds the conversation, fills the brief through tool calls, and decides when a city's rules need researching.
Research agent (Nemotron 3 Ultra with Tavily) searches, reads and extracts regulations into structured, cited rules.
Architect (Nemotron 3 Ultra) drafts plans in parallel, reviews its own drawings like an architect would (a vision model looks at the rendered plan), and writes the 3D model.
Fixer agents (Nemotron 3 Ultra, with reasoning) get a failing plan and a set of tools: inspect the plan, try an edit against the rules engine without applying it, keep only edits that improve the score, and decide when they are done.
Vision agents (Nemotron 3.5 Super VL) read drawings, turn the chosen concept into a feature checklist, and judge the 3D model against it.
Revision agent (Nemotron 3 Ultra, nine tools) reads the comments and looks at a snapshot of each pinned spot, edits the design, checks the rules again and replies.

The models propose and a deterministic rules engine verifies, so nothing that breaks a bylaw is kept.

How we built it

Models: every text and vision call runs on NVIDIA Nemotron through Nebius Token Factory: Ultra for planning, the 3D model and revisions; Super for the conversation; Super VL for anything visual; Lightning as the fallback when a model is busy. Reasoning is switched on only where it pays off (the fixer agents) and off for quick drafts and chat.
Agent framework: the conversational agents run on Google's Agent Development Kit, connected to Token Factory through LiteLLM.
Rules engine: written in Python. It encodes Lahore's regulations from the authority's official documents, plus livable-home rules: light and air in every room, stairs to the roof, a railing at every drop and more.
3D model: the house is generated as a small program the browser runs, so it can be rebuilt part by part, and you watch it assemble.
App: a FastAPI back end on Cloud Run streams every step to the browser; the front end is React and three.js.
Images: concepts and photographs come from Gemini image models, because Token Factory has no image generation.
Research: Tavily search and extraction for the rules.
Tests: unit tests for the rules engine and agents, and a Playwright suite that drives the live app end to end.

Challenges we ran into

Rewriting a whole plan breaks things. Asking a model to regenerate a full plan to fix three problems tends to break five others. Small, tested edits by tool-using fixer agents solved it.
Reasoning can use up the answer. With reasoning on, a model could spend its whole output budget thinking and return nothing. We turn reasoning on per call, only where it helps.
Houses that looked like stepped boxes. Early plans pushed the upper floor far back from the road, so the concept's balconies had nowhere to go. Starting from proven layouts, plus a massing rule, fixed the facade.
3D parts that depended on each other. The model sometimes defined a material in one part and used it in another, so whole parts failed to build. Each part is now self-contained, with an automatic repair step.
Drawings read slightly off. Rooms read from a photo of a plan didn't quite line up. Snapping nearby walls onto shared lines brought the error down to under a foot.
A noisy vision judge. The concept-match score varied between runs. Two camera angles, a fixed temperature, and keeping a rebuild only if it scores higher made it steadier.

Accomplishments that we're proud of

It has already helped us and some friends design homes and check designs against the rules.
It's a complete solution that's usable and ready to publish: live, free to try without an account, from the first message to a shared, revised design.
Agents that check their own work. On our test runs the plans pass every bylaw check: a 10 marla house in Lahore, an Islamabad plot using rules the agent researched itself, and a plan rebuilt from an uploaded drawing.
A language model that builds believable 3D houses from a plan and a concept image, and then verifies the result against the concept.
A harness for residential design. The rules engine, plan format, 3D building kit and agents work together and extend to new plot sizes, cities and building types.

What we learned

Let models propose and let a checker decide. Small, verifiable edits work much better than asking for everything at once.
Turn reasoning on only where it pays. The fixers need it; a quick draft doesn't.
Vision models are good readers of architectural drawings: a floor plan in about five seconds.

What's next

Formalise the bylaws with local architects, and add more places: Karachi, Islamabad, Rawalpindi, Faisalabad, then the Gulf and beyond.
Launch Naqsha as a SaaS product for families, architects and builders.
Cost estimates and bills of quantities with local prices.
Structural and electrical/plumbing drafts, and drawings ready for approval submission.
Bigger plots, more building types, and interiors.
Run the long design jobs on Nebius.