Plausible Is Not Buildable: The Case for Verifiable AI in Architecture

Generative models can now produce floor plans, massing studies, and urban layouts that look convincingly like the work of designers. The question that matters for practice is different: not whether a model can produce something plausible, but whether anyone can verify that what it produced is correct.

A rendering that violates egress requirements is not a design, it is a liability. This distinction, between generating and guaranteeing, is becoming the organizing problem of AI in the built environment, and the research literature has begun to answer it with a specific architecture: learned models for perception and proposal, symbolic systems for constraint and proof, and open data standards as the substrate that connects them.

Sheth, Roy, and Gaur frame the general version of this argument: capable AI systems need both machine perception, which turns raw data into symbols, and machine cognition, which reasons over those symbols against explicit knowledge, and the pairing matters most in domains where decisions must follow articulable guidelines.^[1] Architecture is such a domain in an unusually literal sense. Building codes are articulable guidelines with the force of law, and a licensed professional must be able to justify a design against them. What follows surveys how five research threads converge on that requirement.

Architecture's symbolic tradition predates the neural one

It is tempting to narrate AI in architecture as beginning with deep learning. The record says otherwise. In 1972, two formal programs launched that still structure the field. Stiny and Gips introduced shape grammars, rule systems that generate designs by successive transformation; a fifty-year systematic mapping of the literature finds that their dominant application has been, from the start, the generation of two-dimensional floor plans.^[2] The same year, Bill Hillier founded what became the Space Syntax Laboratory at UCL, representing buildings and cities as configurations, graphs of convex spaces and axial lines whose mathematical properties predict movement and co-presence.^[3] Two decades later, Smith and Park formalized qualitative spatial reasoning itself, showing that inference over topological relationships among spatial objects could be made sound and complete within relation algebra and computed by constraint satisfaction.^[4]

These are not historical curiosities. They established the two representations that modern machine learning in architecture depends on: the building as a rule-governed derivation, and the building as a graph. The mapping study of shape grammars also records the tradition's standing weakness, a persistent gap between formal elegance and usability by non-expert designers.^[2] That gap is precisely what learning-based methods are now being asked to close.

Buildings are graphs, and the models have caught up

A building is a heterogeneous graph: rooms connected by adjacency and circulation, structural members connected by load paths, mechanical systems connected by service relationships. Graph neural networks, which propagate information along edges by message passing, are the natural learning machinery for such data, and the model families now standard in the field are well documented in recent surveys.^[5]

Two results matter specifically for architecture. Graph Transformer Networks showed that a model can learn which compositions of edge types matter for a task rather than requiring hand-specified relational paths,^[6] which is exactly the situation in building data, where the analyst rarely knows in advance whether the informative path runs through spatial adjacency, structural support, or duct connectivity. And StructureNet demonstrated that generation itself can respect structure by construction, encoding shapes as part hierarchies with relationship edges such as symmetry and adjacency, so that a generative model manipulates a building-like decomposition rather than unstructured geometry.^[7]

The graph view also disciplines the data problem. Moradi and colleagues built a pipeline that extracts adjacency matrices from roughly 12,000 residential floor plan drawings at 91.5 percent average precision, converting archives of legacy drawings into machine-readable topology.^[8] Zheng and Petzold closed the loop in the generative direction: their system takes an architect's bubble diagram, the graph of intended rooms and adjacencies, and generates layouts constrained to respect it, decoupling topological prediction from geometric resolution.^[9] The designer states intent at the level of relationships; the model resolves geometry.

The strongest peer-reviewed demonstration of this paradigm operates at the urban scale. Zheng et al., in Nature Computational Science, formulated community-scale spatial planning as sequential decision-making over an urban contiguity graph and trained a graph-based reinforcement learning agent against measurable 15-minute-city objectives. The system improved spatial efficiency metrics by over 48 percent against baselines, produced plans Pareto-optimal against all eight professional planners invited to compete on two real Beijing communities, and, in the workflow the authors actually recommend, acted as a collaborator: humans did conceptual prototyping, the agent did spatial optimization, and the hybrid workflow beat the fully human one by 12.3 percent on service accessibility.^[10] The authors are explicit that the system is no replacement for human designers and that real-world constraints such as land ownership were out of scope. The result is best read not as automation of planning but as evidence that graph representations make spatial design objectives optimizable.

