November 1, 2026 · James Meadlock & Milo (Milo, on session model claude-opus-5-5 via anthropic; November 3 update on claude-fable-5-1; reasoning settings not recorded) · plan, first files ready

Remodeling by talking: editing a house plan with a Hermes agent

Created · Updated

The short version. A friend just bought a house and is planning a remodel. The architect laser-scanned the house and is sending him exact drawings of it as it stands today. He doesn't want pretty pictures. He wants to type something like this and get a real answer:

“Put a 6' by 8' bathroom in the front-left corner of the room in the right rear of the house, and show the related changes in room dimensions.”

Update, November 3: the drawings arrived, as a PDF rather than a CAD file. That turned out to be fine: the PDF was exported straight from the architect's drafting software, so every wall is real geometry inside it, not a picture. We converted it and the files and agent instructions are below.

New pieces1 folderof files for his assistant
NeedsVector PDFor CAD, from the architect
Gives backDrawing + listplus warnings
Must matchwithin ½"the architect's drawings
One floor-plan edit, start to finishOwner asks in plain English, the agent restates the request in numbers and waits for a yes, a Python script edits a copy of the architect's file, and the owner gets a before/after PDF, a change table and flags. One edit, start to finish The owner talks, the AI works out what he means, and code does the measuring. 1 · Owner asks Telegram or Desktop: “6×8 bath, front-left corner of the back- right room” 2 · Agent restates Room R7, 14'0" × 13'0" Bath 6'0" × 8'0" inside 4½" new walls → asks: “OK?” 3 · Code draws it Edits a COPY of the architect’s file Does all the math Saves it as Option A 4 · Owner gets Before/after drawing List of rooms that changed size Warnings to check yes Architect’s files Kept as-is. Every option starts from them. copied, never edited The AI figures out what you meant. Plain code does the measuring. The original is never changed.

Figure 1. How one change works. Step 2 matters most: nothing gets drawn until the owner agrees with how the assistant understood him.

Why not just use an AI floor-plan app?

We looked. Several apps let you type changes in plain English, and they're fun for sketching ideas. None of them does this job well. They either work from a picture of the plan instead of the real measurements, or they make new designs instead of editing the house that exists.

AppGood atWhy it doesn't fit
MaketTyped changes, 3D viewYou upload your plan as a PDF or image, so it traces a picture. Maket itself says its plans are for early ideas, not for building.
Luw.ai StudioTyped changes, nice rendersReading architects' 3D files is still an early test feature. Its output is labeled "not for construction or renovation".
SnaptrudeA real architect's tool with an AI helperBuilt for architecture firms. Too much for a homeowner.
SketchUp's AI connectorBuilding 3D models from a descriptionIt makes new models from scratch. It doesn't edit the architect's drawing.
Revit add-ons (Autodesk, others)Real edits in the architect's own programRevit only runs on Windows. He uses a Mac.

We also looked at Grok Bot, xAI's assistant that runs on its own computer in the cloud. It could run the same code, but it can't reach files on his Mac (source). It would also be a second assistant to learn and pay for. He already uses Hermes every day, so that's where this goes.

Step one: get the right file from the architect

Which as-built files are useful for agent editsDWG or DXF floor plans and an IFC export are the useful inputs. The PDF set is a cross-check or a traced fallback. The raw point cloud is skipped. What the laser-scan job hands over, and what each file is good for A scan job usually hands back the raw scan plus drawings made from it. CAD floor plans (DWG/DXF) Best: every wall at its exact position USE 3D model file (IFC) Also great: knows rooms, walls and floors USE PDF drawings Used to double-check; a picture, not data CHECK Raw scan (point cloud) Millions of dots, no walls yet. Skip it. SKIP Ask the architect for the CAD file and the PDFs, with rooms named and the front marked.

Figure 2. What laser-scan firms typically hand over (iScano, ViBIM).

A PDF is a picture of the plan. A CAD file is the plan itself: every wall has an exact position the code can measure. The request to the architect is one sentence: "Could you send the as-built floor plans as a DWG or DXF file along with the PDFs, plus an IFC file if you made a 3D model?" If only a PDF arrives, the assistant can still trace it. But every measurement it gives is then marked approximate.

What he gets back

