acceptodds
Under review as a conference paper at ICLR 2027

Architect-Ant: Editable Automatic Furnishing of Architectural Floor Plans

Abstract

Furnished floor plans support real-estate visualization, interior design, and architectural workflows, yet automatic furnishing remains challenged by limited real-world data and the need to satisfy interacting geometric and functional constraints. We ask whether professional furnishing knowledge can be learned from real floor plans using a pretrained model, enabling direct constraint-aware layout generation without relying on costly iterative agentic inference. We introduce AntPlan, a curated dataset of 505 real professional architectural floor plans with dense furniture annotations spanning 92 object classes and ten residential room categories, and Architect-Ant, a framework for generating editable furniture layouts. Architect-Ant represents layouts with an editable coordinate-based DSL and first learns professional furnishing patterns through supervised fine-tuning. It is then optimized with GRPO using a Layout Rule Score (LRS) that aggregates geometric and functional constraints derived from professional plans, providing outcome-level supervision without prescribed reasoning traces. Experiments against diverse state-of-the-art baselines show that Architect-Ant combines low geometric violation rates with high functional completeness, while qualitative results more closely reflect real-world residential furnishing patterns. The resulting layouts remain object-level editable and can be converted into 3D scenes.

Primary area:
generative models
Keywords:
indoor scenes, layout generation, constrained generation, large language models, reinforcement learning

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_1t7JOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies automatic furniture layout generation from architectural floor plans, introducing the AntPlan dataset and the Architect-Ant framework. The method combines SFT, rule-rewarded GRPO, and candidate selection to generate editable coordinate-based layouts for 3D scene construction, evaluated on geometric validity, functional completeness, and visual preference.

Critical strengths

AntPlan provides linked structural, room, and object annotations across 92 classes on real professional floor plans, offering a valuable resource for studying spatial configurations. Architect-Ant uses a coordinate-based DSL with object categories, positions, and dimensions, enabling direct geometric checks, object-level edits, and 3D asset matching.

Critical weaknesses

Table 3 compares methods under inconsistent room subsets (90 vs. 109), task settings (mapping dining rooms to kitchens vs. retaining them), and geometric inputs. Moreover, Architect-Ant selects from 20 candidates using retrieved inventories, while regenerated baselines use 4 candidates. This conflates gains from model training with those from retrieval, candidate selection, and baseline adaptation. In Table 5, moving from SFT to reasoning-enabled GRPO changes both the training stage and output format without a direct-DSL GRPO baseline in the main table, failing to isolate the contributions of RL versus explicit reasoning. Combining SFT with rule-based GRPO closely resembles existing layout post-training methods (e.g., ReSpace). The main text lacks sufficient discussion and comparison to clarify Architect-Ant's specific technical innovations in training strategy or reward design.

Questions for authors

Can you provide a controlled comparison in Table 3 with shared rooms, unified dining/kitchen settings, comparable geometric inputs, and matched inventories and candidate budgets to isolate the effect of model training? Can you include direct-DSL SFT + GRPO in Table 5 under a matched token budget, reporting success rates, scores including all-failed rooms, and paired confidence intervals? Do these results still favor reasoning-enabled GRPO? What are the main technical distinctions of Architect-Ant in training, representation, and reward design compared to prior RL/preference-based layout methods? Can you clarify these via direct comparisons or ablations?

7 comments

We thank the reviewer for the very precise questions. They led us to rebuild both comparisons and to make the paper more consistent.

Q2. Direct-DSL GRPO in Table 5, matched token budget, failures counted, paired CIs.

In the submission, the reasoning runs had larger generation limits for the complex room types with long outputs (6,144 tokens for kitchens, 4,096 for living rooms, 3,072 otherwise). We had assumed that a larger budget would let long reasoning finish. It did not solve the problem. Long rollouts that hit the limit still dominated the update, and the budgets were no longer comparable across variants.

For the revision we matched the budget and changed how over-long rollouts are handled:

  • every model, in training and in evaluation, has the same 4,096-token limit;
  • following DAPO (Yu et al., 2025), rollouts that hit the limit are masked out of the policy-gradient loss instead of being penalised token by token (overlong masking);
  • the reasoning prompt asks for concise reasoning.

The rest of the recipe is identical for both GRPO variants: the same text-only (thanks to reviewer Tb1z) SFT start, data, reward, 8 updates of 8 rooms × 16 rollouts, learning rate, seeds and evaluation.

The main gain comes from rule-guided RL itself, not from reasoning: direct-DSL GRPO with our reward improves the mean over SFT in every room type, significantly in kitchens (+1.10 [+0.24, +2.00]) and living rooms (+0.84 [+0.34, +1.39]; reward ablations, Q3). Whether the model reasons before writing the layout is a secondary choice; its mixed results below concern only that choice, not the gain from the reward.

The new Table 4 reports 8 samples per held-out room; as requested by Reviewer Tb1z, it now also includes dining rooms. Every sample counts, with invalid outputs scored −5, and rooms where all samples failed are included:

