AI-Assisted Design Exploration

← Back to Aladdin

By Charles Xie ✉

Most of what you do with Aladdin’s AI Assistant is drafting: you describe a house and it builds one, you ask for a dormer and it cuts one in. The design sweep is something else. It is not a feature for making a model — it is a way of doing design, and the assistant can run both halves of it.

Engineering design has a shape that predates any of this. You open the problem up: you generate alternatives, deliberately different from one another, because the answer you want may not be the first one you thought of. Then you close it down: you compare, you choose, and you refine what you chose. Designers call the two motions divergent and convergent thinking, and the interesting thing about a real design process is that it does not do them once. It fans out, picks, improves, and when the design grows a new question — a porch, a garage, a different roof — it fans out again from where it stands.

Optimization is only the second motion. It is a wonderful tool and Aladdin has a good one, but a search for a minimum can only ever find the best version of the thing you already handed it. It cannot invent the alternative it was never given. That is why the design sweep is built as both motions rather than as an optimizer with a nice interface.

The two motions are two tools, and they are deliberately not the same tool, because they answer to different masters. One generates and refuses to rank; the other ranks and refuses to invent.

Diverging: many houses from one brief

Ask for an exploration and the assistant generates a handful of independent candidate designs for a single brief — up to six of them — and stands them all up in your scene at once, side by side, so you can walk around the whole search rather than being handed a conclusion.

Three things about that turn out to matter, and all three only showed up once it was built.

Variation has to be asked for. Left alone, a model given the same brief six times returns six near-identical buildings; the brief is doing all the work and there is nothing in the request that rewards being different. So each generation prompt carries a digest of the candidates already made and an explicit instruction to differ from them structurally. It is the same feed-the-history trick the refinement loop uses on its trajectory, pointed at diversity instead of progress.

The row has a geometry. Candidates are laid out in an east–west row, twenty metres apart and well clear of anything already in the scene. Shadows at these latitudes point north, so a north–south column would stand each candidate in its neighbour’s shade — a two-storey house throws a midwinter noon shadow around twenty-two metres long, and a row that scored one candidate in the shade of another would be measuring the layout instead of the designs.

And the whole row is scored by one simulation. A single yearly run reports per-building totals, so six candidates standing together cost one simulation rather than six. That is what makes generating a population affordable inside a conversation.

Two ways to judge, and one of them is not a number

This is the part that makes the sweep a design method rather than an optimizer with extra steps. An exploration can be judged two ways, and you choose which when you ask for it.

By energy. One yearly simulation scores every candidate, lowest net energy wins, and the winner is picked for you. This is the convergent motion in its purest form: a scalar, an argmin, a result.

By form. No simulation. No score. No automatic winner. The candidates are generated for architectural variety, left standing side by side, and you pick the one you like.

The second mode exists because of the order real people design in. A house nobody wants to live in does not become more wanted by being efficient, so ranking by kilowatt-hours before the form is settled spends the whole run — and the yearly simulation is most of its wall clock — answering a question nobody is asking yet. Beauty has no scalar. Rather than invent one, the loop generates the diversity and hands the judgement back to you.

Converging: choosing one

Convergence is a decision, not necessarily an arithmetic. Every candidate an exploration produces is recorded on your file as a design series: a compact row of entries under the assistant’s message, each one opening a real interactive 3D preview you can orbit, with its score breakdown if it was scored, and a Restore button that puts that design into the scene at full size.

Because the candidates live on the file rather than only in the scene, the losers are not lost when the row comes down — and the scene goes back to showing one design, so a saved file never accidentally contains a comparison row. When you do want them side by side again, compare mode rebuilds the whole row from the stored geometry on demand and throws it away when you are done. It is scaffolding, deliberately: every element it adds is dropped by the file exporter, so a comparison cannot leak into a saved document even if you save in the middle of one.

Then you keep the one you want, and the second motion begins.

Refining: the optimizer with no dials

Now the objective comes back. Point the sweep at the design you kept and it hill-climbs: simulate, change one thing, simulate again, keep the change only if net energy actually fell, and roll it back if it did not. That is the single-objective form of the loop. Give it two objectives — energy and cost, say — and the same four steps run, but the fourth step stops asking is it better? and asks is it a trade nobody has beaten yet? That form gets its own section further down.

