Routing conduit, duct, and pipe through a congested ceiling is one of the hardest puzzles in construction: thousands of runs competing for the same plenum, each needing to clear the others, hold its code clearances, stay fabricable, and reach its destination by a sensible path. A skilled MEP coordinator solves it slowly, run by run, drawing on years of knowing what works. Generative design tools like Augmenta and EvolveMEP attack it differently, generating and evaluating thousands of candidate routings automatically, exploring a solution space far larger than any human could and surfacing routes that are shorter, cleaner, and more prefab-friendly than hand routing. This is the generative-design engine from Level 1 doing exactly what it is best at. But generative design has a precise and dangerous property: it optimizes exactly what you tell it to optimize, including by ignoring everything you did not tell it, so a generated route can be mathematically optimal and practically unbuildable. This lesson shows you how to use generative MEP routing to explore the space while keeping the selection and the constructability judgment where they belong.

The Routing Problem and Why Generative Design Fits

MEP routing is a combinatorial optimization problem of brutal size. In a congested ceiling, every duct, pipe, conduit, and cable tray must find a path from origin to destination that avoids every other system, the structure, and the architectural constraints, while holding slopes for drainage, clearances for code and maintenance, and bend limits for fabrication. The number of possible routings is astronomical, and a human coordinator can explore only a tiny fraction, settling on the first workable solution rather than the best one because there is no time to try thousands of alternatives. The result is routing that works but is rarely optimal, with more material, more fittings, and more fabrication complexity than necessary.

Generative design fits this problem precisely because it is built to explore vast solution spaces against defined objectives, which is what the routing problem is. Tools like Augmenta for electrical and MEP routing and EvolveMEP generate thousands of candidate routings, evaluate each against the objectives, length, fitting count, clash avoidance, fabrication efficiency, and surface the best candidates, exploring a fraction of the space no human could reach. This is genuine, powerful value: the generative engine can find routings that are materially shorter, use fewer fittings, are easier to prefabricate, and are fully clash-free, because it can actually try the thousands of alternatives a human cannot. The value is real and it is exactly what the generative-design engine is for. But the engine's power comes from optimizing against the objectives it is given, and that is the source of both its value and its specific, characteristic failure.

The Objective Function Problem: It Optimizes What You Specify

The defining property of generative design is that it optimizes exactly the objective function you give it, with total literalness, which means it optimizes for what you specified and ignores everything you did not. If you tell it to minimize total length and fitting count while avoiding clashes and holding clearances, it will find the routing that does that best, and it will cheerfully sacrifice anything you did not list to win on the things you did. The generated optimum is optimal only with respect to the stated objectives, and any real-world consideration absent from the objective function is, from the engine's view, free to violate.

This is the heart of generative design's risk, and it is different from the hallucination risk of language models. The generative engine is not making things up; it is correctly solving the problem you posed, but the problem you posed is almost always an incomplete model of the real problem, because the real constraints on MEP routing are too numerous, too tacit, and too contextual to fully encode. The coordinator knows a hundred things that make a route good or bad, the trade that installs first needs its run accessible, the valve needs to be reachable from a ladder, this area will get a future tenant fit-out so leave room, that beautiful short route crosses three other trades' work in a sequence that makes it impossible to install, that are not in the objective function and that the engine therefore optimizes straight through. So the generated route can be optimal on length and fittings and clashes and still be unbuildable, because it won those metrics by violating the unstated constraints that actually govern whether a route works. The engine optimizes what you specify; the art is knowing everything you did not, and could not, specify.

Generative design optimizes exactly the objective function you give it, sacrificing everything you did not specify to win on what you did. The real constraints on MEP routing are too numerous and tacit to fully encode, so a generated route can be optimal on length, fittings, and clashes and still be unbuildable because it violated the unstated constraints that actually govern whether a route works.

Generated Routes Are Candidates, Not Decisions

