Toward an AI-Native Framework for Constraint-Orchestrated Data Center Architecture

Developed through the working prototype OREXON SYSTEMS.

·  Nouhaila ELMALOULI   ·   Master in AI for Architecture & Business Innovation (MAAI02), IAAC · 2025/2026   ·   Advisor: Dr. Wassim Jabi

Data centers are the physical substrate of artificial intelligence. Every model we train and every query we run lands, eventually, in a room full of racks, power feeds, and cooling loops. Yet the way these rooms are designed has barely changed: floor plans are still drawn discipline by discipline, in sequence, with conflicts discovered late and resolved by hand. My thesis asks whether that process can be rebuilt around the same kind of intelligence the buildings are meant to house.

The result is a framework I call Constraint-Orchestrated Agentic Layout Generation, and a working prototype — OREXON SYSTEMS — that demonstrates it on real data center programs.

The floor plan is a decision matrix

The research focuses on one precise architectural problem: data center floor plan generation. This is not a project about rendering, visualization or generic space planning. It investigates how floor plans can coordinate coupled infrastructural constraints across power, cooling, circulation, operations, compliance and future expansion.

In a data center, the floor plan is never neutral. Moving a data hall changes power routing, cooling distribution, service access, compliance separation, operational flows and future growth capacity. A corridor is not only circulation; it can be a service spine. A mechanical room is not only a room; it is part of an airflow and redundancy strategy. A compliance rule is not only a checklist; it changes spatial relationships.

For that reason, the thesis treats the floor plan as a decision matrix: a spatial expression of infrastructure logic. The complexity is not simply the number of constraints. The complexity is their coupling — the way each decision ripples through every other.

Conventional practice moves through seven disciplines in sequence — architecture, electrical, mechanical, operations, compliance, cost, expansion — each handing work to the next. Conflicts surface exactly when they are most expensive to resolve: deep into a project, when changes cost time, money, and trust.

FIG.  Six floor-plan decisions mapped against six constraint domains. Dense, high-strength coupling is the rule, not the exception — which is why sequential handoffs break down.

Why existing methods fall short

Current design workflows for complex infrastructure are still largely organized through sequential disciplinary handoffs. Architecture, electrical systems, mechanical systems, operations, compliance and cost are often developed through different tools, assumptions and review cycles. The difficulty is that conflicts frequently emerge where these workflows change hands.

A layout may appear valid from an architectural perspective, but later create a cooling bottleneck, a redundancy conflict, a maintenance issue or a compliance risk. By the time these problems are visible, they are expensive to correct. The practical bottleneck is not the lack of tools. It is the lack of an integrated intelligence layer capable of detecting and negotiating conflicts earlier in the design process.

The research therefore asks: how can the design of data center floor plans be restructured through an intelligent workflow capable of coordinating spatial, technical, operational and compliance constraints — simultaneously, from the first line of the brief?

To position the work, the thesis reviews five families of computational paradigms used in floor plan generation and architectural design automation: rule-based systems, optimization methods, deep generative models, LLM-assisted workflows and agentic AI systems.

This diagram shows the basic logic of a deterministic rule engine.

A planning brief enters the system. The rule engine applies if/then logic. Constraints are checked one by one. The result is binary: pass or fail.

This is valuable for compliance and basic validation.

But for data center floor plan generation, many conditions are not binary. They involve trade-offs.

A compact layout may improve cost but worsen cooling. A service corridor may improve operations but reduce spatial efficiency.

So the system needs more than rule checking. It needs coordination.

Optimization methods expand the design space.

Instead of producing only one rule-compliant layout, they can search across many alternatives and balance competing objectives.

Methods such as genetic algorithms and multi-objective optimization are useful because architectural problems often have no single perfect solution.

But the limitation is that optimization tends to treat constraints as objective functions rather than as semantically rich relationships.

It can search, but it does not necessarily understand the architectural meaning of what it is optimizing.

That is why optimization is powerful, but not enough on its own.

Deep generative models represent another important step.

Projects such as House-GAN, House-GAN++, and Graph2Plan show how graph-conditioned models can generate floor plans from structured spatial inputs.

This is highly relevant because it demonstrates that layout generation can be learned from data and represented through graph structures.

However, most of these models are trained on residential typologies.

They generate spatial geometry, but not infrastructure intelligence.

They do not inherently encode power systems, cooling logic, redundancy, standards, compliance, or operational constraints.

