Architect Floorplan — Hermes + Blender Experiment

The original idea

A deliberately small end-to-end pipeline, to test whether an agent could carry a structured specification through to a finished visual artefact.

Hermes designs / specifies the house
Hermes calculates dimensions and coordinates
Hermes writes the Blender Python
Blender generates the floor plan
Hermes visually checks the result

The pipeline is simple to state. In practice, asking Hermes to invent a sensible architectural layout from nothing turned out to be the weak point. Several proposed specifications were poor, and the failures were architectural rather than technical.

Bedrooms far too small

Rooms that satisfied the area target but were unusable as bedrooms. One proposal produced a second bedroom only 1.2 m deep.

Circulation ate the house

Landings and hallways grew until they were larger than the rooms they were meant to serve.

Stairs did not physically fit

A 3.60 m run drawn into a 2.60 m opening, papered over with “the remaining stair continues into the landing”.

Unexplained floor area

Room areas totalled about 29 m² against a 48.96 m² envelope, with the shortfall described as “partitions”.

Windows in party walls

A bathroom window proposed on the side elevation of a house explicitly described as a mid-terrace.

Figures that disagreed

Stated areas did not match the drawn geometry, and stair treads overlapped the WC.

The agent also kept responding to a rejected proposal by starting another redesign, rather than applying the specific feedback it had been given. That loop was the single biggest time sink in the project.

The experiment showed that the architectural specification needed to be constrained by the human (or ChatGPT) before Hermes was asked to generate the Blender geometry.

Where Hermes struggled

The problem was not simply Blender. The difficult part was producing a coherent architectural specification in the first place.

Flow diagram in five stages: house requirements, a Hermes design attempt, problems found, human or ChatGPT constraining the architecture, and finally Hermes producing coordinates while Blender draws the specification. — The point in the process where the approach had to change.

The method that worked

Human / ChatGPT defines a sensible basic layout — envelope, room count, room sizes and stair position.
Hermes converts it into precise coordinates — translation, not design.
Blender draws the specification — deterministic geometry from those coordinates.
Hermes visually verifies the rendered image — looking at the picture, not the log.
Hermes corrects technical presentation problems — without touching the architecture.

This is a more useful division of responsibilities for an experiment like this: the human owns the judgement calls, the agent owns the implementation.

The Blender problem

The first render that appeared to work did not work at all.

What happened

The PNG was produced, it contained black and white pixels, and it was reported as successful. It was blank. The verification — file exists, file is not uniform, file is not empty — could not tell the difference between a correct render and an empty one.

Only when the rendered image was actually looked at did the real problem appear. The two floors had been modelled stacked vertically, which is the honest way to build a two-storey house. A top-down orthographic camera sees only the top surface of the first-floor slab, so the entire ground floor was hidden underneath it. No change of material, lighting or background could have fixed that.

The fix was deliberately not a redesign. The house was left exactly as specified. Both floor plans were presented side by side at the same Z level for the 2D presentation — a drawing convention, not an architectural change.

File validation is not visual validation.

Final result

A readable 2D floor plan generated by generate_floorplan.py, rendered with Blender's Workbench engine using flat object colours on a white background.

Two floor plans side by side. Left is the ground floor with a living room at the front, a hall and staircase through the middle, and a kitchen and dining area at the rear. Right is the first floor with bedroom one at the front, a bathroom and landing in the middle, and bedroom two across the rear. Both plans show external and internal walls, door openings, windows, a staircase with treads, room labels with areas, and dimension lines. — Ground floor on the left, first floor on the right. Front elevation at the bottom.

What the image contains

Ground floor — living room, kitchen/dining, hall, staircase
First floor — bedroom 1, bedroom 2, bathroom, landing, stair void
External walls at 200 mm and internal partitions at 100 mm
Door openings and window positions
Staircase drawn with treads and a direction arrow
Room labels with dimensions and areas
Dimension lines for the 5.50 m × 10.00 m envelope

Not a construction drawing

This is an illustrative concept. It is not architect-certified, has not been checked against Building Regulations, and must not be used for construction. Its purpose is to document what this pipeline can and cannot do.

An earlier design, and why it was replaced

This project went through a first design that rendered successfully but was architecturally weaker than the final one. It is kept here for comparison.

Earlier version of the floor plan, showing two plans side by side. The ground floor has a living room and kitchen/dining room with a hall between them, a WC beside the staircase, and a long landing. The first floor has two bedrooms either side of a central landing with a bathroom between them, and an L-shaped rear bedroom. — The first design. Readable and structurally sound, but with real architectural problems.