The correct mental model for generative MEP output is that it produces candidates, not decisions, a slate of strong routing options the coordinator chooses among and refines, rather than a final routing to accept. This follows directly from the objective function problem: because the engine optimized against an incomplete model of the real constraints, its top candidate is the best solution to the stated problem, not necessarily the best buildable route, so the coordinator's job is to evaluate the candidates against the full reality the objective function could not capture and select or adapt the one that actually works.

This is the decide-then-draft pattern in its generative form: the engine drafts many options fast, and the human decides, applying the constructability, sequence, and maintenance knowledge that determines which option is truly best. The value is enormous even framed this way, because the coordinator is now choosing among thousands of explored options rather than settling for the first workable one they could draw by hand, so the generative engine truly improves the routing by widening the field of choice, even though the choice remains the coordinator's. The discipline is to treat even the engine's top-ranked candidate as a proposal to be checked against constructability rather than an answer, because the ranking reflects the stated objectives and the coordinator's check reflects the unstated ones, and a route can top the ranking while failing the check. The generative engine expands and accelerates the options; the coordinator's judgment selects among them, which is the division that captures the engine's exploration power without inheriting its objective-function blindness.

The Constructability Verification

The core verification on generative MEP routing is constructability, asking of each candidate not is it optimal but can it actually be built, installed, and maintained, which is the question the objective function did not ask. The coordinator walks each strong candidate against the constraints the engine could not encode: the installation sequence, can the trades actually install in an order that lets this route happen, or does it require a later trade to install before an earlier one; the access, can the components be physically brought in and connected in this configuration; the maintenance, can the valves, dampers, and equipment be reached and serviced; the coordination, does this route create a conflict in the field even though it is geometrically clear in the model.

These constructability constraints are exactly where the generated optimum tends to fail, because they are the constraints most likely to be absent from the objective function, being tacit, sequential, and contextual rather than geometric. A route can be perfectly clash-free in the model and still be impossible to install because it requires connecting a pipe in a space that will be walled off by the time that pipe is run, a sequence problem invisible to geometry. So the coordinator's constructability check is the essential verification, the one that catches the optimal-but-unbuildable candidate before it becomes installed-then-reworked, and it must be applied with real field knowledge, because constructability is precisely the knowledge the engine lacks. Alongside constructability sit the gate-level checks the lesson series established: the code clearances, NEC working space, maintenance access required by code, that the engine may or may not have been told to hold, and the design intent, whether the route serves the system's actual purpose. The constructability verification is the coordinator confirming that the engine's optimal-on-paper route is buildable-in-reality, which is the judgment the generative engine structurally cannot supply.

The Real Skill: Designing the Objective and Reading the Candidates

There is a higher-order skill the lesson points at: because the engine optimizes what you specify, the coordinator's leverage is partly in specifying the objective function well, encoding as many of the real constraints as the tool allows so the candidates start closer to buildable. A coordinator who tells the engine to hold the code clearances, respect the maintenance access zones, and weight fabrication efficiency gets candidates that are better starting points than one who optimizes only length, so part of the expertise migrates into shaping the objective, which is a new skill the generative workflow rewards. But the objective can never be complete, because the tacit and contextual constraints resist encoding, so the other half of the skill is reading the candidates against the constraints that remain unstated.

This dual skill, specify what you can and verify for what you cannot, is the generative-design competence the level is building toward, and it reframes the coordinator's role: less hand-routing every run, more designing the optimization and judging its output. The coordinator becomes the person who knows both how to pose the routing problem to the engine, which constraints to encode and how to weight them, and how to evaluate the engine's answers against the reality the problem statement omitted, which is a more leveraged role than hand-routing because it directs the engine's vast exploration toward buildable solutions and then selects among them. The skill is not replaced by the engine; it is relocated to the two ends of the engine's process, the objective going in and the candidates coming out, both of which require exactly the constructability and systems knowledge the engine lacks. The coordinator who masters this gets the engine's exploration power working on a well-posed problem and applies their judgment to the output, which is how generative routing produces routes that are both explored-optimal and actually buildable.