Evaluate. The engine runs over the building and records one number: net energy, meaning heating plus cooling minus whatever the rooftop panels generate. A yearly evaluation samples twelve representative days — the 22nd of each month, hour by hour — which is what makes a step cost seconds rather than minutes.

Revise. The model is handed a compact description of the current design and asked for exactly one concrete change. It gets four rounds to make it: read the scene, call one editing tool, say what it did. It may not run a simulation of its own — the loop owns the measurement — and it may not start another sweep inside this one.

Re-evaluate. The same days are simulated again on the revised geometry, so the two numbers are comparable. The renderer is given a frame to publish the new geometry first; a simulation of a half-built roof would be worse than no simulation at all.

Keep or roll back. The revision has to beat the current best by a real margin, not by rounding noise: two tenths of a percent of the baseline, or half a kilowatt-hour, whichever is larger. Clear it and the revision becomes the new base. Miss it and the design is restored from a snapshot taken before the edit, and the model is told what failed — so the next step tries a different lever instead of walking back into the same dead end.

Then round again, up to eight steps, stopping early on convergence or on the time budget you gave it. Because each step revises the current best, the trajectory only ever improves, and the scene is left at the single best design found rather than at whatever the last step happened to try.

What proposes the move

There is no list of parameters to sweep and no numeric solver hunting through them. The thing suggesting the next move is the language model, reasoning about this house in this climate — that the west glazing is what bakes the upstairs, that the overhang is too short to shade a south window in July. The loop supplies the discipline, the measurement and the veto; the model supplies the ideas.

Aladdin has shipped the classical kind of search for years — a genetic algorithm and a particle swarm, used to lay out solar panel arrays and find tilt angles. They are a useful mirror, because they fail in the opposite direction.

One searches widely because it cannot think; the other searches narrowly because it can. They are good at different jobs: the genetic algorithm where the variables are known and an evaluation is cheap, the sweep where the hard part is knowing which variable to touch.

The dial list that is not there

Every building optimizer before this one searched a space somebody parameterized in advance. You decide beforehand that the variables are the tilt angle, the row spacing, the window-to-wall ratio; you give each a range; the solver moves those dials and nothing else. Expose no dial for the roof shape and no amount of searching will ever try a hip roof.

The sweep has no dial list. A move is any edit the assistant could make by hand — change the roof type, add dormers, cut in skylights, deepen an overhang, re-glaze the south face, rotate the building, lay out a solar array, upgrade the heat pump — so the search can change what the design is, not merely how big its parts are. That is a door no slider box opens.

What it does have is a vocabulary. The moves a house sweep may make fall into twelve named levers — wall insulation, roof insulation, airtightness, glazing performance, window area, shading (a porch, a portico, a recessed entry, trees, shutters), roof form, orientation, skylights, on-site solar, the HVAC plant and the thermostat — and floor area as a thirteenth when you put it on the table. A lever is not a dial. It names a kind of edit and the tools that may make it, not a number and a range: “shading” may add a porch or plant a tree, and the model decides which. Left alone the sweep chooses the lever at each step itself. But because the levers have names you can also hand it a route — “insulation first, then the windows, then solar”, or “just try a heat pump” — and the loop confines each step to the lever you named for it, in your order, and says so in the report. That is the difference between an optimizer you configure and one you talk to: the vocabulary is there so that your instructions have something to bind to.

The rules a search this free has to carry

Opening the move set that wide creates a problem nobody had to solve before. A search that can make any edit will find the dishonest wins. The fastest way to cut a heating bill is a smaller house with fewer windows; the second fastest is to stop heating it so warmly; the third is to write down an air-conditioner that does not exist. A dial-based optimizer cannot cheat in any of those ways unless you hand it the dial — the parameterization was the ethics. Take the parameterization away and the ethics has to be built back in explicitly.

What the sweep may not do, and why

