I recently went to The Future of Product #4 Agentic AI event in Rivvia, Amsterdam, and Titus Ex gave a talk that's worth thinking about more. He walked through how his company has rebuilt its entire workflow around AI. Not just bolted AI onto the old process, but actually changed how the work gets done using agents.

He gave an analogy about the horseless carriage. Early cars that still looked like carriages, because nobody had redesigned around what the engine actually made possible yet. I haven't stopped thinking about that one. It was a nice ending note, and it definitely got me thinking: am I just treating my own design process like a horseless carriage?

That's honestly where I am too. I've been coding, I've automated parts of our design-to-dev handoff, and we use AI across the team already. But if I'm being straight with myself, I hadn't actually worked out what an "agentic workflow" would look like for my own design work, or how far I could push it. So over the weekend, I put my builder hat on and got straight to work. Partly research into how the most forward-thinking agentic AI teams actually operate, partly an honest audit of what works for my own design process today, not what I assume works. This is what I found, and it got me genuinely excited to start making changes.

Workflows vs. agents

Anthropic draws a useful distinction in their engineering writing:

  • Workflows are systems where LLMs and tools are orchestrated through predefined code paths. A human has already decided every branch, and the model just fills in the step it's given.
  • Agents are different. They dynamically direct their own process and tool use, deciding what they need to know, which tool solves the problem in front of them, and when their own output is good enough to hand off.

I've noticed a lot of things called "AI agents" right now are really just workflows wearing a costume. That's not necessarily a bad thing. A workflow runs the same steps in the same order every time, regardless of what it finds along the way, which makes it predictable and easy to trust. An agent inspects what it finds and changes course because of it, which makes it more capable, but also a bigger risk if you get it wrong.

"Start simple, and only add agentic complexity where it clearly earns its keep over a fixed workflow."
Paraphrasing Anthropic's guidance on building with agents

For design teams, I think that's the right order of operations too. Autonomy isn't a feature you switch on. It's something a process earns, after the fixed version has been proven and trusted.

What an agentic design workflow actually means, learning from top AI companies today

When we remove the hype, an agentic design workflow is a process where the system can do all of the following, not just generate something that looks right on the first try.

This is the list I now use myself to check whether something I've built is actually agentic, or just AI-assisted with extra steps.

01 Understand the task Parse what's actually being asked, not just the literal prompt.
02 Decide what it needs to know Identify missing context before acting on incomplete information.
03 Call tools Reach into design files, code, docs, whatever the task requires.
04 Inspect outputs Look at what a tool call actually returned before moving on.
05 Critique or improve its own work Catch its own mistakes before a human has to.
06 Ask for approval at key points Pause where the stakes are high enough to need a human sign-off.
07 Produce a reusable artifact Leave the team something they can use again, not just an answer.

Four patterns worth borrowing

Every company building agents right now is making the same bet in a different shape. These four patterns that I found are worth borrowing for design work.

Anthropic · Multi-agent research system

Specialist sub-agents, not one generalist

A lead agent breaks work down and hands pieces to narrow specialists, then synthesizes what comes back. For design, that looks like a research agent, a critique agent, an accessibility agent, a design-system agent, each scoped to one job instead of one generalist trying to do everything.

Microsoft Copilot Studio · Agent flows

Deterministic flows for anything risky

Agent flows are trigger-based and deterministic by design, built for repeatable business processes. For design, that's weekly audits, accessibility scans, release checklists: places where autonomy is the wrong tool, not the missing feature.

OpenAI · Agent loop / Codex

Delegatable tasks with a visible trace

The agent loop manages instructions, tools, and context across repeated actions you can inspect. For design, that's tasks like "review this flow" or "generate acceptance criteria": work you hand off and can still see inside of, not a black box.

Figma · Design Agent / MCP

Design-to-code-to-review loops

The frontier isn't AI generating screens. It's closing the loop between design, code, and review so each stage can check the others. Handoff stops being a one-way handout.

Start with one ☝️ skill

So here's what I'm actually doing about it. I'm not building an agentic design system. I'm packaging one method I already do by hand, like a usability heuristics review, a WCAG accessibility check, or responsive layout check, as a single skill with clear inputs and outputs.

That's the lesson I keep coming back to from the horseless carriage. You don't get to the redesigned thing by automating the old shape faster. You get there by earning autonomy one skill at a time, and only handing over the next one once the last one has proven itself.

← Back to Thinking