AI programming agents in architectural design turn a project brief into a working program inside a building. In Snaptrude, three agents handle this stage in the Feasibility phase: Generate Program, which breaks a brief into departments with area allocations, space counts, and adjacency intent; Stack Program, which distributes those departments across building floors using adjacency and stacking rules; and Pack Program, which spatially packs the approved program into each floor of the massing.

This post explains what each agent does, how they work together, and where they fit into the way architects actually program a project.

Why does architectural programming slow down early design?

Programming is one of those parts of the process that looks straightforward and almost never is.

A real brief comes in fragments. A PDF from the client. A meeting note. A sketch from the principal. The first task is always to turn that into a working program table: departments, area allocations, space counts, adjacency intent. Most teams do this in a spreadsheet. It works, but it takes hours, and the spreadsheet has no connection to the actual building.

Then comes stacking. Which department goes on which floor? Adjacency matters. Floor plate efficiency matters. Circulation matters. Most architects do this with diagrams and gut feel, often without a quick way to test whether a particular stacking configuration actually works.

Then comes packing. Once stacked, each floor needs to be drawn in plan, with the right departments and spaces in the right relationships. This is where programming becomes design work, and it's slow.

Here's what we noticed: the bottleneck in programming is the loop. When the brief changes (and the brief always changes), the program table changes, the stacking changes, and the floor plans change. Each change ripples through three separate stages of work, each done in a different tool, none of them connected to the others.

That's the bottleneck. Programming runs slowly because the workflow has three disconnected stages, and every change requires redoing all three.

Architectural programming is slow not because any one step is hard, but because the brief, the stacking, and the floor plans live in separate tools that don't talk to each other.

What do the Generate Program, Stack Program, and Pack Program agents actually do?

The three agents map onto the three stages of programming. Each one handles a specific step: brief into program table, program into floors, floors into geometry.

Generate Program

Generate Program breaks a project brief into a structured program. It produces a program table with departments, area allocations, space counts, and adjacency intent. The output is editable, which matters because no first-pass program is ever final.

The agent accepts PDF briefs. You can drop in a client brief, a feasibility report, or your own internal program document, and the agent reads it and produces the structured program from there. You can also run it from a typed brief if you don't have a PDF on hand.

Generate Program has no prerequisites. You can run it without a site, without a massing, without anything else in the project. The output is a working program, ready to be reviewed, edited, and approved.

Stack Program

Stack Program takes the approved program and distributes the departments across building floors. It uses adjacency intent (from Generate Program), floor area, and stacking rules to produce a storey table with stacking diagrams.

What you get is a vertical view of how the program lives in the building. Which departments sit on which floors. How the adjacencies between departments resolve when those departments need to be stacked rather than placed side by side. Where the natural breaks in the program fall, vertically.

Stack Program requires approved departments from Generate Program. The dependency exists because the agent needs a defined program to distribute, with adjacency intent already specified.

Pack Program

Pack Program is where programming meets geometry. The agent runs adjacency analysis and spatially packs the approved program into each floor of your massing. It produces a layout directly on the canvas.

What this means in practice: each floor of your building gets a packed plan, with the right departments in the right relationships, fit to the actual floor plate geometry. Adjacencies are respected horizontally on each floor, the way Stack Program respected them vertically.

Pack Program requires both an approved Explore Massing output (the building geometry to pack into) and an approved Stack Program output (the storey-by-storey distribution). Without both, the agent has nothing to pack.

Generate Program creates the program table. Stack Program distributes it across floors. Pack Program packs it into the building geometry. Three steps, three agents, one connected workflow.

How do you use these agents together in a real workflow?

The sequence depends on where you start. Two common entry points.

If you're starting with a brief and no building yet: Run Generate Program first. The agent has no prerequisites, so you can get a working program table before any other work happens. Drop the brief PDF, review the output, edit anything the agent didn't get right, and approve.

From there, you can run Stack Program immediately if you want to see how the program distributes vertically, even without a building geometry yet. Stack Program doesn't need a massing, only an approved program.

Pack Program is where the geometry comes in. To run it, you need an approved massing from Explore Massing. If you haven't run massing yet, you'll do that before packing.

If you're starting with a site and building geometry already in place: The site agents and massing agents run first. Once you have an approved massing, the programming agents follow. Generate Program is still the entry point. Stack Program builds on its output. Pack Program closes the loop by fitting the program into the massing.

A full early-design workflow that uses all five Feasibility agents typically runs:

1. Analyze Site, then Buildable Envelope
2. Explore Massing, then Place Cores
3. Generate Program, then Stack Program
4. Pack Program (which depends on both massing and stacking)

The whole sequence can run in a single working session. The agents are accessed via the sparkle launcher in the bottom command bar, which opens the Canvas Agent Panel on the left side of the canvas.

From here, you're into the Concept phase, where Generate Spaces and the rest of the room-level agents take over.

Generate Program is the entry point and can run anytime. Stack Program needs an approved program. Pack Program needs both an approved program (stacked) and an approved massing. Respecting the chain is what lets each agent do its job.

What are the limits of AI architectural programming?

Three things worth knowing.

Generate Program produces a first-pass program, not a final one. The brief you input shapes the quality of the output, and even on a clear brief, the agent's first pass benefits from review. Treat it as a strong starting point you'll edit, not a finished deliverable.

Stack Program follows stacking rules and adjacencies, not building character. The agent will produce a vertically resolved stack that respects the rules you've specified. It won't know that you want the gallery on the top floor for symbolic reasons, or that the principal prefers conference rooms on lower levels. Those choices stay with you. The agent's role is to surface options and trade-offs; the design intent stays with the architect.

Pack Program packs the program into the geometry it's given. If your massing is geometrically awkward, the pack will reflect that. The agent doesn't redesign your massing to make the program fit better. If the program and the massing aren't compatible, that's a feasibility signal worth catching at this stage, before you go further. The agents work in chain for a reason.

These are real constraints. Within them, the agents handle a category of work that traditionally takes a week of spreadsheets, stacking diagrams, and plan drawings, and they handle it in a way that's connected to the building geometry rather than separate from it.

These agents produce structured programs, vertical stacks, and packed floor layouts. They don't replace the design intent that goes into a brief, a stack, or a plan. Use them to surface options faster, then bring the judgment.

Programming as a workflow, not a deliverable

The case for these agents is simple. Programming has always been a workflow that lives in three disconnected tools: a spreadsheet for the brief, diagrams for the stack, plans for the pack. Every change to the brief means redoing all three, which is why teams often resist changes that would make the building better.

Generate Program, Stack Program, and Pack Program turn that into a connected chain. The brief flows into the program, the program flows into the stack, the stack flows into the geometry. When the brief changes, the chain reruns. That's the structural shift that makes the rest possible.

If you want to see how these three agents connect to the rest of the early-design workflow, the 2.5-hour RFP workflow shows the full chain in action. Or try them in Snaptrude on your next brief.

We built these agents because the slowest part of early design was almost never the design itself. It was the work of getting a brief into a program, into floors, and into geometry. We wanted that chain to stop being a bottleneck. Whether it stops being one for your team is something you'll feel by the second project.

‍

Frequently Asked Questions

‍