(a) MeanBaseSFTSFT + direct-DSL GRPOSFT + reasoning GRPOΔ reasoning − direct-DSL (paired 95% CI)Valid % (SFT / DSL / reasoning)
Kitchen (47)−12.13 ± 3.71−0.85 ± 2.270.25 ± 2.001.76 ± 1.57+1.51 [+0.52, +2.50]100 / 100 / 90.2
Bathroom (74)−2.80 ± 1.405.91 ± 0.996.68 ± 0.956.58 ± 0.91−0.10 [−0.61, +0.42]100 / 100 / 98.1
Living room (56)1.45 ± 1.815.70 ± 0.826.54 ± 0.806.02 ± 0.85−0.52 [−1.23, +0.12]99.8 / 100 / 97.1
Bedroom (66)−3.40 ± 2.035.82 ± 0.846.17 ± 0.905.49 ± 1.06−0.68 [−1.50, +0.09]100 / 100 / 95.6
Dining (14)4.39 ± 2.662.75 ± 3.865.35 ± 1.626.84 ± 1.31+1.49 [+0.42, +2.61]98.2 / 99.1 / 97.3

(a) Valid % = share of outputs that parse into a layout within the 4,096-token budget.

(b) Best-of-8BaseSFTSFT + direct-DSL GRPOSFT + reasoning GRPOΔ reasoning − direct-DSL (paired 95% CI)
Kitchen−3.65 ± 2.885.16 ± 1.515.29 ± 1.486.07 ± 1.15+0.78 [−0.11, +1.79]
Bathroom2.03 ± 1.158.45 ± 0.618.47 ± 0.589.09 ± 0.45+0.62 [+0.34, +0.95]
Living room6.05 ± 1.188.95 ± 0.439.02 ± 0.419.21 ± 0.45+0.20 [−0.11, +0.49]
Bedroom2.56 ± 1.648.61 ± 0.508.68 ± 0.418.86 ± 0.46+0.18 [−0.29, +0.62]
Dining6.93 ± 2.218.17 ± 1.348.83 ± 0.719.48 ± 0.64+0.65 [−0.40, +1.50]
  • Reasoning GRPO is clearly better than direct-DSL in kitchens and dining rooms (mean +1.51 and +1.49), the two room types where a functional group must be arranged around a work or table zone. It is better on best-of-8 in bathrooms (+0.62), and its best-of-8 is the highest of all four models in every room type. In living rooms and bedrooms it is slightly lower on the mean (−0.52, −0.68) and slightly higher on best-of-8 (+0.20, +0.18).
  • Reasoning costs validity and tokens: 2–10% of its outputs fail within the 4,096-token budget, against at most 1% for direct DSL, and its outputs are several times longer.

Do the results still favour reasoning-enabled GRPO? In the matched comparison, reasoning GRPO improves the mean LRS over direct-DSL GRPO in kitchens and dining rooms, and the best-of-8 LRS in bathrooms, with paired 95% confidence intervals excluding zero. It has the highest best-of-8 point estimate in every room type, but the other best-of-8 differences, and its lower means in living rooms and bedrooms, are not statistically resolved. We keep it as the main model for its gains in kitchens and dining rooms and its best-of-8 performance. Its lower means come partially from outputs that do not finish within the token budget; direct-DSL GRPO remains a faster alternative with fewer failures.

Q3. Distinctions from ReSpace and prior RL/preference-based layout methods.

Our contribution relative to ReSpace is RL on the functional quality of the whole room. ReSpace rewards each added object for geometric validity and request match; our reward scores how the objects of the finished room work together (work zones, seating, clearance at doors and windows), so functional coordination becomes an explicit training objective. The reward ablations below show that this functional part drives the gain over SFT; they isolate the reward, not whole-room versus object-by-object generation.

We now cite ReSpace (Bucher & Armeni, 2025) and discuss it in Related Work. Shared ideas: an LLM fine-tuned on a structured scene representation, SFT followed by verifiable-reward post-training, decoupled asset retrieval, and object-level editing.

ReSpaceArchitect-Ant
Unit of generationOne object per call; full scenes by sequential addition from an LLM-planned listThe whole room in one response, so relations between objects are optimised jointly
Room inputFloor/ceiling polygon; no doors or windowsWalls, doors, windows and railings in metres, plus a furniture request
Supported room typesBedrooms and living/dining rooms (3D-FRONT categories)Bedrooms, bathrooms, kitchens, living rooms and dining rooms
RewardBinary pass/fail per object (voxel violation, prompt and size match); the final model uses rejection-sampling fine-tuningGraded whole-room score over 33 rule types, including opening clearance, work zones, seating and wall anchoring
Representation3D boxes with rotation and text descriptions (richer)2D axis-aligned footprints (compact; yaw inferred downstream)
Time per scene (Table 3b)≈ 760 s32 s

