Modals all the way down: why agents bury decisions you'd put on the row
The modal reflex is one of the most consistent patterns in agent-built UI. A button opens a dialog. The action lives in the dialog. Save closes it. It compounds in batch workflows.
Ask an agent to make an action available in a data table and it will give you a button that opens a modal. The form lives in the modal. Save closes the modal. Sometimes there's a confirmation dialog inside the modal. The user clicks through three surfaces to complete one action on one row, then starts over on the next.
This happens so consistently it deserves a name: the modal reflex. It's not a bug or a misunderstanding — it's the path of least resistance when you're scaffolding from a data model without knowing the job.
When modals are right
Modals have a legitimate role. They're right when the action is a genuine context switch — when completing it requires information or focus that would be disruptive to have inline. Creating a new entity from scratch is a modal candidate. Configuring a complex rule that references data from multiple sources is a modal candidate. A destructive action with real consequences — delete, cancel, revoke — warrants a modal plus a confirmation.
What these have in common: the user is leaving the current context to do something different. The modal signals that boundary. It's appropriate when the boundary is real.
When modals are wrong
Modals are wrong when the action belongs to the row. If the user is going through twenty recommendations and approving, rejecting, or editing each one, the action lives on the row. The row is the decision unit. Opening a modal to approve a single recommendation and then closing it before moving to the next one adds three clicks of ceremony to every decision — sixty extra clicks for twenty rows.
In batch workflows — reorder decisions, support ticket triage, expense approvals, inventory updates — this compounds fast. It turns a tool for deciding into an obstacle course. The user's job is to process the batch. The interface's job should be to make that frictionless. A modal on every row is the opposite of that.
Pattern: modals are for leaving the context. If the action lives in the same context as the row, keep it there. Approve, reject, edit-in-place, and confirm all belong inline when the user is working through a list.
Why agents reach for modals
The modal reflex comes from scaffold-first thinking. When an agent sees a table and needs to make a record editable, the simplest structure is: button triggers a form, form lives in a container that overlays the table, save dismisses the container. That's a modal. It requires no knowledge of how many records the user processes per session, what the cadence is, or whether the action is the whole job or a sub-step.
Agents also reach for modals defensively. Modals feel safe — the user confirms before committing, the form is contained, there's a clear cancel path. The problem is that this safety is real for destructive or irreversible actions and unnecessary for everything else. Approving a low-stakes recommendation is not a dangerous action. Wrapping it in a modal adds ceremony without adding safety.
How TheDesignAgent flags it
The /ux lens raises a layout_fights_action flag when a modal pattern is detected on what appears to be a batch or repetitive job. The extraneous_load sub-score reflects the per-action overhead — if every decision in a list requires a modal open and close, the score drops accordingly.
Patches on this pattern are consistent: collapse the modal into the row, expose the primary action directly, add an expand gesture for any secondary context the user might want. The agent gets explicit before/after: "move approve/reject/override inline; reserve modal for edit scenarios where quantity and reasoning need simultaneous view."
The difference is visible in the homepage receipts — the inventory planning case shows the before and after. The before is functionally correct. The after is the same logic with the ceremony stripped out.