ResVR · ResOS · a simplified Higharc, built on what we own

Every plan, a shoppable 3D home — with a live price.

Author a plan's options once in Production Tracker. The Visualizer shows every variation in 3D — and what it costs — in real time. Higharc's buyer experience, minus the machinery we don't need.

reuses the Visualizer live pricing from PT no construction-doc machinery

Executive Summary ONE PAGE · READ THIS FIRST

The problem

Every builder plan hides thousands of variations — deck vs. porch vs. sunroom, elevations, mirrored plans. We can't hand-build a 3D model for each, and buyers can't see or price the choices they're making.

The idea

A simplified, Higharc-style single source of truth. AI reads the floorplan into structured data; we build the home from reusable snap-on 3D pieces (one base + option modules). The Visualizer shows every combination live — and a running price pulled straight from Production Tracker updates as the buyer toggles options.

Why now

Higharc just raised a $95M Series C (June 2026) selling exactly this to builders. The category is validated — and we already own the hardest, flashiest piece (the 3D configurator). We take that slice; we skip the rest.

Why it fits us

The Visualizer is the buyer configurator. PT's structural_options tree is the option ruleset — with unreal_path columns sitting empty. And PT's catalog already stores option prices. We're finishing a loop, not starting one.

The honest limit

No "point an API at a floorplan, get a finished house" button exists today. The accurate path is a pipeline with a quick human check at the front. But because we build pieces, cost is per-plan, not per-variation.

The ask

Approve a small ~1–2 week proof-of-concept: AI reliably reads a Schell plan into structured data. If it lands, we fund the pipeline — and the live-price overlay is a cheap early win.

Higharc, and the slice we're taking

Take the buyer-facing pillar. Skip the enterprise tail.

Higharc turns one plan into shoppable 3D, plan-based estimating, and permit-ready construction docs. We don't need all three — we need the one buyers touch, and we're already most of the way there.

✓ already own it

Shoppable 3D configurator

Real-time 3D where buyers toggle options and watch the home change. This is what the Visualizer already does.

~ simplified

Plan-based pricing

Not full estimating & takeoffs — just a buyer-facing running price, read live from PT's catalog. Higharc's headline number, the lightweight way.

✕ not building

Permit-ready construction docs

Structural drawings, permits, full BOM. Huge scope, not our business. We stop at the shopping experience.

$95M

Higharc's Series C (June 2026), $170M+ raised total. The market has already decided builders want this. Our edge: we're not building the platform — we're extending the Visualizer we already ship.

The whole idea in one picture

It's a LEGO house kit — with a price tag.

📦
The floorplan is the picture on the front of a LEGO box.
🤖
The AI is a super-fast helper who looks at the picture and writes down which pieces go where — and which are extras you can add or skip (the deck, the porch).
🏠
We build the base house once, and make each extra a snap-on piece.
🧩
Picking "Deck 1 + Screen Porch 2" just snaps on two pieces — and the price tag adds up as you go.
🎮
The Visualizer is the toy town where the finished house gets walked around.

How it works · 5 steps

Drawing in, walkable priced home out.

🤖

Parse

AI reads it

A vision model reads the drawing — rooms, dimensions, and which regions are optional.

👀

Review

Human checks

A person fixes anything the AI got wrong. The safety net that builds trust.

🧱

Extrude

Build the pieces

Deterministic code turns the plan into accurate walls, a base, and snap-on modules.

🎮

Assemble

Into the Visualizer

Base + modules load into Unreal; option toggles wire to the existing config.

💲

Price + Publish

Live cost, then GDN

Each toggle pulls its price from PT and updates the total; ships via NVIDIA GDN.

Step 1 is the only place AI does the heavy lifting — it removes the tedious human step. Everything after is deterministic: accurate, repeatable, auditable.

The handoff · how a piece reaches the Visualizer

Into the Visualizer — the honest version.

The pieces don't magically appear in the Visualizer. They cross a real boundary: we produce the assets and the option/price data; the Unreal team brings them into the project, wires the toggles, and ships the build. It reuses the exact pipeline that ships every Visualizer build today.

Export

Base + option modules as Datasmith / FBX / glTF, plus the option & price data.

Import

Pulled into the Unreal project as static meshes at known anchor points.

Wire toggles

Each module bound to an in-engine option toggle, keyed to the PT option ID. unreal_path written back to PT.

Cook

Baked into the map & packaged — BuildCookRun.

Ship to GDN

Uploaded to NVIDIA GDN, pixel-streamed to buyers. Build-monitor watches it.

ResOS · our pipeline (steps 1) Unreal team · Plastic SCM → GDN (steps 2–5)

Reality check: the Visualizer is baked — every content change needs a cook + GDN redeploy (not instant like a web app), and the in-engine toggle wiring is owned by the Unreal team. Want "edit in PT, appears instantly, no rebuild"? That's a separate runtime-loading rework — a future fork, not part of this plan.