Learning on geometry itself

Between the drawing and the graph sits geometry, and a distinct line of research has made neural networks respect its structure. Buildings do not have a preferred orientation; a model that must relearn a truss under rotation is wasting its training data. SE(3)-equivariant attention networks guaranteed that outputs transform predictably under 3D rotation and translation,^[11] and the line has since matured through Clifford group equivariant networks^[12] to the Geometric Algebra Transformer, which represents points, planes, directions, and rigid motions in a single algebraic token space with full E(3) equivariance at transformer scale.^[13] For a field whose data is walls, planes, axes, and rigid assemblies, this is the closest current template for a geometry-native model backbone.

Deployment in practice, however, is gated less by benchmark accuracy than by robustness to how geometry arrives. Scan data and authored models are different discretizations of the same building. DiffusionNet addressed this directly: by making learned diffusion the only spatial operation, it trains on triangle meshes and evaluates on point clouds without retraining.^[14] DeltaConv built anisotropic, direction-aware operators for raw point clouds,^[15] the native output of laser scanning and the entry point of every scan-to-BIM pipeline. And for tasks where being topologically right matters more than being pixel-perfect, exactly the situation in room-connectivity extraction, persistent-homology losses let a network be trained to match a specified topology directly.^[16]

The neurosymbolic turn: learning that answers to rules

None of the above guarantees compliance. A generative model, however well structured, samples from a distribution; a building code is not a distribution, it is a set of predicates. The research program now called neurosymbolic AI exists to connect the two, and its main variants map cleanly onto architectural needs.

Logic Tensor Networks ground first-order logical axioms as differentiable objectives, so a generator can be trained to satisfy declaratively written rules, adjacency requirements, dimensional bounds, zoning envelopes, as soft constraints during learning rather than filters after it.^[17]DeepProbLog embeds neural networks as probabilistic predicates inside a logic program, the template for pipelines where a network reads a drawing and a rule system reasons over what it reads, trained end to end.^[18] Scallop industrializes the pattern with a Datalog-based language supporting recursion and aggregation, which is what spatial queries actually need: circulation reachability is recursive, area compliance is an aggregate.^[19] Logical Neural Networks add something practice will recognize immediately, truth maintained as bounds under an open-world assumption, so a system can report what a partial design already entails, what it contradicts, and what remains open, which is how code review of schematic designs actually proceeds.^[20] And differentiable inductive logic programming showed that explicit, human-readable rules can be induced from noisy data,^[21] pointing at the extraction of inspectable design grammars from a firm's own messy precedent archive rather than from a curated benchmark.

The critical caveat is that all of these satisfy constraints softly, by degrees. Fuzzy satisfaction is the right tool during training and the wrong tool for sign-off. For hard guarantees the relevant technology is older and sharper: satisfiability modulo theories. Z3, the de facto standard SMT solver, decides first-order formulas over arithmetic, arrays, and other theories, returning either a satisfying assignment or a proof of infeasibility.^[22] Encoded as SMT constraints, a code provision is not a preference the model tends toward; it is a predicate the design either satisfies or provably cannot. The mature stack is therefore two-layered: differentiable logic shapes what models propose, and a solver verifies what they deliver. This is the architecture the strongest current tools are converging on, learned proposal contained by deterministic verification.

The same conclusion is now arriving from the language model systems community by a different route. Zhang argues that the harness, the programmatic layer between a model and its environment, should carry the burden of compositional generalization: decompose a task so that each individual model call stays close to the distribution the model was trained on, and what the system learns generalizes across task lengths and domains far better than scaling the network alone, with harness-mediated training shown to transfer to tasks 8 to 32 times longer than any seen in training.^[30] For the built environment, the harness is not an abstraction. It is the graphs, the standards, and the solvers described here, and its design, not model size, is what determines whether AI on buildings can be trusted.

The data layer decides what is learnable

Every thread above presumes machine-readable building data, and here the field's advantage is real but uneven. Industry Foundation Classes, standardized as ISO 16739, give the built environment something most industries lack: an open, vendor-neutral schema for geometry, elements, properties, and relationships across the building lifecycle, extended in IFC 4.3 to linear infrastructure.^[23] Open tooling makes the standard computable: IfcOpenShell parses, modifies, and converts IFC across schema versions and serializations, the practical bridge from the standard to learnable structures,^[24] while BHoM offers a code-centric, discipline-spanning object model as an alternative interoperability route.^[25] Once building data is a graph with typed relations, knowledge graph embedding libraries such as PyKEEN make link prediction and semantic enrichment over that graph a commodity operation.^[26]

