Introduction


Planning an office layout can be more complex than it seems. Decisions must be made about where to place departments, how to connect them, who gets window access, and many other factors. Traditionally, human designers have relied on experience and intuition to handle these issues. Now, by combining Large Language Models (LLMs) with parametric models and optimization algorithms, it’s possible to achieve far more efficient and creative outcomes.

This article explains how office layouts have traditionally been designed and how LLMs can enhance that process, as well as how parametric models and optimization algorithms can work together to generate the best results. We’ll also look at practical ways to divide zones, allocate windows, and optimize adjacency relationships.


Traditional Design Methods

When human designers plan an office layout, they typically follow these steps:


  1. Identify User Requirements and Program
    • Gather information about the client (or company), such as team sizes, required spaces (open workstations, private offices, meeting rooms, lounges, etc.).
    • Understand how the organization operates, its collaboration needs, and physical constraints (building structure, regulations).

  2. Adjacency Planning
    • Determine which departments need to be near each other, who communicates frequently, etc.
    • Tools like bubble diagrams or an adjacency matrix visualize relationships (e.g., “Departments A and B work closely, so they should be adjacent”).

  3. Space Planning
    • Based on the building’s floor plan, decide how much area to allocate to each zone.
    • Consider columns, walls, windows, emergency exits, etc., checking whether the layout has convenient circulation, sufficient noise control, and so on.
    • The designer typically iterates through multiple sketches, adjusting furniture, partitions, doors, corridors—almost like solving a “jigsaw puzzle.”

  4. Finalizing the Layout and Details
    • Once the design seems “ideal,” determine precise dimensions, choose furniture, finalize finishes, etc.
    • Incorporate on-site conditions or client feedback to produce the final version.

Although this traditional process leverages the designer’s expertise and intuition, it requires a lot of time and many iterations. Also, it can be challenging to consistently handle numerous factors (building codes, collaboration needs, brand identity) without missing something.


LLMs, Parametric Models, and Optimization Algorithms


If we integrate LLMs with parametric models and optimization algorithms into this traditional workflow, we can identify three main pillars:

  1. LLM (Large Language Model)
    • Interprets human-language requirements (e.g., “We want a more conservative office atmosphere, so private offices should face the windows.”).
    • Based on guidelines such as “Only 25% collaboration space needed” or “Position private offices near windows,” it decides how many zones to create, which functions they serve, and how much window coverage each zone gets.

  2. Parametric Model
    • Defines the design process (which used to be done by hand sketches) as parameters.
    • Uses rule-based methods like rectangle decomposition and bin-packing algorithms to split and fill space.
    • Automatically generates multiple layout options by varying these parameters.


  1. Optimization Algorithm
    • After the LLM has proposed certain parameter combinations (e.g., “50% of windows reserved for private cells”), it generates a large number of layout candidates, then evaluates each to find the top-scoring ones.
    • Considers adjacency (graph structure), window usage, or the ratio of collaboration vs. focus zones, among other factors, to compute a composite score.


Finally, the LLM reevaluates these top candidates and recommends which layout best aligns with the client’s requirements and the design vision.


How Does AI Complement the Architect’s Role?

Automating Repetitive Sketching

Previously, an architect might do a series of sketches, moving furniture, adjusting corridor widths, or redistributing windows—potentially dozens of times. Now, a parametric model automates these “repetitive sketches.” The designer gives the LLM a few “guidelines,” and the system generates multiple floor plan drafts.


Consistently Applying Rules and Constraints

In the past, adjacency matrices or bubble diagrams were used to show who needs to be close to whom. A graph plus optimization algorithm can handle these rules comprehensively. - “IT support must be central to all teams.” - “Meeting rooms should be near the entrance.” - “Loud copy/printing areas must be placed away from quiet zones.” Rather than manually ensuring all these conditions, an algorithm can score adjacency relationships and pick the layout that best satisfies them.


Providing “Automatic Assistance” for the Designer’s Intuition

LLMs can translate abstract demands—“The client wants a more conservative feel,” “Employees value natural light”—into quantifiable parameters. For example: - “Private cells occupy 75% of the windows.” - “Collaboration areas only 25% of the floor.” Once converted to numbers, the optimization algorithm can generate and evaluate layouts that meet these preferences. The designer picks one they like and refines it based on human judgment (aesthetics, corporate culture).


Key Decisions LLM Makes


An LLM does more than just parse text. It interprets prompts to address critical questions:

  1. “Into how many zones should the office be divided?”
    • For instance, “How many private cells do we need?”
    • A conservative office may tightly group private offices along the windows, while a collaborative office might favor an open plan.

  2. “Which function does each zone serve?”
    • Should private cells be for individual work or small meetings?

  3. “How much of the windows should private cells occupy—100%, 50%, etc.?”
    • The LLM decides and quantifies these details based on the company’s operations (heavy meetings, greater need for privacy, etc.).

  4. “How should adjacency relationships be configured?”
    • Should focus zones and social zones be adjacent or separated?
    • The optimization algorithm encodes these relationships as a graph and ranks them, while the LLM ultimately decides which graph structure is “most ideal.”


Role of the System Prompt

  • Defines criteria the LLM should follow when optimizing the office layout.
  • Instructs the LLM on how to interpret user requirements (layout, orientation, openness) and produce relevant design decisions.
  • Ensures the LLM references specific evaluation metrics and recommends the best solution.