Ablations of the reward design. To isolate the reward, we retrain the same model with different rewards and change nothing else. All ablation arms use the direct-DSL GRPO variant: the unified recipe without the reasoning block, which keeps outputs short and the comparison cheap. Kitchen and living room; the held-out evaluation always uses the full score.

  • Binary (our adaptation of ReSpace's pass/fail reward): no grading: +1 if the layout passes all hard geometric and request rules, 0 if it breaks any, −1 if it cannot be parsed; room-specific rules are not used.
  • Geometry-only: our graded score (points per violation), with the room-specific rules removed; geometric and request rules are kept.
Direct-DSL GRPO, reward usedKitchen meanΔ vs SFTLiving-room meanΔ vs SFT
none (SFT start)−0.85–5.70–
full graded, room-aware (ours)0.25+1.10 [+0.24, +2.00]6.54+0.84 [+0.34, +1.39]
binary pass/fail (ReSpace-inspired adaptation)−0.08+0.77 [−0.16, +1.69]6.08+0.38 [−0.10, +0.86]
geometry only−0.73+0.12 [−1.01, +1.23]6.23+0.53 [+0.14, +0.94]

The full graded, room-aware reward improves over SFT in both tested room types, with 95% confidence intervals excluding zero. In kitchens, removing the room-specific rules reduces LRS by 0.98 [0.28, 1.75], while functional violations rise from 4.4 to 5.5 penalty points per room. This supports the contribution of room-specific functional rules.

We also evaluated the released ReSpace model in Table 3b on the 90 bedroom/living/dining shells as its full native pipeline (own planner and shipped search).

Q1. A controlled comparison for Table 3.

We understand the concern that differences in inventories, candidate budgets and inputs prevent attributing the original Table 3 gains to model training. We added a comparison that matches these factors across the regenerated methods, alongside a separate comparison using each trained method's native inputs:

  • Table 3a, matched comparison against SceneSmith (all 109 shells). SceneSmith cannot take a furniture request, and re-running it is impractical (its Table 18: $13.98 and 3 h 26 min per scene on average). Its authors released one selected scene per benchmark shell, which we use as its entry, without resampling or our selection. We give every other method SceneSmith's own furniture list for that shell: the objects of the released scene mapped to our categories, with SceneSmith's sizes. Architect-Ant, LayoutGPT, Holodeck and LayoutVLM then receive the same shell, the same list, the same 4 seeded runs, the same selection rule and the same scorer. The three baselines use the same Gemma-4-31B backbone without our training, with no solver (LayoutGPT), a constraint solver (Holodeck) or a differentiable optimiser (LayoutVLM). Every shell keeps its SceneSmith room type (31 bedrooms, 32 living rooms, 27 dining rooms, 13 kitchens, 6 bathrooms).
  • Table 3b, comparison with the other trained methods on the same SceneSmith shells, restricted to the 90 that all of them can furnish (31 bedrooms, 32 living rooms, 27 dining rooms; the 3D-FRONT methods and ReSpace cannot furnish kitchens or bathrooms). Each method gets its native inputs: Architect-Ant the SceneSmith shell with its doors and windows and a furniture list retrieved from a similar training room; ReSpace (published weights, full native pipeline) the floor shape and a text prompt, its own planner choosing the furniture; ATISS the room shape as a mask; InstructScene a text caption and DiffuScene no input (unconditional), both placed at the centre of the shell. The 3D-FRONT methods and ReSpace choose their own furniture and do not see doors or windows, so this table compares methods as they are used.

Table 3a (SceneSmith's furniture lists, all 109 shells; Architect-Ant, LayoutGPT, Holodeck and LayoutVLM: same shell, list and budget of 4 runs with one selection rule; SceneSmith: its single released scene per shell, not resampled or reselected)

MethodBase modelScenesValid# Obj./room# Obj./10 m²Cov. %COL+ % ↓OOB % ↓Acc. pairs % ↑FUN+ % ↑LRS ↑Time s ↓Req. missing % ↓Door blk % ↓ (raw)Win blk % ↓ (raw)
Architect-AntGemma-41091097.73.7821.80.90.1100.0909.67290.08.8 (10.5)1.9 (6.6)
LayoutGPTGemma-41091097.43.6720.83.82.798.7867.51773.128.9 (30.7)14.0 (15.9)
HolodeckGemma-41091099.64.6730.60.00.099.5919.4551323.30.0 (0.0)32.6 (48.4)
LayoutVLMGemma-41091097.63.7822.10.26.997.9898.819040.016.7 (23.7)5.8 (13.6)
SceneSmithGPT-5.21091098.94.5023.44.01.399.4918.331555–21.1 (22.8)1.6 (2.3)

Architect-Ant has the highest LRS: +1.34 [+0.99, +1.72] over SceneSmith's released scenes, +0.21 [+0.02, +0.41] over Holodeck, +0.86 [+0.64, +1.09] over LayoutVLM and +2.16 [+1.79, +2.54] over LayoutGPT. SceneSmith's own scenes contain some decoration beyond the requested list (e.g. laundry hampers, bath stools, towel ladders, bath mats), which our categories do not cover; it stays in SceneSmith's scored scene, which partly explains its higher object count. Architect-Ant and LayoutVLM place every requested object (0 of 832 missing). LayoutGPT misses 26 (3.1%; mostly rugs 14, beds 3, sofas 3). Holodeck misses 194 (23.3%; chairs 51, rugs 38, floor lamps 23, lamps 17, tables 12), because its LLM object selection treats the list as guidance and substitutes part of it (it adds, e.g., cabinets and side tables). Architect-Ant also leaves windows clear (1.9% blocked vs 32.6% for Holodeck). With the door boxes, Holodeck's solver keeps every door zone clear, but its pipeline does not constrain windows, which is why it blocks many of them. Its solver also guarantees zero collisions, where Architect-Ant has 0.9%.

Reviewer_PgUzOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes a new dataset of floor plans and furniture requests. Given an unfurnished floor plan (walls, windows, doors, empty space) and a furniture request (number, type, and size of furniture) it generates furnished floor plans. The collection consists of 505 plans drawn by professionals with furnitures and they are used to fine-tune a Gemma-4-31B with LoRA to predict the coordinates of each furniture. Separate adapters are trained per room type. Empty floor plans are created by removing the furniture. The method uses RL to create multiple furniture coordinates penalized by 33 hand handcrafted rules (no collisions etc). At inference, given the empty floor plan it retrieves the closest furniture lists (room type and size) from the training set and furnish them and select the best one based on their LRS.

Critical strengths
  • A new datasets is valuable, especially hand drawn plans by experts that include furniture annotations.
  • The goal of adapting furniture placements to new room layouts is valid albeit limited. However is it not clear how close are those generated furnished rooms to the training data.
  • Constraint satisfaction using RL during training is an interesting approach.
Critical weaknesses
  • Why use a learned generator? Given that room geometries are provided with furniture categories and counts and approximate size retrieved from nearest layouts the variability of the generated room could be limited.
  • Large scale generation. The method was not evaluated on large scale generation. It is unclear wether generating thousands of rooms would allow enough diversity for training downstream tasks or the use of the original hand drawn dataset is already as diverse as it gets. Variabiluty in large scale generation.
  • Downstream task usability. The paper does not evaluate any downstream tasks eg. scene graph generation for navigation or spatial understanding etc.
  • Number of distinct categories per room. The paper reports number of instances per room but not number of distinct categories.
Questions for authors
  • How different are the generated layouts from the training examples?
  • How well does the method scale to large-scale generation?
  • Downstream usability example.
3 comments

We thank the reviewer for the constructive feedback and insightful questions.

W1. Why use a learned generator? .. furniture categories and counts and approximate size retrieved from nearest layouts the variability of the generated room could be limited.

The variety of generated rooms is not limited to the retrieved lists. The model follows the furniture list it is given, within the categories of its room type. In Table 3a the lists come from SceneSmith's scenes rather than from our data, and on held-out rooms with their own professional lists the model reproduces the list exactly in 1,958 of 1,969 valid outputs (99.4%; 95.2% of all attempts, see our response to Reviewer Tb1z, Q4). The rooms are new as well: the 109 benchmark rooms come from the SceneSmith benchmark and the large-scale set from 1,000 randomly drawn CubiCasa apartments (Q2).

Retrieval is only our default way to obtain a plausible list when none is given; a user can also write or edit the list (add, remove or resize items) or sample it from a distribution, so retrieval does not fix the generated inventory. When the list for the same room is changed, by a different full list or by a single added, removed, recounted or resized item, the model follows the change (response to Reviewer Tb1z, Q4). The learned generator's role is to adapt the placement to the geometry of the new room: its doors and windows are almost never where the retrieved training room had them (Q1), so the training layout cannot simply be reused.

Q1. How different are the generated layouts from the training examples?

In updated Table 3a (thanks to Reviewer 1t7J) the furniture lists come from SceneSmith's scenes, not from our data, so both the list and the room are new to the model. Our default pipeline retrieves the list from a training room, and even then the room is new.

As retrieval picks a training room of the same type and similar size (frame sizes differ by only 0.13 m, median), but the architecture inside differs: the number of doors differs in 66% of cases and the number of windows in 80%; even when the counts match, at least one door is elsewhere in 47% of cases and at least one window in 88%. For all 109 benchmark rooms, at least one door or window in the retrieved training room does not match the location of a corresponding door or window in the new room. A bed in front of what is now a door would break the room, so the training layout cannot simply be copied.

How we compare. For every layout generated for Table 3a on the 82 shells of the four main types (4 runs each: 328 layouts, 327 of them valid; the 27 dining shells are left out here) we find the most similar training room of the same type among the 2,259 training rooms of these four types, also checking their mirrored and rotated versions. Similarity is the standard box-set matching from layout generation (DocSim, Patil et al., 2020; Max-IoU, Kikuchi et al., 2021): objects of the same category are paired by Hungarian matching and compared by position and size. We then measure how far the furniture is from where it stands in that training room: the shift of each paired object's centre as a share of the room's width and depth, averaged over the room. As a reference we measure the same for 243 real rooms by architects that the model never saw (our validation split).

Average shift vs. the most similar training roomGenerated, Table 3a (327 layouts)Unseen real rooms (243)
under 2% of the room size (practically a copy)0.0%0.9%
2–5%0.3%13.8%
5–10%24.8%35.7%
10–20%67.3%48.7%
20–30%7.6%1.0%
over 30%0.0%0.0%
Average13.1%, 0.61 m10.6%, 0.52 m

On this distance test, no generated layout is a copy of a training room, even mirrored or rotated (0.0% within 2%), while 0.9% of the unseen real rooms by architects are that close to a training room.

Q2. How well does the method scale?

We drew 1,000 CubiCasa apartments uniformly at random and generated 8 layouts for every room of our five room types (bathroom, bedroom, kitchen, living room, dining room (was added thanks to Reviewer Tb1z)):

All 1,000 apartments
Rooms / layouts6,062 / 48,496
Wall clock16.3 h
GPU-hours (2× A100, 2× H100)61.8
Layouts per GPU-hour785
GPU-minutes per room (8 layouts)0.61
Valid layouts90.6%
Cut off at 4,096 tokens9.4%
Rooms with ≥ 1 layout LRS ≥ 883.4%
Mean LRS, selected layout per room (best of 8)8.82
By room typeRoomsValidBest-of-8 LRSMean LRS per layoutRooms with LRS ≥ 8
Bathroom1,69291.4%9.144.8487.8%
Bedroom2,10588.2%8.973.3286.2%
Kitchen1,03486.8%7.430.2761.6%
Living room1,07897.1%9.214.2689.8%
Dining room15394.3%9.957.2299%

W2. Variability at scale.

We represent every room as a scene graph (objects, and relations such as adjacent, facing, on) and count distinct graphs up to isomorphism, as in DisCo (Xu et al., 2024), plus graph entropy as in MSD (van Engelenburg et al., 2024):

  • The professional data is not saturated: 93% of held-out AntPlan rooms have an arrangement graph that never occurs in the 2,259 training rooms of the four main types.
  • At equal sample size, the generated scene graphs are as diverse as professional ones: unique-graph ratio 0.962 vs 0.967 and graph entropy 7.92 vs 7.93 for professional AntPlan rooms, for the selected layout per room (all valid layouts: 0.982 and 7.96). Together with the distance test in Q1, each test covers one aspect of diversity: closeness to the training data, and the variety of object arrangements.
  • Scale adds new arrangements: the 43,920 valid layouts of the 1,000 apartments contain 37,421 distinct arrangement graphs, 93.5% of which never occur in the training data.
  • Sampling gives different arrangements: the 8 layouts of one room contain on average 7.0 distinct arrangement graphs (of 7.25 valid).

W4. Distinct categories per room.

BathroomBedroomKitchenLiving roomDiningAll five
AntPlan, all rooms (2,577)4.916.007.366.213.355.90
AntPlan training rooms (2,320 = 2,259 of the four main types + 61 dining; source of the retrieved lists)4.945.987.356.213.255.91
Generated, Table 3a (435 valid layouts)2.836.325.316.562.375.10
Generated, all 1,000 apartments (43,920 valid layouts)4.485.857.486.922.855.86

Category counts follow the request. In Table 3a the generated layouts have exactly the categories of SceneSmith's lists (same values for the requests), which are short for bathrooms, kitchens and dining rooms. At scale, the counts match the professional data.

Q3. Downstream usability.

The generated layouts support an executed spatial task, beyond visualization or file export. In object-goal navigation planning, an agent reaches 93.7% of object goals in Architect-Ant layouts, i.e. the furniture stays accessible from its usable sides after furnishing (task and comparison below).

Scene-graph export. Every layout is exported as a scene graph, in the file layout of 3DSSG (Wald et al., 2020) and in an equivalent JSON schema: objects.json lists the nodes (room, doors, windows, entrances, and objects with category, footprint, size including height, and front), relationships.json lists typed edges as [subject, object, relation_id, relation]. Trimmed example, a generated Table 3a bedroom:

"objects": [
 {"id": "1", "label": "room",       "attributes": {"room_type": "bedroom", "polygon": [[0.15,0.15],[4.55,0.15],[4.55,4.05],[0.15,4.05]]}},
 {"id": "2", "label": "door",       "attributes": {"center": [0.08,1.85], "width_m": 0.9}},
 {"id": "4", "label": "bed",        "attributes": {"center": [2.86,1.03], "size": [2.07,1.76,0.55], "front": "+y"}},
 {"id": "5", "label": "wardrobe",   "attributes": {"center": [0.75,0.46], "size": [1.19,0.62,2.0], "front": "+y"}},
 {"id": "6", "label": "nightstand", "attributes": {"center": [1.57,0.38], "size": [0.5,0.45,0.55], "front": "+y"}},
 {"id": "7", "label": "entrance",   "attributes": {"door": "door_0", "usable": true}}]
"relationships": [[4,1,1,"in"], [4,1,8,"against_wall"], [4,6,5,"adjacent"], [4,5,6,"near"],
                  [7,2,12,"through"], [4,7,13,"reachable_from"]]

Relations are our own set, computed geometrically from the layout: support and proximity relations in the spirit of 3DSSG (on / inside, adjacent, near), plus layout-specific ones: in, overlaps, facing, against_wall, blocks_door, blocks_window, connects, through, and reachable_from (object → entrance, with path length); apartments add room_door_room links, marked passable when empty and when furnished. A room graph has on average 13 nodes and 45 edges.

Task. Object-goal navigation planning on these environments: a disc agent of radius 0.25 m starts inside each entrance and must reach every object from its usable side, with optimal grid planning. Planner and thresholds are identical for every method.

Table 3a (109 rooms, same furniture lists)Trips reached % ↑Entrances blocked % ↓Objects unreachable % ↓
Architect-Ant93.70.06.3
SceneSmith (released scene)92.80.07.2
LayoutGPT92.93.77.1
Holodeck87.70.012.3

With the same lists and doors given to every method, Architect-Ant reaches the most goals. This shows the generated rooms are usable as structured environments for spatial tasks.

Dear Reviewer PgUz,

We hope our clarifications and additional experiments have addressed your concerns. We would greatly appreciate your consideration of these updates in your final assessment.

Reviewer_Tb1zOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents Architect-Ant and introduces AntPlan, a dataset built from real professional architectural floor plans. The method uses supervised fine-tuning (SFT) and GRPO to generate editable 2D furniture layouts in a domain-specific language (DSL), conditioned on room structure and furniture requirements. These layouts are converted into 3D scenes through asset retrieval and assembly. Training and the main evaluation operate at the individual-room level.

Critical strengths
  1. Relevant data source. Structural and furniture annotations from real professional architectural drawings provide layout priors that are relevant to practical design needs.
  2. Potential for model reuse. LoRA adaptation of an open-weight model provides a foundation for further domain adaptation and local deployment.
  3. Editable outputs. The DSL explicitly represents furniture categories, positions, and footprint dimensions, supporting manual adjustments, geometric checks, and subsequent 3D scene construction.
Critical weaknesses
  1. Limited methodological novelty. The framework primarily combines existing techniques, including SFT, GRPO, rule-based rewards, and candidate selection. Its contributions lie mainly in data curation and system integration, while a distinct methodological advance is not sufficiently established.
  2. Missing orientation in the layout representation. The DSL does not explicitly predict furniture orientation and relies on post-processing rules to recover it. This limits the representation and control of arrangements involving specific orientations or diagonal placement.
  3. Limited coverage and generalization evidence. The dataset contains 505 source floor plans, and the main training and evaluation focus on four room types. Layout diversity, unusual room geometry, and generalization to other room types require further analysis.
  4. Limited scope of functional evaluation. LRS and FUN+ capture selected geometric relationships and minimum functional requirements, but do not fully characterize comfort, aesthetics, or usability in practice.
  5. Substantial input and preprocessing requirements. The method depends on structural images, textual geometry, and furniture requirements. The effects of drawing-parsing errors, scale-calibration errors, and inaccurate structural information have not been sufficiently evaluated.
Questions for authors
  1. How is furniture orientation determined? The DSL does not explicitly encode orientation, yet LRS uses directional conditions involving sofa-facing regions and appliance work zones. Please explain how these directions are inferred and how associated objects are selected when multiple candidates exist, such as a chair near several tables. Are the furniture orientations used for scoring consistent with the actual orientations of the rendered 3D models?
  2. What is the scope of the method? The dataset covers ten room categories, but the main training and evaluation focus on four. Please explain this choice, provide generation results for representative additional room types, and clarify how the whole-house examples are generated and coordinated across rooms.
  3. Is the structural image still necessary for the final model? The visual-input ablation in Table 13 evaluates only the untuned base model. Please compare text-only and text-plus-structural-image configurations under the final SFT+GRPO pipeline, using matched data, training, and sampling settings, to establish the contribution of visual input.
  4. How accurately do the generated layouts follow the requested furniture inventory? Although inventory mismatch is penalized during training, adherence to the input requirements is not separately reported. Please report the proportion of layouts that exactly match the requested categories and per-category counts, statistics on missing and additional objects, and responses to controlled changes in furniture requests for the same room.
5 comments

We thank the reviewer for the valuable feedback and thoughtful questions.

Q1. How is furniture orientation determined?

The model outputs, for every object, an axis-aligned box (position, width, depth) but no facing direction.

In LRS, only kitchen appliances need a direction. The work-zone and fridge-door rules check a free strip on the appliance's outer side, the side facing away from the wall it stands against; if that side is ambiguous (for example, the appliance touches no wall), the appliance is skipped. This happens for 8 of the 169 appliances in the 243 held-out rooms and for none of the 30 in Table 3a. No other rule uses facing: the sofa–TV rule only checks that the TV is in line with the sofa, on either side, and a chair is assigned to the nearest table by distance.

In the 3D scene, every object gets a facing by fixed rules, the same for every method: an object against a wall faces away from it (wardrobes, appliances, sofas, beds, toilets), so an appliance faces the side LRS checks; a chair faces the nearest table; a TV faces the nearest seat; a nightstand copies the bed. The navigation test (response to Reviewer PgUz) uses the same facings.

Measured agreement on the final model's selected layouts (243 held-out and 109 Table 3a rooms): every appliance that LRS checks faces the checked side in the 3D scene (191 of 191).

We chose axis-aligned boxes because in the professional drawings of AntPlan almost all furniture is drawn parallel to the walls, so one box per object captures it.

Q2. What is the scope of the method?

  • Why these room types: bedrooms, bathrooms, kitchens and living rooms carry the dense furniture supervision: 2,595 of 4,495 annotated rooms and 83.7% of room-assigned objects. The other categories are small (80 dining rooms) or sparsely furnished (entries 2.1 objects per room, storage 2.8, balconies 2.8, terraces 1.2).
  • Dining is now a fifth full room type. It is trained with the same recipe and reported in every table: in Table 4 (mean LRS 6.84, best-of-8 9.48 on held-out rooms) and in Table 3a, where the 27 dining rooms are now furnished by the dining model and scored with dining rules.
  • Whole apartments. The input is the full apartment floor plan, and each room is furnished independently by the model for its room type; there is no cross-room objective.

Generalisation and diversity are covered in our response to Reviewer PgUz with two tests: distance to the most similar training room (no generated Table 3a layout is within 2% of one, vs 0.9% of unseen professional rooms) and scene-graph diversity at equal sample size (unique-graph ratio 0.962 vs 0.967, graph entropy 7.92 vs 7.93 for professional rooms). Each test covers one aspect of diversity: closeness to the training data, and the variety of object arrangements.

Q3. Is the structural image still necessary for the final model?

No. We trained text-only and text+image models with identical data, recipe and evaluation; the only difference is whether the image is attached. On the 243 held-out rooms (8 samples each; Δ = text-only − image; 95% CIs clustered by source plan):

Δ mean LRSΔ best-of-8 LRS
Untuned base model (paper Table 17)−1.53 [−2.25, −0.80]−1.59 [−2.36, −0.82]
After SFT+0.12 [−0.14, +0.38]+0.07 [−0.20, +0.33]
After SFT + GRPO (bedroom, 66 rooms)−0.15 [−0.62, +0.36]−0.26 [−0.58, +0.08]

The image matters for the untuned model, but once the model is trained it reads the geometry from the text, which lists every wall, door and window in metres; with training the difference disappears. We therefore dropped the image: every result in the revised paper, including the new Tables 3a, 3b and 5 (thanks to Reviewer 1t7J) and the 1,000-apartment run (thanks to Reviewer PgUz), is generated from text alone. This also removes the image rendering step from the inputs.

W5. Input and preprocessing requirements. (effects of parsing, scale-calibration and structural errors)

Robustness to input errors. We corrupted the shell given to the final model on 60 held-out rooms, with 10 corruptions plus the clean input (a door moved by ±0.15 m, its width changed by ±0.10 m, one door removed, one window removed, wall noise, scale ±10%, a 10% stretch along one axis; 4 samples each), and scored the layout on the true room (clean LRS 6.03):

  • Opening errors cost little: a door moved by ±0.15 m, its width changed by ±0.10 m, or a missing door costs −0.17 to −0.68 LRS, with every interval including zero; a missing window costs −1.18 [−2.29, −0.08].
  • Wall noise (σ = 0.05 m) costs −2.00 [−2.90, −1.14].
  • Scale errors carry straight into the layout: ±10% scale or a 10% stretch costs −6 to −10 LRS, because the model furnishes the room it is shown; scored on that room, LRS stays at 3.4–6.4.

Metric scale calibration is therefore the critical preprocessing step.

Q4. How accurately do the generated layouts follow the requested inventory?

Almost exactly. On the held-out validation rooms, each room is given its own furniture list (8 samples per room). A layout is valid if it is non-empty and parseable; exact means every category and its count equal the request.

Room (held-out rooms)Valid / samplesExact among validMissing / extra objects
Bathroom (74)581 / 592581 / 5810 / 0
Bedroom (66)505 / 528503 / 5051 / 1
Living room (56)435 / 448434 / 4351 / 0
Kitchen (47)339 / 376332 / 3391 / 6
Dining (14)109 / 112108 / 1091 / 0
All1,969 / 2,0561,958 / 1,969 (99.4%)4 / 7 of 15,161 requested objects

The few deviations are one missing chair (twice), curtain or countertop, and six extra countertops in kitchens plus one wardrobe.

Different requests for the same room. The model follows whichever list it is given:

  • Same 109 benchmark shells, two different lists (all 109 pairs differ; 4 runs each): with a list retrieved from a similar training room, 411 of 417 valid layouts are exact (98.6%); with SceneSmith's own list for that shell (Table 3a), 432 of 435 (99.3%). Every shell has an exact layout under both lists.

Controlled single-item edits. On 38 held-out rooms (all five room types), we kept the room and changed its list by one item, with edits fixed before generation (4 runs each, 760 layouts):

EditValidEdited list reproduced exactlyOther objects changed
None (original list)152 / 152151 / 152–
Add one object144 / 152144 / 1440
Remove one object150 / 152150 / 1500
Change one count by ±1143 / 152140 / 1431
Resize one object by ±30%143 / 152143 / 1430

For resized objects, 142 of 143 are placed within ±10% of the new size. Counting invalid outputs as failures, 577 of the 608 edited attempts (94.9%) reproduce the edited list exactly. The model makes the requested change even when it makes the room harder to furnish.

The furniture request therefore remains a controllable input, rather than being fixed by retrieval. The alternative-list and controlled-edit experiments show that the model follows changes to the requested furniture for the same room.

Dear Reviewer Tb1z,

We hope our additional experiments and explanations have addressed your concerns. We would appreciate your consideration of these results when finalizing your assessment.

Comments on the paper

1 comment

We thank all reviewers for their valuable and constructive feedback.

We are glad that the reviewers found value in several aspects of our work:

  • The AntPlan dataset: real professional floor plans with linked structural, room and furniture annotations across 92 classes, which provide layout priors relevant to practical design (Tb1z, PgUz, 1t7J).
  • The rule-based RL approach: constraint satisfaction through GRPO during training (PgUz).
  • Domain adaptation and local deployment: LoRA adaptation of an open-weight model that can be reused and run locally (Tb1z).
  • The editable DSL: explicit categories, positions and dimensions that support manual edits, geometric checks and 3D scene construction (Tb1z, 1t7J).

Contribution. We present a framework that learns whole-room functional furniture arrangement from a limited set of professional floor plans, using GRPO with a reward built from explicit design rules. The closest RL-based precedent, ReSpace, trains a policy that adds one object at a time and rewards geometric validity and agreement with the request. Our reward instead scores the complete arrangement by how its objects work together: appliance work zones, seating relationships and clearance around doors and windows. Functional coordination across the whole room thus becomes an explicit training objective, and it pays off in practice: in both comparison tables Architect-Ant satisfies the layout constraints best (highest LRS). With the same inputs as the other methods (Table 3a), it is also best in object accessibility and requested objects placed, and second in out-of-bounds objects and door and window clearance; against the trained methods with native inputs (Table 3b), it is best in collisions, out-of-bounds objects, functional completeness and door and window clearance. Generating the whole room in one response, without object-by-object addition or an inference-time solver, also makes it about 24× faster than ReSpace and 18× faster than Holodeck with its constraint solver.

We address the reviewers' requests as follows:

  • Controlled comparison with state-of-the-art methods (1t7J). The original Table 3 compared end-to-end pipelines that received different furniture inventories and candidate budgets; we now separate the two settings. Table 3a gives Architect-Ant, LayoutGPT, Holodeck and LayoutVLM the same shells, the same furniture lists (SceneSmith's own), the same budget of 4 runs, the same selection rule and the same scorer. SceneSmith does not accept a furniture list as input, and re-running it is impractical: $13.98 and 3 h 26 min per scene on average, so it enters with its single released scene per shell, without resampling or our selection. Table 3b compares the trained methods with their native inputs, stated per method. We also added reward ablations and a matched direct-DSL vs reasoning GRPO comparison with paired confidence intervals.
  • One recipe for all room types (1t7J, Tb1z). All final models share one text-only SFT + GRPO recipe and one evaluation protocol; dining rooms are now a fifth room type with their own model.
  • Lighter input (Tb1z). The structural image helps only the untrained model; after training, text-only and text+image models are statistically indistinguishable, so we removed the image from the input, which also shortens the prompt.
  • Request adherence and robustness (Tb1z). On held-out rooms the model reproduces the requested furniture list exactly in 99.4% of valid outputs (1,958 of 1,969), which is 95.2% of all attempts (1,958 of 2,056) when invalid outputs count as failures. Single-item edits (add, remove, count, resize) are followed exactly in 99.5% of valid outputs (577 of 580), 94.9% of all edited attempts (577 of 608). We also measured the sensitivity to errors in doors, walls and scale: small opening errors cost little, while scale errors carry into the layout. We also clarify how orientation is inferred and used.
  • Scale and diversity (PgUz). We furnished 1,000 randomly drawn CubiCasa apartments (6,062 rooms, 48,496 layouts, 0.61 GPU-minutes per room). 90.6% of all layouts are valid; 99.5% of the valid ones contain exactly the requested furniture (90.1% of all layouts), and 83.4% of rooms get at least one layout with LRS ≥ 8. Two diversity tests compare generated with professional layouts: distance to the most similar training room (no Table 3a layout is within 2% of one, vs 0.9% of unseen professional rooms) and scene-graph diversity at equal sample size (unique-graph ratio 0.962 vs 0.967, graph entropy 7.92 vs 7.93).
  • Downstream use (PgUz). Every layout is exported as a scene graph, also in the 3DSSG file format, and used for an executed object-goal navigation task; we will publish the generated layouts in this format together with AntPlan.

All these updates are included in the revised version of the paper. We hope they resolve the reviewers' main concerns, and we are happy to answer any further questions.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.