The rule	What it stops	Can you lift it?
Keep the house	A revision may not cut the conditioned floor area, not by more than a rounding error. Shrinking the building lowers the number without improving anything, and the objective is supposed to compare the same house with itself.	Yes — name a floor
Keep the envelope real	Insulation and glazing are capped at what can be bought: roughly R-40 walls and R-57 roofs in imperial units, windows no better than U-0.5 in SI units (about U-0.09 imperial), and the air leakage of a wall or a window can be lowered but never to zero. Above those, the search is no longer insulating a house; it is dividing the loss term by a number. The fresh-air ventilation the occupants breathe may not be cut at all.	No
Leave the thermostat alone	Setpoints are the service the building delivers, not part of its design. Widen the comfort band and you save energy by being colder in winter and warmer in summer — the before and after are no longer the same house keeping you equally comfortable.	Yes — ask for it
Buy equipment that exists	Cooling electricity is the load divided by the air-conditioner’s coefficient of performance, so a single revision claiming a COP of 25 divides most of the objective away with a number rather than a building. What may be specified is capped at the best product on the market.	No
Do not redefine the job	A revision may not build a second house, open another file, load an example, or start a sweep inside the sweep. It may not run a simulation either: the loop owns the measurement, so no step can score itself.	No
Leave the land alone	On a solar farm, a wind farm or a solar plant the site is the given: a revision may re-lay the field on the same slab but may not enlarge it, may not place a rack or a turbine off it, may not remove the array outright, and may not ask for a machine that does not exist — a 300-metre rotor, a mirror with a reflectance above 95 percent.	No

The thermostat rule is the one worth dwelling on, because the point of it is not that the lever is illegitimate. A night setback is a standard, sensible energy measure and a perfectly good thing to study. The point is that the optimizer must not choose it on your behalf and then quote the result as though the building had got better. So say “try a night setback” and the guard stands down for that run — and the report then tells you, separately, how much of the saving was the building and how much was the extra sweater.

The equipment rule works differently, and the difference is instructive. Buying a better machine is a real design decision: swapping electric resistance for a heat pump is exactly the retrofit an energy study should be free to propose, and the house still delivers the same comfort afterwards. So this is a ceiling rather than a ban. Honest upgrades pass untouched, a fantasy machine is rejected before it is ever scored, and whatever the winning design did buy is disclosed in the report — because a saving that arrives with a new machine and its price tag should not read as a fabric improvement. And unlike the thermostat, it has no unlock: no phrasing you could type makes a COP 40 chiller purchasable, so an unlock would only let the search launder an impossible number through a stray wording.

The envelope rule was learned the hard way. An early sweep took a house in Massachusetts to net zero on insulation and a heat pump alone, which is not a result but a warning: the model house had been hermetically sealed, with no air leakage and no fresh air, and the reviser had written down wall R-values that no product supplies. A building that does not breathe is very cheap to heat. So a house now leaks and ventilates by default, at rates a real house does, the insulation and glazing have ceilings, and the ventilation is off limits to the search. The same honesty runs the other way, too: the sweep scores under whatever weather the scene already uses and says which in its report — the synthesized climate, which is optimistic, or measured typical-year weather — and it never switches the basis behind your back, because the baseline has to be the number you were just shown.

An optimizer that cannot make you colder to flatter its own number is the design principle here, and it is one this generation of tools is going to need.

Two numbers, and a front

Energy is the axis the simulator measures directly, and it was the right first objective. It is not what a design decision actually trades against. Triple glazing saves energy and costs money; a smaller house saves both and gives up living space; a heat pump pays for itself in some number of years or never does. A single scalar cannot hold any of that, and the classical fix — a weighted sum, with the weights chosen by whoever configured the run — decides the trade-off before the search has shown you what the trade-off is.

So the sweep takes more than one objective, and when it does, it changes what it keeps. Ask for energy against cost and each candidate is scored on both: the same yearly simulation for the kilowatt-hours, and the construction estimator — the one behind the assistant’s budget tool, a quantity take-off priced from a book of unit rates — for the dollars. The accept test is no longer is it better? A revision is kept if it is not dominated: if no design the sweep has scored so far beats it on every objective at once. A cheaper house that uses a little more energy is a legitimate new point, not a failure. Every design the run touches, kept or reverted, goes into an archive with its numbers, and at the end the archive is sifted for the ones nothing dominates. That set is the Pareto front: the menu of trade-offs the search found, with no point on it called the optimum, because along a front there is no such thing.

A front is a menu, and a menu needs a default. The scene is left at the knee — the point on the front closest, with each axis normalized to the front’s own span, to the corner where both objectives would be at their best at once. It is where the trade-off bends: to the left of it you pay a lot of energy for a little money, to the right a lot of money for a little energy. But the knee is a suggestion, not a verdict. Every design on the front, and every dominated one behind it, is recorded on the file as a design series — the same compact row of restorable entries an exploration leaves under the assistant’s message — so you read the menu, orbit any point in its preview, and put the one you want into the scene with a click.

