AI Agents for Design

Under the branding, an agent is a fairly simple idea built on the LLMs you already understand. You give it a goal in plain language. It then runs a loop: it plans a next step, acts by taking that step - often calling a tool such as a web search, a calculator, a file reader, or another AI - observes the result, and then plans again in light of what it saw. It repeats this cycle until it decides the goal is met or it gives up. That loop - plan, act, observe - is the whole engine.

The leap from a plain assistant is tool use. A chat model can only produce text; an agent can be given the ability to do things - fetch a live web page, run a calculation, read a document, write a file. That is what lets it gather information it was not given and take actions in the world, not just describe them. It is also, precisely, what raises the stakes: a system that can act can act wrongly.

The second leap is self-direction across steps. You do not script each step as you would in a fixed pipeline (Module 8.1); the agent decides the sequence itself. Ask it to 'research three precedents for a hillside house and produce a comparison table' and it might search, read several pages, extract facts, and assemble the table - choosing those sub-steps on its own.

That autonomy is the source of both the excitement and the danger. A fixed pipeline is predictable but rigid; an agent is flexible but less predictable. Every error in an early step feeds its own next decision, so a small wrong turn can compound into a confidently-wrong result several steps later - with no human having looked in between unless you insisted on it.

Here is the honest state of play, holding both the real capability and the real limits at once. Agents in 2026 are genuinely good at bounded, multi-step information tasks where the steps are fuzzy but the domain is contained and the output is checkable. Agentic research is the clearest win: 'find and summarise five recent precedents for mass-timber housing, with sources' is the kind of multi-step search-read-synthesise job an agent handles well - and you can verify every source it cites.

Other realistic uses cluster in the same shape: pulling together data from several documents into one structured summary, drafting then self-critiquing and revising a piece of writing, or orchestrating a chain of other AI tools (running the pipeline from Module 8.1 with less hand-holding). Coding agents that write and test small scripts are among the more mature examples, which is why they show up in the automation work of the last lesson.

A concrete case makes the shape clear. Ask an agentic research tool to 'compile five recent precedents for naturally ventilated schools in a warm-humid climate, each with a source, the ventilation strategy and one measured outcome'. A capable agent will search, open several pages, notice that two hits are marketing rather than evidence and discard them, keep searching until it has five solid ones, and assemble a table - choosing those sub-steps itself. That is genuinely useful, and every cell is checkable, which is exactly why this task suits an agent while 'design me a school' does not.

Now the limits, stated plainly. Agents do not autonomously design buildings, and claims that they do are hype - they have no site judgement, no client relationship, no accountability, and no reliable grasp of truth, exactly as established in Module 0. They are less reliable the longer they run: errors compound across steps, and a confident wrong turn early can derail everything after it. They can take real actions, so a mistake is not just a bad sentence but a bad action - a wrong file overwritten, a wrong figure sent on. And they can be slower and more expensive than a human doing the same bounded task, because each step is its own model call.

The useful mental model for 2026: an agent is a capable, eager, sometimes-unreliable junior who can run an errand across several steps - superb for the right contained research or drafting chore, nowhere near ready to be left alone with a decision that matters.

This whole course rests on the human-in-the-loop, and agents are where that principle is both hardest to hold and most important. The paradox is plain: the appeal of an agent is that it acts without you at each step, yet the more autonomous a system is, the more consequential an unreviewed error becomes. The resolution is not to reject agents but to design the gate deliberately rather than assume it.

The most important control is scoping the goal and the tools. Give an agent a bounded, checkable task, not an open-ended mandate, and give it only the tools it genuinely needs. An agent that can read files and search the web is far safer than one that can also delete files, send emails or spend money. Match the leash to the stakes: generous for low-stakes research, very short for anything that touches a deliverable or the outside world.

The second control is the checkpoint. Well-designed agentic tools let you insert human approval before consequential actions - the agent proposes, you approve, it proceeds. Treat any irreversible or external action (sending, publishing, spending, deleting) as one that must pass a human gate, every time. For high-stakes work, prefer an agent that drafts a plan for your approval over one that just runs.

The third is verification of the result, unchanged from every other lesson: an agent's output is a starting point you judge, and its confidence is not evidence. Because an agent can show you a tidy final answer while hiding a wrong turn three steps back, read its working where you can - the sources, the intermediate steps - not just its conclusion. Autonomy raises the ceiling of what AI can attempt in your workflow; your judgement, deliberately placed, is what keeps that from becoming a liability.

Agents are moving fast, and it would be as foolish to dismiss them as to believe the boldest claims. So here is a measured view to carry forward - useful whether you read this in 2026 or later.

The direction of travel is real. Tool use is getting more reliable, agents are handling longer chains of steps, and the tooling for supervising them - checkpoints, permissions, audit trails - is maturing. It is reasonable to expect agents to take on more of the bounded, multi-step drudgery of practice over time: research, data-wrangling, first-draft documentation, orchestrating other tools. Learning to direct and supervise an agent - to scope a goal well, choose its tools, and review its work - is a genuinely durable skill, and a natural extension of the human-in-the-loop craft this whole course has built.

What is not on a credible horizon is the fantasy version: an agent you brief once that autonomously designs and delivers a building. The barriers there are not temporary engineering gaps but the same enduring ones - accountability, real-world judgement, client relationship, the difference between plausible and correct. Those remain the designer's, and a profession that stakes its name and liability on its work will keep a human author for good reason.

So treat agents as the leading edge of AI-assisted design, not a replacement for it. Experiment with them on contained, checkable tasks; be sceptical of any demo that skips the verification; and keep your hand on the gate as their autonomy grows. The designers who will thrive are not the ones who hand everything to an agent, nor the ones who refuse to touch them - but the ones who learn to conduct them: setting the goal, holding the standards, and staying, always, the author of the work.