So they generate plans, but not necessarily data center plans.

Large language models introduce a different capability.

They are not primarily geometry engines. Their strength is interpretation.

They can read an unstructured brief, extract entities, parse requirements, resolve ambiguity, and transform natural language into structured design information.

In this thesis, the LLM is positioned as a reasoning interface inside a larger workflow.

It helps translate design intent into constraints and schemas.

But it does not autonomously generate validated geometry, simulate technical systems, or close the design loop.

So the LLM is useful, but only as one component inside a larger agentic system.

This matrix summarizes the gap.

Rule-based systems are explainable, but rigid.
Optimization explores alternatives, but lacks semantic depth.
Deep generative models produce geometry, but not infrastructure logic.
LLMs reason about language, but do not close the spatial design loop.

The missing capability is an integrated system that can combine geometry generation, coupled-constraint handling, semantic reasoning, compliance validation, and iterative refinement.

That is the gap this thesis addresses through an agentic AI framework.

The central shift proposed by the research is to move from architecture as drawing to architecture as workflow design. In this model, the architect does not simply produce a final object. The architect designs the process that produces the object — encoding priorities, constraints, trade-offs, and validation logic into an intelligent system that can reason through them in parallel.

This does not remove authorship. It changes its medium. The architect becomes the person who structures the design intelligence: deciding what should matter, what can be traded off, what must remain hard constraint, and how alternatives should be evaluated.

For data center architecture, this shift is crucial. A plan cannot be judged only by shape or area efficiency. It must be judged by how well it coordinates multiple infrastructure systems simultaneously.

A framework: Constraint-Orchestrated Agentic Layout Generation

From geometry to knowledge

Before an AI system can reason about a floor plan, the floor plan must be represented as more than geometry. Geometry describes shape, size, position and boundaries. Topology adds relationships such as adjacency and connectivity. Ontology introduces meaning: what a space is, what it does, what rules govern it. And a knowledge graph connects all of these into a queryable, traversable structure that an agent can navigate.

This representational stack — geometry, topology, ontology and knowledge graph — became one of the core contributions of the research. It allows the data center layout to be treated not only as a drawing, but as a knowledge structure that an AI agent can query, reason about, and modify.

The work is theoretically informed by TopologicPy and the work of Dr. Wassim Jabi, where architectural space is understood as an information-rich topological structure. This is important because data center intelligence cannot live only in pixels or polygons. It needs relationships. It needs traceability. It needs a way to connect an architectural decision to a technical consequence.

A key design choice: standards such as ASHRAE TC 9.9 and the Uptime Institute tiers are modeled as first-class nodes in the graph, not as hidden attributes. Compliance becomes something the system can reason about — not just check at the end.

The knowledge graph as a reasoning layer

In the proposed framework, standards are not treated as passive references at the end of the workflow. They become first-class nodes in the knowledge graph. ASHRAE, Uptime-related requirements, clearance rules, redundancy tiers — all are embedded in the reasoning layer from the start, not appended as post-processing checks.

This makes the layout more explainable. A warning is not just a red flag. It can be traced back to a rule, a standard, a spatial relationship, a system dependency or an evaluation metric. This traceability is what turns compliance from a gate into a conversation.

The graph also gives the interface a different role. It is not only a visualization layer. It becomes a way to inspect the logic of the project: which systems are connected, which rules are active, which constraints are being violated and why — making the design process transparent and auditable.

To test the framework beyond theory, I built OREXON SYSTEMS — a prototype that implements the conceptual stack end to end, from natural language brief to validated, infrastructure-aware floor plan candidates.

The DC Knowledge Explorer: roughly 120 nodes and 200 edges spanning spaces, systems, flows, constraints, standards, and metrics — the reasoning layer made visible.

Seven agents on a shared knowledge graph

On top of that substrate sit seven specialized agents — Spatial, Cooling, Power, Operations, Compliance, Evaluation, and Refinement — each an expert in one domain, all reading from and writing to the same shared knowledge graph. No handoffs. No queues. Parallel negotiation.

OREXON SYSTEMS: a working prototype

From a structured program, the Deployment Studio generates candidate floor plans that already encode zoning, redundancy topology, and clearances — not just polygons, but infrastructure-aware layouts.

▶  Compliance Validation (demo video)

Because the loop produces several candidates, they can be read side by side against the objectives that matter — readiness, power, cooling, reserve, and warning load — so a team can weigh trade-offs in one place instead of arguing over stacked drawings.