System Prompt Example


    The `RESPONSE_FORMAT` describes the final JSON structure. This structure has `"type": "json_schema"`. 
    Inside `"json_schema"`, we set `"name": "OfficeLayoutSchema"`, then define an object under `"schema"`, specifying `"properties"` like `candidate_index` (integer) and `reasoning` (string). These two properties are `"required"`. 
    In other words, the final output must include a `candidate_index` that indicates the best design candidate, plus a `reasoning` field explaining why.

    Additionally, the entire `SYSTEM_PROMPT` details how to plan an office layout, instructing the LLM on analysis methods. 
    The core idea is to parse the user’s requirements and pick the best candidate design, then return it as `candidate_index`. 
    Notably, priorities such as `target_focus`, `target_social`, `target_collab`, and `adjacency_preferences` must be satisfied first. 
    If the user specifies `direction` requirements, each zone’s cardinal orientation (east/west/north/south) should also be considered.

    The `analysis_dict` references several items like `total_area` (total zone area), `zone_area_by_type` and `zone_area_ratio_by_type` (area distribution across zone types), and `direction_distribution_by_type` for cardinal orientations. 
    It also includes metrics like `no_window_area_ratio` and `private_vs_open_area`, allowing the system to evaluate how open or closed the layout is, whether it’s uniform or diverse, if it’s flexible or monolithic, etc.

    To accomplish this, the system calculates seven key metrics, such as `compute_diversity_ratio` (uniform vs. diverse) and `compute_open_space_ratio` (closed vs. open), `compute_soft_boundary_score`, `compute_transparency_score`, `compute_flexibility_score`, `compute_modular_score`, and `compute_mixed_use_score`. 
    These range from zero (completely one extreme) to one (the opposite extreme).


Parametric Model

Even if the LLM makes certain design decisions, you don’t get just a single floor plan automatically. A parametric model is needed to combine many conditions and generate multiple possible layouts:

  • Overall building outline and column locations: provided as input.
  • Doors, windows, corridors: specified as parameters for zone allocation, corridor widths, etc.
  • Desired percentages: e.g., 30% focus, 50% collaboration, 20% social.
  • LLM-driven options: e.g., “Only 25% of windows for private cells,” or “Only 2 private meeting rooms.”

In other words, the parametric model acts like an “engine” that takes (rules + variables) to produce countless layout solutions.


Optimization Algorithm

Once the system has placed zones, it calculates various metrics for each candidate layout. For instance, an analysis_dict might look like this:


    analysis_dict = {
        "total_area": total_area_all_zones,
        "zone_area_by_type": zone_area_by_type,
        "zone_area_ratio_by_type": zone_area_ratio_by_type,
        "no_window_area_ratio": no_window_area_ratio,
        "private_vs_open_area": {
            "private_percent": private_area_pct,
            "open_percent": open_area_pct,
        },
        "direction_score": direction_score,
    }
    candidate["analysis"] = analysis_dict
    scores = compute_strategy_scores(analysis_dict, total_zones=total_zones_count)
    candidate["strategy_scores"] = scores
    candidate["direction_score"] = direction_score

It then computes seven strategic scores (e.g., how open, diverse, flexible the layout is) and directional analysis (orientation, cardinal direction usage). The algorithm uses these scores to identify top-ranked solutions.


Selecting Final Candidates and LLM Refinement

After running the optimization, multiple “best” solutions emerge. Here, the LLM returns, using the initial design philosophy and preferences (e.g., “emphasis on private space, 25% collaboration, social zone on the east side, conservative mood”) to finalize which candidate is best. For example, the system might compile data from each candidate like so:


    all_candidates_data = []
    for idx, candidate in enumerate(top_candidates):
        candidate_data = {
            "candidate_index": idx,
            "analysis": candidate.get("analysis", {}),
            "adjacency_info": candidate.get("adjacency_info", {}),
            "strategy_scores": candidate.get("strategy_scores", {}),
            "direction_score": candidate.get("direction_score", {}),
            "focus_ratio": candidate.get("focus_ratio", None),
            "social_ratio": candidate.get("social_ratio", None),
            "collab_ratio": candidate.get("collab_ratio", None),
        }
        all_candidates_data.append(candidate_data)


Example: Parameter Suggestions and the Final Outcome

Using the System Prompt described above, the LLM constructs a JSON response based on the user’s requirements and various guidelines. For instance:


    {
    "focus": 40,
    "social": 30,
    "collaboration": 30,
    "member_type": "Collaborative",
    "plan_type": "Mixed Type",
    "atmosphere_type": "Dynamic & Collaborative",
    "density_type": "Medium Density",
    "cell_type": 1,
    "private_cell_to_collab_ratio": 1,
    "focus_preset_id": 2,
    "split_density": 1,
    "closed_or_opened_focus": 0,
    "reasoning": "We set a 40:30:30 ratio for balanced quiet vs. collaborative areas. About half the windows are assigned to private cells; the rest is for collaborative zones..."
    }

With these parameters in place, the optimization algorithm generates floor plans, evaluates them, and ultimately the LLM chooses the best layout.


Conclusion

Because the LLM transforms natural-language requirements into formal design parameters, even abstract ideas—like corporate culture—become part of the design logic. The parametric model then uses these parameters to systematically produce design proposals, accounting for the building’s structure, floor areas, window distribution, and furniture layouts. Finally, an optimization algorithm swiftly explores countless candidates, filtering for adjacency, space usage, orientation, and flexibility.


Result Examples

By leveraging these three pillars—LLM, parametric modeling, and optimization—designers can generate office layouts far more quickly and innovatively than before, while focusing their attention on creativity and unique design expertise.