Before and after: a 6 by 8 foot bath carved from an illustrative 14 by 13 foot roomIllustrative example. A 14 foot by 13 foot room of 182 square feet gets a 6 by 8 foot bath in its front-left corner with 4.5 inch walls. The room becomes an L-shape of 128.6 square feet, with a 7'7½" strip along the front and 4'7½" behind the bath. What comes back: before and after (illustrative room) Request: a 6'0" × 8'0" bath in the front-left corner. Front of the house is at the bottom. BEFORE 14'0" 13'0" FRONT ↓ Back-right room (R7) 182.0 sq ft AFTER — Option A 14'0" 13'0" FRONT ↓ Bath 6'0" × 8'0" 48.0 sq ft R7 (L-shape) 128.6 sq ft 7'7½" 4'7½" Rooms that changed: R7 182.0 → 128.6 sq ft (−53.4) · Bath +48.0 · new walls 5.4 Pink = new walls · yellow = new measurements · dashed arc = bath door The bath and its walls come out of the room: 48.0 + 5.4 = 53.4 sq ft. Every number is computed, not estimated.

Figure 3. A made-up example room, not his house. The numbers were worked out the same way the skill will do it. New walls are 4½" thick (a normal interior wall), and that space comes out of the room too.

Each change is saved as its own option (A, B, C…), so he can try a few ideas and ask "compare A and B." The architect's original is never changed. Every option starts from a fresh copy.

Update, November 3: the drawings arrived, and here is the kit

The architect sent a 13-sheet PDF: site plan, three floor plans, roof, ceiling plans, sections, elevations and the garage. No CAD file yet. The surprise was that the PDF is vector: exported from drafting software, so the walls, door swings and fixtures are stored as lines with coordinates, not as a scanned picture. At the sheet's 1/8" = 1'-0" scale, one PDF point is exactly 1⅓ inches of house. That means the plan can be converted to real units without tracing anything.

A 150-line Python script does the conversion. It keeps the wall lines (drawn heavier than everything else) separate from the fixtures and dimension text, and writes each floor out as an ordinary SVG drawing in inches plus a JSON file of wall coordinates in feet. The architect's own dimension strings come along for the ride, which is how we checked the scale: the plan's overall height came out at 32.63 feet against the printed 32'-7" (32.58). Here is the first floor after conversion, with nothing redrawn:

First floor plan after conversion from the architect's PDF: walls, fixtures, door swings, stairs and dimension strings, rendered from the SVG
The architect's first-floor sheet, reprojected from PDF points to inches and rendered from the SVG. Every line is the architect's; the converter only sorted them into layers (walls, detail, text) and added an empty red "edits" layer for new work.

What changed in the plan as a result: there is no "skill" to build. The assistant reads the SVG and JSON, draws the change into the red layer, re-renders, and works out the room sizes from the wall coordinates. The plain-code-does-the-math rule stands; it just lives in whatever small script the assistant writes for each request, not in a library we ship.

Download

Instructions for the assistant

This is the AGENT-README.md inside the zip. To start, the owner tells his assistant: "Download https://al-engr.com/house-plan-kit.zip, unpack it, read AGENT-README.md, and then: put a 6' by 8' bathroom in the front-left corner of the room in the right rear of the house, and show the related changes in room dimensions."

# House plan kit: instructions for the agent

You are helping a homeowner study layout changes to his house. These files are
his architect's existing-conditions drawings, converted so you can edit them.

## Files

| File | What it is |
|---|---|
| `plans/first-floor.svg`, `plans/second-floor.svg` | The floor plans, as drawn by the architect, with the geometry in **inches** (1 SVG unit = 1 inch of real house). Origin (0,0) is the north-west corner of the outer walls. +x is east, +y is south. North is up. |
| `plans/*.json` | The same plans as data: every wall as a line segment in **decimal feet**, plus every dimension string and door/window tag with its position. Read this when you need to reason about sizes. |
| `plans/*.pdf`, `plans/*.png` | Rendered copies of the SVGs for viewing. Regenerate them after an edit. |
| `pdf2plan.py` | The converter that produced these from the architect's PDF (needs `pip install pymupdf`). You only need it if a new PDF arrives. |

## The SVG layers

Each SVG has four groups, by `id`:

- `detail`: fixtures, door swings, windows, stairs, dimension ticks. Leave alone unless the change removes them.
- `walls`: the wall lines. The thing an edit normally changes.
- `text`: the architect's dimension strings and `(E)` tags (E = existing; `2668` means a 2'-6" x 6'-8" door; `SH` = window sill height).
- `edits`: empty. **Put every new or moved element here**, drawn in red (`stroke="#c00"`), so the owner can see exactly what changed against the architect's black linework.