What is uneven is the labeled data itself. Yu et al. quantified the problem for BIM element classification: real model archives are badly class-imbalanced, and training on them yields 84 percent accuracy; parametrically generated synthetic elements, balanced across categories, raise it to 95 percent, with minority classes gaining roughly 80 points.^[27] The lesson generalizes: within any single firm, the data is limited to that firm's models and libraries. Amer, Jung, and Golparvar-Fard demonstrated how much tacit knowledge such records hold, training a transformer on construction schedules to learn dependency logic that superintendents know but never encode, at 91 percent F1, and using it to generate revised lookahead plans automatically.^[28] Firm archives are, collectively, a large and largely unmined corpus of design and construction knowledge.

Collectively is the operative word, and it points at the last thread. Firms will not, and mostly cannot, pool proprietary project data. Federated learning trains shared models while raw data stays where it is, exchanging only model updates, and open frameworks such as Flower have made the pattern deployable, with production precedents in domains at least as confidentiality-bound as construction, including hospital networks.^[29] An industry of tens of thousands of small firms, each holding a sliver of the total evidence about how buildings get designed and built, is close to the ideal case for the approach.

Conclusion

Read together, these literatures describe a consistent architecture rather than a collection of demos. Architecture's own formal traditions, grammars, configuration graphs, and spatial relation algebras, supplied the symbolic spine decades early. Graph and geometric deep learning now supply perception and proposal over that spine, with equivariance and discretization robustness addressing the conditions of real practice rather than benchmarks. Neurosymbolic methods connect learned models to declarative rules during training, and solvers such as Z3 convert compliance from a tendency into a proof at delivery. Open standards and open tooling determine what is learnable at all, synthetic data patches what individual archives lack, and federated learning offers a path to learning from the industry's collective record without asking anyone to surrender it.

The practical implication is a division of labor. Models propose; solvers verify; standards carry meaning between them; and designers, as the strongest empirical work in the field takes care to state, remain the ones deciding what is worth proposing. The systems that will matter in practice are not the ones that generate the most convincing plans. They are the ones that can show their work.

References