The objectives on offer are five. For a house: net energy, construction cost, floor area and payback period. Floor area is the odd one, because it is maximized: put it on the table and the search is allowed to grow the house as well as shrink it, and the no-shrink rule relaxes to a floor. Payback is the one people actually ask for — shorten my payback, what has the best return — and it is a ratio of two things every scored design already carries: the extra construction cost over the baseline, divided by the energy the design saves each year at your electricity price. A design that saves nothing never pays back, and loses to any that does; one that saves energy and costs less than the baseline pays back at once. For a plant, the fifth objective, annual yield, replaces energy, and payback becomes the project’s own: capital cost against yearly revenue less operations, the number the payback card shows.

The trade-off does not have to be two-way. Ask for energy, cost and floor area together and the archive keeps a three-dimensional front, the scatter draws the third objective as the size of each mark, and the knee is found in three dimensions. Beyond three the front still exists and is still reported as a table; only the picture stops being a picture.

What comes back

A multi-minute search that leaves behind only a paragraph of prose is not much use half an hour later, so the sweep writes its trajectory into the transcript: one row per step, what it tried, what the meter read — heating, cooling and solar separately, so a rooftop array that was already cutting the bill is on the record and not silently absorbed into the net — and whether it survived. Under a multi-objective run the rows carry the cost, the area and the payback as well, and the outcome column stops saying kept and reverted and says where each design stands: on the front, at the knee, or dominated by something already found.

A trajectory, as the transcript records it

Step	What it changed	Net kWh	Outcome
0	baseline	9,140	—
1	Triple-glazed the west and south windows	8,610	kept
2	Raised the roof insulation	8,290	kept
3	Deepened the south overhang to 1.2 m	8,315	reverted
4	Laid out a solar array on the south roof	6,880	kept

The same house swept for energy against cost

Step	What it changed	Net kWh	Cost $	Stands
0	baseline	9,140	312,400	on the front
1	Raised the roof insulation	8,720	314,100	on the front, knee
2	Triple-glazed every window	8,190	329,800	on the front
3	Deepened the south overhang to 1.2 m	8,215	331,600	dominated
4	Laid out a solar array on the south roof	6,880	343,900	on the front

Two charts come with the rows. The first is the staircase from the diagram above, drawn from the real numbers: net energy stepping down through the run, one landing per kept step. The second, for a multi-objective run, is the scatter on the previous figure: every scored design on two axes, the front joined, the knee starred, the dominated designs hollow. Both live in the chat and in the file, and both survive into the PDF report the assistant can export, as still pictures.

Alongside it comes the arithmetic that matters: the baseline, the best design found, the kilowatt-hours saved and the percentage, how many revisions were accepted, and which levers turned out to be dead ends. If the scene held more than one house, the report names the one these figures are about — scoring the sum of every building in the scene would quietly ruin both the percentage and the comparison. If the run stopped early it says so, and says plainly that this is not a finished optimization. And if the thermostat was opened or the plant was upgraded, that is called out separately from the headline number rather than folded into it.

These are not decorative figures. Aladdin’s building-energy engine is checked against ASHRAE Standard 140 (BESTEST), the reference suite whole-building simulation programs are validated with — the same bar the professional tools are held to.

The same loop over a solar farm, a wind farm, a solar plant

Nothing in the four steps says house. The evaluator, the vocabulary of levers and the guards are what make a sweep a house sweep, and each of those can be swapped. So the same tool now sweeps the other things Aladdin builds, and the assistant decides which from what is standing in the scene — or from what you name, since a house and the ground-mounted array that feeds it are one scene with two sweepable things in it.

A solar farm is scored on annual yield, the more the better, by the same yearly simulation that scores its rooftop cousins. The levers are the ones a farm designer actually turns — tilt, row pitch and ground-coverage ratio, azimuth, rows per rack and their orientation, pole height, the module itself including bifacial ones — and the slab and the module count are held fixed, so a “better” layout that quietly bought more panels is refused. Trackers are left out of the study on purpose; they are a different question. Yield against build cost is the natural front, and payback the natural single objective.

A concentrated solar plant — parabolic troughs, linear Fresnel reflectors, a heliostat field around a power tower, or dishes — is scored on the energy its field collects over a year. Each type has its own levers: for a trough field the row pitch, the collector width and length and the focal geometry; for Fresnel the absorber height above all; for a tower the tower height, the mirror size and spacing and the shape of the field, with the field’s radius and the number of towers treated as the land and left alone. The reviser rebuilds the plant in place on its own slab, keeping the slab and every identity, which is what stopped an early version from standing a second field beside the first every time it tried a wider pitch. A heliostat field is the slowest thing the program simulates, so a tower step is a minute or more, and the report says so.