Why it was replaced

This version was rejected on architectural grounds, not presentation grounds. The three problems below are the substantive ones:

The stairs overlapped the WC

The ground-floor stair was drawn running through the same footprint as the downstairs WC, so the two spaces occupied the same floor area.

Bedroom 2 was an awkward L-shape

The rear bedroom wrapped around the landing in two arms rather than forming a single rectangular room, which made it awkward to furnish.

The bathroom had no window

The bathroom sat internally with no external wall, so it could only be lit indirectly. The final design resolved this.

A label that disagreed with its own geometry

In this version the Bedroom 2 label printed on the drawing read “15.8 sq m” and “3.0 × 2.2 + 5.1 × 2.1 m”, while the rectangles behind it actually measured 16.83 m² — 3.00 × 1.70 m plus 5.10 × 2.30 m. The geometry was correct and the text was wrong.

This is kept deliberately. It is a small, honest example of why “the file rendered successfully” and “the drawing is right” are entirely separate questions.

Comparison worth noting. This first design spent noticeably more of its floor area on circulation than the final version. The final plan traded that space for larger, more usable rooms and a more compact landing.

Final workflow

The sequence that produced a usable result, and where responsibility for each decision sits.

Six-step vertical workflow diagram: specification, coordinates, Blender Python, 2D floor plan, visual inspection, and correction, with a loop-back arrow from correction to visual inspection. — Specification → coordinates → Blender → render → inspect → correct.

1 · Specification

The human side fixes the envelope, room count, room sizes and stair position. Nothing architectural is invented downstream.

2 · Coordinates

Hermes translates the agreed layout into explicit X/Y rectangles for every room, wall and opening.

3 · Blender Python

A script builds the geometry, sets an orthographic camera and configures a flat Workbench render.

4 · 2D floor plan

Both floors render side by side on a white background with dark line work.

5 · Visual inspection

The rendered image is examined directly. A render that exists is not the same as a render that is correct.

6 · Correction

Presentation problems are fixed. The architecture is left alone.

How long did it take?

Considerably longer than this small visual result suggests.

This small proof-of-concept took considerably longer than expected, because most of the iteration was spent getting the specification right and diagnosing whether the Blender output was actually correct — not in writing Blender code.

Writing the generator script turned out to be the easy part. The effort went into making three kinds of decision at once: architectural judgement, arithmetical consistency with the envelope, and verification that the rendered image was right. The middle one was the most error-prone and the least visible until the image was inspected.

Two failures were only caught because something was actually checked: a script that would not run, and an image that was blank. Neither would have been found by reading the code or the log alone.

Final lessons

What worked

Hermes can generate and execute Blender Python
Hermes can create structured geometry from coordinates
Blender can produce a clean 2D presentation
Hermes can visually inspect its own generated image
Hermes can diagnose a real presentation error and correct it

What didn't work

Asking Hermes to freely invent the architecture
Trusting textual claims that the render was correct
Assuming a non-empty PNG is a useful image
Stacking both floors and expecting one top-down view to show both

AI agents are much more reliable when the human defines the important constraints and the agent handles the implementation.

The role of ChatGPT

ChatGPT was used alongside Hermes during the experiment. It did not design the architectural plan — it was used to:

Challenge poor floor-plan specifications instead of accepting them
Identify unrealistic room proportions and unusable bedroom shapes
Tighten the requirements until they were actually satisfiable
Recognise when Hermes was overcomplicating the task or restarting a redesign
Help restructure the workflow so the agent had a bounded job

The experiment became successful once the architectural constraints were defined clearly enough for Hermes to execute. That is the point — not that ChatGPT produced a professional architectural plan.

Technical stack

Hermes local AI agent
Blender 5.2.2 LTS
Python
Blender Python API
Git
GitHub
GitHub Pages
PNG rendering
Visual verification

The project ran locally on Windows. No external services were used beyond GitHub for hosting.

Repository contents

File	Purpose
`index.html`	This page
`style.css`	Styling, dark and light
`generate_floorplan.py`	Blender script that builds and renders the plan
`make_diagrams.py`	Generates the two diagrams with Pillow
`images/`	Final floor plan and the two diagrams
`docs/`	Specification and correction log

Reproducing the render

blender --background --python generate_floorplan.py