1. A. Sheth, K. Roy, M. Gaur. Neurosymbolic AI: Why, What, and How. IEEE Intelligent Systems, 2023. https://arxiv.org/abs/2305.00813
2. S. M. Haakonsen, A. Ronnquist, N. Labonnote. Fifty years of shape grammars: A systematic mapping of its application in engineering and architecture. International Journal of Architectural Computing 21(1), 2023. https://journals.sagepub.com/doi/full/10.1177/14780771221089882
3. Space Syntax Laboratory, The Bartlett School of Architecture, UCL. Founded 1972. https://www.ucl.ac.uk/bartlett/architecture/research/space-syntax-laboratory
4. T. R. Smith, K. K. Park. Algebraic approach to spatial reasoning. International Journal of Geographical Information Systems 6(3), 1992. https://www.tandfonline.com/doi/abs/10.1080/02693799208901904
5. B. Khemani, S. Patil, K. Kotecha, S. Tanwar. A review of graph neural networks: concepts, architectures, techniques, challenges, datasets, applications, and future directions. Journal of Big Data 11:18, 2024. https://link.springer.com/article/10.1186/s40537-023-00876-4
6. S. Yun, M. Jeong, R. Kim, J. Kang, H. J. Kim. Graph Transformer Networks. NeurIPS 2019. https://arxiv.org/abs/1911.06455
7. K. Mo, P. Guerrero, L. Yi, H. Su, P. Wonka, N. Mitra, L. J. Guibas. StructureNet: Hierarchical Graph Networks for 3D Shape Generation. ACM Transactions on Graphics (SIGGRAPH Asia), 2019. https://arxiv.org/abs/1908.00575
8. M. A. Moradi, O. Mohammadrashidi, N. Niazkar, M. Rahbar. Revealing connectivity in residential architecture: An algorithmic approach to extracting adjacency matrices from floor plans. Frontiers of Architectural Research 13(2), 2024. https://www.sciencedirect.com/science/article/pii/S2095263523000924
9. Z. Zheng, F. Petzold. Neural-guided room layout generation with bubble diagram constraints. Automation in Construction 154, 2023. https://www.sciencedirect.com/science/article/abs/pii/S0926580523002224
10. Y. Zheng, Y. Lin, L. Zhao, T. Wu, D. Jin, Y. Li. Spatial planning of urban communities via deep reinforcement learning. Nature Computational Science 3, 2023. https://www.nature.com/articles/s43588-023-00503-5
11. F. B. Fuchs, D. E. Worrall, V. Fischer, M. Welling. SE(3)-Transformers: 3D Roto-Translation Equivariant Attention Networks. NeurIPS 2020. https://arxiv.org/abs/2006.10503
12. D. Ruhe, J. Brandstetter, P. Forre. Clifford Group Equivariant Neural Networks. NeurIPS 2023. https://arxiv.org/abs/2305.11141
13. J. Brehmer, P. de Haan, S. Behrends, T. Cohen. Geometric Algebra Transformer. NeurIPS 2023. https://arxiv.org/abs/2305.18415
14. N. Sharp, S. Attaiki, K. Crane, M. Ovsjanikov. DiffusionNet: Discretization Agnostic Learning on Surfaces. ACM Transactions on Graphics 41(3), 2022. https://dl.acm.org/doi/10.1145/3507905
15. R. Wiersma, A. Nasikun, E. Eisemann, K. Hildebrandt. DeltaConv: Anisotropic Operators for Geometric Deep Learning on Point Clouds. ACM Transactions on Graphics 41(4), SIGGRAPH 2022. https://dl.acm.org/doi/10.1145/3528223.3530166
16. J. R. Clough, N. Byrne, I. Oksuz, V. A. Zimmer, J. A. Schnabel, A. P. King. A Topological Loss Function for Deep-Learning based Image Segmentation using Persistent Homology. IEEE TPAMI, 2020. https://arxiv.org/abs/1910.01877
17. S. Badreddine, A. d'Avila Garcez, L. Serafini, M. Spranger. Logic Tensor Networks. Artificial Intelligence 303, 2022. https://arxiv.org/abs/2012.13635
18. R. Manhaeve, S. Dumancic, A. Kimmig, T. Demeester, L. De Raedt. DeepProbLog: Neural Probabilistic Logic Programming. NeurIPS 2018. https://arxiv.org/abs/1805.10872
19. Z. Li, J. Huang, M. Naik. Scallop: A Language for Neurosymbolic Programming. 2023. https://arxiv.org/abs/2304.04812
20. R. Riegel et al. Logical Neural Networks. 2020. https://arxiv.org/abs/2006.13155
21. R. Evans, E. Grefenstette. Learning Explanatory Rules from Noisy Data. Journal of Artificial Intelligence Research, 2018. https://arxiv.org/abs/1711.04574
22. L. de Moura, N. Bjorner. Z3: An Efficient SMT Solver. TACAS 2008. https://github.com/Z3Prover/z3
23. buildingSMART International. Industry Foundation Classes (IFC), ISO 16739-1. https://technical.buildingsmart.org/standards/ifc/
24. IfcOpenShell: open source IFC toolkit and geometry engine. https://ifcopenshell.org/
25. BHoM: the Buildings and Habitats object Model. https://github.com/BHoM/BHoM
26. M. Ali et al. PyKEEN: A Python library for training and evaluating knowledge graph embeddings. JMLR, 2021. https://github.com/pykeen/pykeen
27. Y. Yu, D. Ha, K. Lee, J. Choi, B. Koo. ArchShapesNet: a novel dataset for benchmarking architectural building information modeling element classification algorithms. Journal of Computational Design and Engineering 9(4), 2022. https://academic.oup.com/jcde/article/9/4/1449/6650220
28. F. Amer, Y. Jung, M. Golparvar-Fard. Construction schedule augmentation with implicit dependency constraints and automated generation of lookahead plan revisions. Automation in Construction 152, 2023. https://www.sciencedirect.com/science/article/abs/pii/S0926580523001565
29. D. J. Beutel et al. Flower: A Friendly Federated Learning Research Framework. https://flower.ai/
30. A. Zhang. Language Model Harnesses and Compositional Generalization. 2026. https://alexzhang13.github.io/blog/2026/harness/