A wind farm is the fast one. Its annual energy comes from a wind-resource integral over the site’s wind rose, with wake losses between turbines modelled analytically, so an evaluation is instant and a step costs only the reviser’s thinking. The sweep fetches the site’s measured wind rose first if the scene has none, so the wakes are directional for the whole run. The levers are the turbine model, hub height and rotor, the number of machines against their spacing, the row bearing and stagger, and placement — and inside a wind sweep, uniquely, the reviser may call Aladdin’s own wake optimizer to reposition the machines, because that is a real move a wind engineer would make. Fewer turbines is a legitimate design here; overlapping rotors and hubs above 200 metres are not.

In every case the plant is swept on its own numbers, and when a house shares the scene the report names it and says that the plant’s generation is credited to it, so that the house’s net can be re-run once against the new plant rather than blended into the plant’s score.

Diverging again

A hill-climb has a horizon, and it is worth being blunt about where it is. The sweep takes the best single edit it can find at each step and never backtracks past a decision it has banked, so it converges on a good version of the house you gave it. It will not discover that the whole thing wanted to be an L-plan.

That is not a defect to be engineered away; it is the reason the method has a second motion. When the refined design raises a new question — how should the porch go, what happens if this becomes two storeys, which of four roofs suits it — you go back up and fan out again, this time from everything you have already settled. The brief for the second exploration is richer than the brief for the first, because it carries the decisions you made in between. Compare the new candidates, keep one, refine it, and the design has climbed a level rather than a slope.

Run it a few times and the shape of the thing becomes obvious: a spiral rather than a loop. Each turn is a diverge and a converge, and each turn starts from a design that is more decided than the last.

Where this sits

Both halves have a lineage, and they are good ones. Optimizing a building by simulating it, changing something and simulating again is how the field has worked for decades — NREL’s BEopt, Berkeley Lab’s GenOpt, jEPlus over EnergyPlus, Galapagos and Octopus in Grasshopper, generative design inside Revit. Letting a language model do the proposing has its own line of research, from Evolution through Large Models and OPRO to FunSearch and Eureka: propose, measure, feed the scored history back, keep what survives. And divergent generation is the oldest idea in design methods, going back to the design-methods movement of the 1960s and running through every ideation tool since.

What has been missing is the pairing. The generative tools generate and do not measure; the optimizers measure and cannot generate; and the two have historically lived in different programs, with an export in between. Here they are two tools over one scene, sharing one representation, so the output of the divergent motion is the input of the convergent one with nothing in between to translate.

The setting does the rest. The evaluator lives in the same program as the geometry, so there is no export, no intermediate file and no batch job — which is why a whole turn of the spiral fits inside a conversation. The search edits your actual scene and can undo, so what comes back is a better house, not a table of numbers to rebuild from. And it begins with a sentence: the professional tools in this space are excellent and every one of them assumes an expert with a configuration file, while here a fifteen-year-old types optimize this house and watches it happen.

What it does not do yet

The front a sweep returns is the front of the designs it happened to visit, and a greedy walk visits a path, not a population. Ten steps give you ten or so points, chosen by a reasoner working along a trajectory, and a good front deserves more than that: repeated runs from different starting points, or a proper multi-objective evolutionary search using the language model as the mutation operator, so the front is filled in rather than sketched. Where the picture stops is a smaller version of the same limit — three objectives draw, four or more only tabulate, and a parallel-coordinates view is the obvious next card. And a front still has no way to hear a preference: “I care about cost twice as much” should move the knee, and today it does not.

The divergent half has its own frontier. Today an exploration generates independent candidates for a brief; the natural next step is variation on a design already settled — five gardens for one house, four roofs for one plan — which is a different generative problem from five houses for one site, and the one the second turn of the spiral asks for most often.

To see the sweep in the context of actually designing something, it appears near the end of Designing Your Dream Home with AI, after the house has been built, furnished and planted. There is a wider tour of what the assistant can be asked to reason about in An AI-Aided Engineering Design Loop, and the modelling side of it in Using LLMs to Create 3D Models in Aladdin.

← Back to Aladdin