4 Patterns the Best AI Agents Actually Share

Picasso said "good artists borrow, great artists steal." Mardu Swanepoel—builder at Flinn AI—opens with that quote, and it's doing real work. He's not being edgy. He's describing a legitimate engineering methodology: study what's already working, understand why it works, then extract that into something you can actually use.

That's what his recent talk at the AI Engineer channel is: a 10-minute teardown of four agents—Harvey, Cursor, Manus, and Claude—across completely different domains, looking for the patterns they share. Coding, legal, general-purpose agents. Different surfaces, different users, different stakes. And yet four things keep showing up.

Whether you're building agents or just living inside them, these patterns are worth knowing.

Focus Modes: The art of doing less, better

The instinct when building an agent is to make it capable of everything. Why constrain it? Swanepoel's answer: because "do anything, ask me anything" UIs create a specific problem where the user doesn't know what inputs will produce the best outputs, expectations balloon, and quality suffers across the board.

Focus modes flip this. You narrow the action and input space—planning mode, research mode, debug mode—and suddenly you can actually optimize for that smaller surface. Better system prompts, tighter evals, fewer tools getting in each other's way.

Cursor is his example here. Switch to planning mode and the agent does exactly one thing: it comes up with a plan and asks you questions. It will not write code. You know what you signed up for. Debug mode is different—it runs a hypothesis-driven diagnosis, spins up a dedicated debug server, pushes logs. It's not trying to be a planner right now; it's being a debugger.

There's an interesting tension here that Swanepoel doesn't fully resolve: focus modes are partly a UX decision (set user expectations) and partly an engineering decision (constrain the optimization target). Those goals usually align, but they don't always. An agent that's been made more predictable for users might be less flexible for power users who know what they're doing. That tradeoff is real, and it's not obvious where the right line is.

Transparent Execution: Show your work

This one is deceptively important. Swanepoel frames it as a shift "from delegation to collaboration"—and that's not just vibes, it has practical implications.

The claim: if an agent hands you a finished output with no window into how it got there, you'll trust it less than if it showed you the process—what it read, what it assumed, where it was uncertain. That matches how I think most people experience working with humans, so it seems plausible it transfers.

But the bigger practical win is earlier intervention. Swanepoel puts it plainly: "If at step two of the agent, we saw the agent has just read from, I don't know, Notion docs A and B, and I wouldn't have done that, then we can very easily say, 'Hey, I think let's stop and take a different approach.'"

Claude's interface handles this with a live task list that updates alongside every tool call—inputs, outputs, what's done, what's next. You can see the agent mid-thought. Manus does something similar with task progress that shows both completed steps and what's coming. Both designs treat the user as a participant in the process rather than just the recipient of its output.

This matters a lot for trust—and trust, at this stage of agent adoption, is still fragile. Users who can see what an agent is doing are users who can catch it going sideways before it's too late. The cost of opacity isn't just philosophical; it's compounding errors that could have been caught at step two.

Personalization: Speed to understanding, not speed to output

Here's where Swanepoel draws a distinction I think is genuinely underrated. Most agents, he says, are optimized for speed to outcome—get the output generated as fast as possible. What they're not optimized for is speed to understanding—actually grasping the nuances of what the user wants and how they'd want it done.

"It's very easy to just generate an output for a user, but if it's not really in line with what the user wants in terms of how they wanted it, it's going to be useless."

This lands. Fast wrong answers aren't a win. And the ways agents currently address this are pretty varied. Harvey's approach is a "playbook"—legal firms encode their own methods and principles for reviewing a contract, and Harvey executes it the way that firm would, not the way some generic legal AI might. Swanepoel is clear he's not a legal expert, but the concept tracks: institutional knowledge baked in before the agent starts, rather than corrected after.

Harvey also uses memory that builds across interactions, so the agent gets better at understanding you over time. Claude takes the connector approach—skills, systems, knowledge bases you can attach to it. Different architectures, same underlying goal: minimize the gap between what you asked and what the agent understood you to mean.

There's a real open question here about how personalization interacts with the regulatory landscape. A Harvey playbook encoding a specific firm's legal methods is also encoding specific legal judgments—and those have compliance implications that generic AI outputs might not trigger. The personalization that makes these agents powerful is exactly what makes them harder to audit.

Reversibility: Bounding the downside

This might be the most practically underappreciated of the four. The psychological argument Swanepoel makes is simple: if you know you can undo it, you'll try things you otherwise wouldn't. "If we know what the worst-case outcome is... it makes the ROI calculation much easier for me to actually say, 'Happy if you go and do that.'"

Cursor's implementation is layered in a way that's worth spelling out. You can accept or reject changes at the line level. At the file level. You can roll back entire conversation states—"undo the last three messages and everything you changed." And you can run multiple model outputs in parallel from the same input, knowing you'll discard all but the one you want. That last bit reframes something interesting: the user is intentionally creating waste as a strategy for finding value. Reversibility makes that a rational choice rather than a reckless one.

Harvey handles it differently—leaning into the track-changes paradigm through its Microsoft Word add-in. Legal professionals already live in that review/accept/reject workflow; Harvey just plugs into the same native API rather than inventing a new mental model. That's smart: meet users where their muscle memory already lives.

The broader point is that reversibility is a psychological unlocking mechanism, not just a safety net. When the downside is bounded, users take on higher-value tasks. Which means the agents that invest in reversibility might see higher-stakes—and higher-ROI—adoption patterns than agents that don't.

What's striking about all four patterns is that none of them are about raw model capability. They're about the contract between the agent and the user: what the agent will try to do, how visible its process is, how well it understands what you actually want, and how safe it is to let it try.

That's a different conversation than "which model is smartest." And it might end up being the more consequential one.

Yuki Okonkwo is Buzzrag's AI & Machine Learning Correspondent. She covers the people and systems shaping how AI actually gets built and used.