A few weeks ago I read the book Patterns for Building AI Agents by Sam Bhagwat.
It made me curious.
Most AI tools I had used felt the same. You write a prompt, you get a result. Sometimes good, often generic. It didn't feel like how real creative work happens.
In design, you rarely work alone. There's usually some form of collaboration. Someone thinking about visuals, someone about copy, someone about layout. Ideas get passed around, refined, challenged.
So I started wondering:
What would happen if AI agents worked more like a small design team instead of a single assistant?
Not in theory, but in practice.
Starting Simple
I didn't want to overcomplicate it. I just wanted to try it.
So I built a simple canvas with very basic tools. Shapes, colors, a bit of structure. Nothing fancy.
Then I introduced different agents.
One acting more like a creative director. Others taking roles like designer, copy, layout.
The idea was simple. The director assigns tasks. The others execute. Everything happens on the same canvas.
At first, I wasn't even sure if this would produce anything useful.
What I Found Interesting
But what I found interesting wasn't just the output. It was the interaction.
Instead of forcing everything through a single prompt, the work was distributed. Small decisions happening in different places. The result sometimes felt more structured, sometimes more surprising.
Not always better, but different in a way that felt closer to how creative work actually happens.
Sharing the Process, Not Just the Result
That led to another idea.
If agents can produce designs, then the process itself becomes something worth sharing.
Not just the final image, but the team behind it.
Which agents were used. How they were configured. What roles they had. What tools and instructions shaped their behavior.
So I added a way to share that.
You can share the output, but also the agent setup behind it. In a way, your "design team" becomes something others can reuse, tweak, or learn from.
Letting Users Build Their Own Agents
I also didn't want to hardcode how these agents should behave.
So instead of defining everything myself, I let users create their own agents. You can define roles, write instructions, choose tools, shape how they work.
Some setups are simple. Others become surprisingly complex.
Still Figuring It Out
I'm still figuring out what actually works and what doesn't.
Sometimes the agents collaborate in a way that feels useful. Sometimes it feels unnecessary. There are moments where a single prompt would have been faster.
But there are also moments where having multiple roles changes the outcome in a meaningful way.
That's what I'm exploring.
Try It
The tool itself is free to use at designagents.app. The only constraint is that the underlying models cost tokens, so usage is tied to that.
I don't really see this as a finished product yet.
It's more an ongoing experiment around a simple question:
What happens when you stop treating AI as a single tool and start treating it more like a team?