Why this approach

Build pieces, not combinations.

✕ The hard way — model every combo

1,000s full 3D houses to model

Impossible by hand. This is the trap.

✓ The LEGO way — snap pieces together

1 base house
+ ~8 snap-on option pieces
= the same thousands of combos

~9 things to build

Cost is per-plan, not per-variation.

Build ~9 pieces, get thousands of priced variations for free.

It plugs into what we already have

The data — and the prices — are already sitting there.

PT already stores each plan's options as a structured tree, with the 3D columns in place. The catalog already stores prices. The pipeline just fills the blanks and reads the numbers. No new source of truth.

production-tracker · structural_options + catalog_options

"Rear Structural Option Location 1"        ← choice group (parent row)
     ├─ Deck 1           ┐
     ├─ Screen Porch 1   │  pick exactly ONE (mutually exclusive)
     ├─ Sunroom          │  each row already stores:
     └─ Covered Porch    ┘  floor · room · image_url ·
                           render_url · unreal_path  ◄── EMPTY, waiting for us

catalog_options.price  + community/region overrides   ◄── drives the live total

The pricing overlay

Watch the price move as you choose.

Your home · Cassidy plan live

Base planschell · cassidy $412,000

+ Deck 1rear structural · loc 2 + $18,500

+ Screen Porch 2rear structural · loc 1 + $24,000

+ Gourmet Kitchencatalog · appliances + $12,750

Total $467,250

◦ Illustrative numbers — not real Schell pricing.

How it works

✓ As the buyer toggles an option in the Visualizer, its price is read from PT and the total re-computes instantly — the same option data that drives the 3D also drives the number.

✓ Finish/catalog options are priced in PT today — catalog_options.price, with community & region overrides. This half works right now.

⚠ Structural options (deck/porch) aren't priced yet — they need one new price column on structural_options. Small, honest add; called out so nobody's surprised.

Scope discipline

What we're deliberately not building.

This is what keeps it "simplified."

Construction & permit docs

Structural drawings, code-compliant permit sets. Huge, regulated, not our lane.

Full estimating / BOM

Line-item material takeoffs and bids. We show a buyer price, not a builder's cost sheet.

Generative "AI house" mesh

Meshy / Tripo-style guesswork. Not dimensionally trustworthy for real homes.

The plan · crawl → walk → run

Phased, with a go/no-go gate up front.

Phase	What we do	Rough effort	Skills
0 · Prove the AI gate	Feed 3–5 Schell plans to a vision model + CV. Output structured data (footprint + option regions tagged to PT option IDs). Measure accuracy.	~1–2 wks · 1 eng	AI / vision
1 · Trust layer	Scaffold a ResOS app (from orgchart). A review screen to correct scale, walls, and option tags. D1 for jobs, R2 for files.	~4–6 wks · 1–2 eng	React / TS + platform
2 · Build the pieces	Headless pipeline: plan → accurate walls, openings, roof → base + option modules. Export to the Visualizer's format.	~4–6 wks · 1 eng	3D / Blender
2.5 · Live pricing	Wire option toggles to PT prices; running total in the Visualizer. Add a price column to structural options. Cheap early win, high visibility.	~1–2 wks · 1 eng	platform / PT
3 · Into the Visualizer	Import base + modules into Unreal; wire option toggles to PT option IDs; publish via GDN. Reuses the existing config.	~6–8 wks · 1 eng	Unreal (existing team)
4 · ResOS automation	A new community or plan auto-kicks the pipeline → review → publish, kept in sync with PT. The single-source payoff.	ongoing	platform / PT

End-to-end (1 builder)

~4–6 months to a working, priced configurator for Schell, then scale to other builders & plans.

Team

~1 AI/vision eng + 1 3D/Blender eng + the existing Unreal engineer + part-time platform/PT.

⚠ Effort figures are best-guess bands to refine with the team — not commitments. Phase 0 is deliberately tiny so we learn cheaply before investing.

Straight talk

What AI can and can't do here.

Real leverageAI shines

Reading the drawing. Labels, dimensions, tagging option regions to catalog IDs, scale calibration. This is the tedious human bottleneck — and the reason to do this at all.

Assist onlyAI helps

Tracing the walls. Computer-vision tools lead; the AI verifies and fills gaps. A collaboration, not magic.

Not AI at alland that's good

The accurate geometry, and the pricing math. Deterministic code — which is the point. Deterministic means accurate, reproducible, and auditable. Prices come straight from PT, not from a model's guess.

The ask

Let's spend two weeks proving the hard part.

Fund a small Phase 0 proof-of-concept: show that AI can reliably read a Schell floorplan into structured data our tools already understand. Low cost, clear go/no-go. If it works, we've got a simplified Higharc — built on the Visualizer and PT we already own.

Approve Phase 0 → ~1–2 weeks, 1 engineer

Everything after the gate is optional and sequenced.