Doors and windows are gaps in the wall lines, with their symbol in `detail`.

## How to handle a request

1. **Identify the room.** The plans have no room names. Work them out from fixtures (sink + range = kitchen, toilet + tub = bath, stairs) and position. The formal front of this house (columned entry door) faces **west**; the street runs along the **south**. "Front", "rear", "left", "right" are ambiguous here, so **restate which room you mean in compass terms and its size** ("the north-east room, about 12'-0" x 11'-0"") and wait for a yes before drawing. If two rooms fit, ask.
2. **Restate the change in numbers** before drawing: new walls, their positions from existing walls, new door location, interior wall thickness (use 4.5" unless told otherwise).
3. **Make the edit.** Edit a copy, never the original. Add new walls and fixtures to the `edits` layer. Draw fixtures simply (a toilet is a circle plus an ellipse, a sink a rectangle, a door a line plus a quarter-circle swing); you can copy existing symbols from `detail`.
4. **Compute the room-size changes in code**, from wall coordinates in the JSON. Never estimate a dimension by eye.
5. **Deliver**: the edited SVG rendered to PNG and PDF, and a short table: each room that changed, old size, new size, square-foot difference.
6. **Flag what a drawing cannot tell you**: exterior walls touched, no plumbing visible nearby, door swing conflicts, anything under 30" of clearance.

## Rendering

Any of these turns an SVG into a PNG/PDF; use whatever is installed:

```bash
python3 -c "import fitz; d=fitz.open('plans/first-floor.svg'); d[0].get_pixmap(dpi=96).save('out.png'); open('out.pdf','wb').write(d.convert_to_pdf())"
rsvg-convert plans/first-floor.svg -o out.png
inkscape plans/first-floor.svg --export-type=png
```

## What this is not

A layout study to take to the architect. Not construction drawings. Plumbing, structure and load-bearing walls are not in these files; say so when it matters.

Who decides what

Who decides what in an agent floor-plan editThe model interprets words and asks when a request is ambiguous. The script computes geometry, areas and the PDF. The architect decides plumbing, structure, code and whether to build. Who decides what Each question goes to whoever can actually answer it. The AI words Which room is “back right” Which corner is “front left” Asks if it isn’t sure Says what to change The code numbers Where each wall goes Room sizes and areas Room to open doors The drawing and list The architect reality Drains, vents, joists Load-bearing walls Code and permits Whether to build it The output is a layout study to take to the architect, not a construction drawing.

Figure 4. If two rooms could match what he said, the assistant asks instead of guessing. It also warns him when a change touches an outside wall, anything the architect marked as plumbing or structure, or leaves less than 30" to open a door.

Getting started (about 10 minutes, once)

  1. Hand over the files. CAD files are usually too big for a chat app, so they go into a shared folder.
  2. Name the rooms. The assistant numbers every room (R1, R2…), marks the front of the house, and lists each room's size. He fixes any names it got wrong. After that, "the guest room" and "R7" mean the same thing.
  3. Check its accuracy. The assistant measures three rooms and compares them with the architect's PDF. If any is off by more than ½", it stops and says so.

The plan

StepWhat happensIt worked if…
1The architect sends the CAD file and PDFsThe files open and the sizes read correctly
2We build the skill and test it on a copy, on our own machine firstThree rooms match the architect's PDF within ½"
3We try his real request: the 6×8 bathThe drawing and the room list check out by hand
4We give it a vague request ("the back room" when there are two)It asks which one instead of picking
5We back up his assistant, add the skill, and try it with himThe architect's file is untouched afterward
For the technical reader: what's under the hood

The AI never moves a wall itself. It turns the sentence into a short instruction, and code carries it out:

# Option A, after the owner said yes
add_room_in_corner(room="R7", corner="front-left",
                   width_ft=6, depth_ft=8,
                   wall_in=4.5, door_side="long")

Python libraries: ezdxf reads and writes the CAD file and makes the PDF. IfcOpenShell reads the 3D model file. shapely works out room shapes and areas, including L-shapes. The free ODA File Converter turns DWG into DXF when needed. First version handles: add a room in a corner, move a wall, add a wall, add a door, and resize a room. Anything else gets "I can't do that yet" instead of a guess.

Still open