RoomDex

RoomDex is a shared room-layout canvas for people and agents. A person works directly in a lightweight 3D room while a browser agent can inspect, arrange, measure, and refine that exact room through WebMCP.

It began with one small correction: look at a room, say “move only the floor lamp to the other side of the chair,” and see that exact change happen without starting over. A screenshot makes the agent guess at scale. A generated image gives the person nothing precise to refine. RoomDex keeps both collaborators on the same visible, measurable room plan.

Live app: roomdex.vercel.app

Source: github.com/Prashant002-1/roomdex

The shared-room loop

The person sets the purpose and priorities, then works directly with the room. The agent reads that same brief and geometry, compares arrangements without mutation, explains measured tradeoffs, and applies only the chosen changes. Both can make a smaller correction afterward. Every successful edit becomes a visible, attributed revision that can be inspected or undone.

RoomDex is not an agent chat laid over a scene. WebMCP gives the agent room-native verbs, real measurements, and revision-aware actions while the person keeps visual control of the artifact.

Where this can go

The next credible step is editable doors and windows, followed by connected rooms. The same named objects, real measurements, spatial checks, revisions, and human approval points could then support office seating, retail fixtures, and exhibition planning. Building-scale review is a longer-term direction that would require deeper architectural constraints, not just a larger canvas.

What it does

• Renders an editable 18 × 14 foot living room with procedural Three.js furniture.
• Supports direct human edits for room dimensions, object position, size, rotation, color, duplication, deletion, undo, redo, and camera view.
• Uses one validated measurement model across initialized rooms, imported plans, direct controls, and WebMCP actions.
• Keeps the room's intended use and up to five human priorities in the same document the agent inspects.
• Gives agents 21 focused WebMCP tools for inspection, recent-change review, shared-brief updates, catalog search, non-mutating layout comparison, measurement, naming, visible room finishes, and room edits.
• Resolves commands such as “put the lamp beside the lounge chair” against named room objects.
• Exposes the rendered window, entry door, main walkway, and entry landing to the agent, then checks hard collisions, room boundaries, recommended furniture clearances, wall-opening conflicts, and circulation obstructions.
• Places catalog art on the preferred back wall when it fits, then chooses the next opening-safe wall and ceiling-safe elevation in compact rooms.
• Shows whether a person or agent made each revision without turning the product into a chat interface.
• Persists the room locally and supports portable JSON export and import.
• Distinguishes a furniture tap from an orbit, pan, or pinch gesture so moving the camera does not silently change the inspector.
• Keeps every piece keyboard-selectable, gives the camera keyboard and named single-pointer zoom controls, and retains manual editing through a 2D fallback if WebGL is unavailable.
• Pairs the canvas with a current nonvisual room description and identifies invalid measurements in place instead of silently discarding them.

One-minute native walkthrough

Open RoomDex in the Codex in-app browser and confirm that the toolbar reports 21 agent tools.

1. Ask the agent to inspect the room and compare the three built-in arrangements against the shared brief. Have it explain the tradeoffs without making a change. Inspection and comparison should leave the revision unchanged.

2. Choose the reading-corner option, then ask the agent to apply it and add a warm abstract print where it will not cover a door or window. Each write should add one rendered, agent-attributed revision.

3. Make the narrow correction:

   Keep the arrangement. Move only the Floor lamp to the other side of the Lounge chair, from x -7.5 to x -5.0 feet while keeping z -4.9 feet. Then analyze the layout. Do not change anything else.

   The rest of the room should remain unchanged, analysis should stay clear, and the activity trace should read “Floor lamp moved precisely.”

4. Ask the agent to review the recent changes, then undo the lamp move. The review should not change the revision; undo should restore the earlier room as a new, visible revision.

For a looser first prompt, try:

Inspect the room. Make a reading corner beside the window, keep the entry and walkway clear, and add a warm abstract print to the back wall.

The activity trace keeps agent work legible without becoming a second workspace.

Release evidence

• All 21 tools registered natively in a WebMCP-capable Codex browser.
• A production-preview pass exercised the read, compare, write, revision, presentation, and undo loop against the visible room.
• TypeScript, the production build, and 211 deterministic tests across nineteen files pass.
• A clean source-only archive installs from the lockfile and passes the same verification command.

