The macro recorder
Turning a good agent run into a reusable recipe.
The best agent runs are the ones the user wants to do again. They got the cohort right. They got the email shape right. The next obvious move is to save them. Most products make this a wall. The user has to re-prompt, re-configure, re-approve. A macro recorder turns a finished thread into a one-tap recipe.
The pattern is small UI, big leverage. A chip at the end of a good run: 'save as macro.' Four taps later, the thread has become a template with named slots. The next person to want this workflow doesn't start from scratch.
"A good agent run is a prototype of a macro you don't know you need yet. The product's job is to catch the macro before the user forgets."
Save. Parameterize. Pin. Run.
At the end of a thread, the model offers to save it. The user names it. The product parses the prompts and asks which literals should become slots. The macro lives in a sidebar; double-click to run, or fill the slots and fire. The output is a new thread, transparent about which macro produced it.
- promptPull the last 30 days of churn for the enterprise tier
- toolquery_warehouse → 143 rows
- promptGroup by region and write a 3-sentence summary
- toolgenerate_table → 4 regions
- outputNorth-America-E leads with 6.2% monthly churn.
A good thread becomes a macro in four taps. Slots make it reusable without making it fragile.
Power users make the same prompt a hundred times.
The second, third, and fiftieth run of a good workflow is where product value lives. A team that ran a successful cohort analysis once will want to run it weekly. If the product makes them re-type the prompt, they won't. If the product catches it, they do, and the value compounds.
Macros that stay useful.
- Parse slots from the prompt. The user shouldn't have to write a template. Highlight the literals and offer them as slots.
- Preview before running. The macro should show the exact sequence of steps it will replay, with slot values filled in, before anything happens.
- Link back to the first run. Every macro should remember the thread that spawned it. When the macro breaks, the user can see the working reference.
Macros that rot.
Macros are fragile. A model update, a tool rename, a schema change, and suddenly a macro that ran every Monday breaks on a Tuesday. Products that don't version their macros turn them into a surface-area liability.
What this pattern gets wrong when it gets wrong.
- Runaway agent
- An agent that loops, spends, or edits past the user's intent with no visible cap.
- Phantom tool
- A visible tool call that didn't happen, or happened but with different arguments than shown.
- Ambiguous state
- Running, done, errored, paused all look the same. The user has to infer from context.
Three shipping variants worth copying.
- A 'save as macro' chip at the end of a run
- Macros turn literals in the prompt into named slots
- A macro library with a 'run' button on each row