The Applied Problem: Generate, Evaluate, Select, Verify

Here is the exercise. Take a congested ceiling area with multiple MEP systems to route, set up the generative routing with a thoughtful objective function (length, fittings, clash avoidance, code clearances, fabrication), generate the candidate routings, then evaluate and select: assess the strong candidates for constructability, sequence, and maintenance access, identify where the optimal-on-paper candidate fails the buildability check, and select or adapt the candidate that actually works. Run the full generative workflow from posing the problem to selecting the buildable answer.

Produce two things. First, the selected routing, the candidate you chose or adapted, with the rationale for why it is buildable, in the form the coordinator would actually issue for fabrication and installation. Second, the evaluation record: for the engine's top-ranked candidate that you did not select, why, the constructability, sequence, maintenance, or coordination constraint it violated that the objective function did not capture, because that record is both the selection logic and a concrete demonstration of the objective-function problem, the gap between optimal-on-paper and buildable-in-reality. Pay particular attention to the candidates that won on length or fittings but failed on installation sequence, because those most cleanly show the engine optimizing through a constraint it was not given.

The deliverable is the selected buildable routing and the evaluation record, and the lasting product is a generative-routing workflow that uses the engine's exploration power to widen the field of options far beyond hand routing while the coordinator's objective design and constructability judgment ensure the selected route is buildable. This is the generative-design core of the BIM chapter, and it is the level's clearest lesson on the engine that optimizes what you specify: the engine explores thousands of routes against the stated objectives, and the coordinator supplies the unstated constraints, both by shaping the objective going in and by verifying constructability coming out. The coordinator who masters this produces MEP routing that is materially better than hand routing, shorter, cleaner, more prefab-friendly, and fully buildable, achieved because the engine explored what the coordinator could not and the coordinator judged what the engine could not, which is the only way a generated optimum becomes an installed reality rather than an elegant route that cannot be built.

Key Takeaways

• MEP routing is a combinatorial optimization problem of astronomical size, and a human coordinator can explore only a tiny fraction, settling on the first workable solution rather than the best. Generative tools (Augmenta, EvolveMEP) generate and evaluate thousands of candidates, finding routes shorter, cleaner, and more prefab-friendly than hand routing, the generative-design engine doing exactly what it is best at.
• The defining property of generative design is that it optimizes exactly the objective function you give it, with total literalness, sacrificing everything you did not specify to win on what you did, so any real constraint absent from the objective is free to violate.
• This differs from hallucination: the engine is not making things up, it is correctly solving the problem you posed, but the posed problem is an incomplete model of the real one, because MEP's real constraints (install sequence, maintenance access, future fit-out, trade coordination) are too numerous, tacit, and contextual to fully encode.
• So a generated route can be optimal on length, fittings, and clashes and still be unbuildable, because it won those metrics by violating the unstated constraints that actually govern whether a route works.
• Generated routes are candidates, not decisions: the engine drafts many options fast (decide-then-draft in generative form) and the coordinator decides, evaluating against the full reality the objective could not capture. Even the top-ranked candidate is a proposal to check, because the ranking reflects stated objectives and the check reflects unstated ones.
• The core verification is constructability: can each candidate actually be built, installed, and maintained, the question the objective did not ask. This is where the optimum tends to fail, because constructability constraints (especially install sequence) are tacit and contextual, not geometric, so a route clash-free in the model can be impossible to install.
• The real skill is dual: specify the objective well (encode as many real constraints as the tool allows, holding code clearances and maintenance zones) so candidates start closer to buildable, and read the candidates against the constraints that remain unstated. The coordinator's role relocates to the two ends of the engine's process, posing the problem and judging the output.
• The artifact: set up generative routing with a thoughtful objective, generate candidates, evaluate for constructability and sequence, select or adapt the buildable one, and document why the top-ranked candidate failed the buildability check, demonstrating the gap between optimal-on-paper and buildable-in-reality.