The same core native loop passes on the public Vercel deployment. The public repository contains the complete MIT-licensed source, intended assets, lockfile, verification command, and direct native document.modelContext.registerTool implementation.

WebMCP surface

Read-only tools:

• inspect_room
• review_recent_changes
• list_furniture
• analyze_layout
• compare_layouts
• measure_clearance

Room-editing tools:

• set_room_shell
• set_room_brief
• add_furniture
• move_furniture
• resize_furniture
• rotate_furniture
• style_furniture
• rename_furniture
• duplicate_furniture
• remove_furniture
• create_wall_art
• apply_layout
• set_room_view
• undo_room_change
• redo_room_change

One declarative registry powers both the native tools and the local evaluation bridge. The native registration path calls document.modelContext.registerTool directly, while both paths share schemas, validators, handlers, output limits, and cleanup.

The tool boundary is semantic rather than pointer-based. The agent acts on named furniture, real units, support relationships, wall placement, clearances, and revisions. Comparison remains a read, application remains an explicit write, and every mutation can include an expectedRevision so an older plan cannot overwrite newer work.

Writes are serialized and wait for the matching rendered revision before completion. Results that can echo human-authored room content are marked untrusted, retained outputs are bounded, and cancellation distinguishes work stopped before mutation from a revision that committed before presentation was confirmed. The evaluation fixtures cover direct, contextual, portable, and adversarial cases.

Local security boundary

RoomDex is a client-only application. It does not send room documents to an application server, load remote media, or require an account. Production and local-preview responses use a restrictive Content Security Policy, same-origin opener and resource policies, origin clustering, denied unrelated browser capabilities, disabled embedding, and a WebMCP tools capability restricted to the same origin. Production source maps are disabled. File imports keep the room revision from the moment the file is chosen, so a delayed read cannot overwrite a newer human or agent edit, and only the most recently chosen file remains eligible when reads overlap.

Native WebMCP registration has a two-second timeout. If registration is missing, fails, or stalls, RoomDex keeps the complete manual interface and the local evaluation bridge instead of leaving the workspace in an indefinite connecting state.

Early v1 local saves allowed any positive room or item dimension. Restore migrates those values into the current minimum envelope across the visible state and undo/redo history, preserving wall attachment and supported-item placement. Nonpositive or malformed room values remain invalid rather than being silently reinterpreted. If the current room is valid but an auxiliary activity or history stream is malformed, RoomDex retains the room and discards only the corrupt stream before saving a sanitized payload.

The right panel includes a compact toolkit disclosure generated from the same registry used for native registration, so its six read tools and fifteen room actions cannot drift from the real surface. It remains available while a furniture inspector is open. The toolbar names a single active tool, reports concurrent work as a batch, and holds success, stopped, or error results long enough to be perceivable. A transient canvas card shows active and terminal agent feedback without duplicating the durable room history or its screen-reader announcement.

Run locally

RoomDex requires Node.js 22.12, 24, or 26 and newer. This range matches the locked build and test toolchain.

npm ci
npm run dev

Open the local URL in a browser with WebMCP enabled. The current release was verified in the Codex in-app browser, where the toolbar should report 21 agent tools. Browsers without native WebMCP retain the complete manual experience and expose the same handlers at window.roomdex for local evaluation.

Verify

npm run verify

This runs the TypeScript check, deterministic domain and tool-contract tests, and a production build.

To inspect the built artifact locally:

npm run preview

Architecture

• src/domain: serializable room state, catalog, placement rules, geometry checks, history, and persistence
• src/webmcp: one declarative tool registry shared by native registration and the fallback bridge
• src/scene: event-driven Three.js rendering with a low-power WebGL preference, no idle animation loop, and a 2D failure fallback
• src/components: the manual room workspace and visible activity trace
• src/config: the production and local-preview security-header contract
• evals: direct, contextual, portable GoogleChromeLabs-format, and adversarial trust-boundary fixtures with an explicit validation boundary
• vercel.json: production build settings and the same WebMCP response headers used by local preview

RoomDex has no backend, account requirement, analytics, or external data dependency. The 3D scene loads no remote models or user-uploaded media. The app itself keeps room plans in local browser storage unless the person exports them. When someone invokes a browser agent, the requested tool inputs and results are processed according to that browser and agent provider's settings.

License

MIT

The self-hosted Manrope and Newsreader font files retain their original copyright notices and SIL Open Font License, which is copied into the deployed site.