A live compliance run: an 84% score, rule landscape by category, and an inspectable ASHRAE TC 9.9 humidity warning with a proposed fix. Upload the full clip (Compliance_Validation_Demo.mp4) to this post in WordPress.

▶  Layout Deployment & Multi-Objective Comparison (demo video)

Generating candidate layouts and comparing Baseline, Redundancy-Focused, and Cooling-Optimized paths across readiness, power, cooling, reserve, and warnings. Upload the full clip (Layout_Deployment_Demo.mp4) to this post in WordPress.

Compliance is continuous rather than terminal. The Compliance view scores a layout against the standards encoded in the graph, surfaces passing and failing rules by category, and proposes remediations — transforming compliance from a final gate into an ongoing design signal.

PROTOTYPE  A generated, redundancy-focused layout for a 20 MW / N+1 program, with inspectable properties for every zone.

What this changes

Replacing sequential handoffs with parallel agent negotiation reshapes the workflow: coordination becomes automatic, evaluation continuous, and multiple validated scenarios become achievable in a single design session — not over weeks of back-and-forth.

Underneath the numbers is a fundamental shift in the architect’s role — from author of form to orchestrator of systems: defining goals and priorities, encoding the brief, reviewing candidates, and validating compliance — while AI handles the combinatorial logic that no single person can hold at once.

The thesis contributes on five fronts: a conceptual four-layer representational stack; the Constraint-Orchestrated Agentic Layout Generation methodology; a structured comparison of five computational paradigms; a domain knowledge graph with ~120 nodes and 200 edges encoding data center infrastructure logic; and the OREXON SYSTEMS working prototype.

It is, of course, a beginning. The prototype is validated on a limited set of configurations; the ontology still needs full OWL/RDF formalization and publication; the evaluation metrics and usability findings need larger samples; and the workflow comparison remains qualitative. The road ahead runs through full ontology publication, expansion to campus and hyperscale typologies, BIM integration, multi-user sessions, quantitative benchmarking, and standards-as-code.

Implications: the architect as orchestrator

The broader implication of the research is not that AI replaces the architect. It is that the architect’s role expands. The architect becomes an orchestrator of systems: defining goals, encoding priorities, reviewing candidates, and validating compliance — with AI handling the combinatorial complexity that no single discipline can fully hold.

This is an important distinction. Automation alone would be a weak ambition. The stronger ambition is augmentation: a design workflow where AI helps expose relationships that are too coupled, too technical, or too numerous for any single discipline to manage alone — and where the architect retains authorship over what matters most.

For AI infrastructure, this shift is especially urgent. The next generation of data centers will not be evaluated only by how much compute they contain. They will be evaluated by where they are located, how efficiently they use power and water, how resilient they are to failure, and how quickly they can be adapted to new requirements. That is a design problem as much as an engineering one.

Research contributions

The thesis contributes conceptually by proposing a four-layer representational stack: geometry, topology, ontology and knowledge graph. It contributes methodologically through the framework of Constraint-Orchestrated Agentic Layout Generation. Technically, it delivers a working prototype and a domain knowledge graph encoding data center infrastructure logic. Practically, it demonstrates that multiple validated floor plan scenarios can be generated in a single design session.

The work remains at prototype stage. The system has been tested on limited configurations, the ontology requires further formalization, evaluation metrics need larger-scale validation and benchmarking against traditional workflows remains a future research direction. These limitations are not secondary details; they define the next trajectory of the work.

Future development includes ontology publication, standards-as-code, BIM workflow integration, multi-user collaborative sessions, campus-scale typologies and quantitative benchmarking. The long-term ambition is a design intelligence layer that makes data center architecture faster, more coherent, and more defensible — at every stage of the process.

Closing reflection

This research began with a simple provocation: if AI is transforming the world, can AI also help us design its own physical infrastructure? The answer is not a single generated image or a fully autonomous system. The answer is a framework — a way of encoding architectural intelligence into a process that can reason, evaluate, and refine in collaboration with a designer.

AI infrastructure is physical. It occupies land, consumes energy, produces heat, requires redundancy, creates environmental consequences and demands architectural decisions. To design it responsibly, we need workflows that are as sophisticated as the systems they produce.

Orexon Systems emerged from this research as one possible direction: an attempt to transform data center planning from late-stage coordination into early-stage architectural intelligence.