What the Best Agents Share

What can you learn from an agent that already works well? Start by studying its choices closely enough to understand why they work. Mardu Swanepoel opens with an interpretation of stealing, attached to a quotation he attributes to Picasso: understand existing work deeply, make its lessons your own, and use that understanding to create something better. The useful act is transforming an idea, not presenting someone else’s work as yours.

The examples are Cursor, Claude Cowork, Harvey, and Manus—products Swanepoel considers particularly worth studying, rather than winners of a measured ranking. The comparison follows four patterns, asking what each pattern does, what value it provides, and how it appears in a working interface. That makes the product behavior, rather than the product label, the reusable lesson.

Focus modes constrain both the action space and the input space. A planning or research mode gives the agent a smaller job to do well. For engineers, that creates a tractable optimization target: remove tools that do not belong in the mode, refine the system prompt around the remaining task, and tune evaluations for that narrower behavior before expanding the agent’s responsibilities.

The same constraint helps users. An open-ended interface invites broad expectations without explaining which inputs will produce useful results. Selecting a mode establishes a more specific agreement: what the user should supply, what the agent will do, and what kind of result to expect. A question from a planning agent can then feel like progress rather than a failure to execute.

Cursor makes that agreement visible through a dropdown in its chat interface. The modes shown have different procedures, not merely different names:

In the planning example, the absence of code changes is part of the contract. In Cursor’s Debug mode, the investigation follows hypotheses about possible faults. Swanepoel describes starting a dedicated debug server and sending logs there to work out what is happening. The narrower mode lets the product support a specific workflow in depth.

Once the agent starts working, the next question is whether the user can follow its execution. Transparent execution turns delegation into collaboration by exposing the process alongside the eventual result. Which material did the agent read? What assumptions did it make? Where is it uncertain? Those details give the user a basis for trusting—or questioning—the output.

Visibility also creates an opportunity to intervene before more work is wasted. Swanepoel’s example is an agent that, at step two, has read Notion documents A and B. If the user would not have chosen those documents, seeing that action provides a concrete reason to stop and redirect the agent. A progress display becomes useful when it exposes decisions early enough for the user to change what happens next.

The Cowork interface shown makes several parts of execution inspectable:

• Progress: A list distinguishes completed work from upcoming work, including the next step.
• Context: The interface shows the context being used and the skills the agent draws on.
• Tool activity: Tool calls expose their inputs and outputs, so the user can inspect more than a generic working indicator.

Together, these surfaces explain what is happening during execution. Manus offers a similar view through task progress, the material it inspected, and what it made of that material. Both examples keep the user involved while there is still time to influence the result.

An agent can execute visibly and still approach the task in the wrong way. Personalization supplies the knowledge, systems, principles, and patterns the user would have applied themselves. Its purpose is to improve speed to understanding, not simply speed to outcome. A quickly generated result can be useless if it misses the user’s intended approach, including preferences and nuances they have not restated in the current request.

Harvey makes that context explicit through playbooks. Swanepoel, qualifying his explanation as a nonexpert understanding of legal work, describes a playbook as a legal firm’s methods and principles for a task such as contract review. Creating one gives the agent a reusable account of how the firm wants that work approached.

Memory provides another route: Swanepoel describes Harvey creating memories from instructions and interactions, then drawing on them in later exchanges. This is a description of the capability, not broad availability; Harvey’s later Memory announcement still identified it as Early Access in August 2026. Claude’s skills, connectors, and connected systems provide additional ways to supply knowledge and personalize the agent. Playbooks capture an intended method, memories retain context across interactions, and connected systems make relevant knowledge available to the task.

The final pattern addresses what happens when the agent gets something wrong. Reversibility bounds the cost of mistakes by letting users undo agent actions. Knowing the downside makes the decision to delegate easier: the user can weigh the potential benefit against a more understandable cost of failure. Swanepoel connects that confidence to greater willingness to experiment and attempt higher-value tasks.

Cursor illustrates why the granularity of undo matters. A user may want to reject one change while preserving the rest, or abandon an entire stretch of work.

The conversation example goes back before the last three messages and undoes the changes made during them. That gives the user a way to retreat from an unsuccessful direction without deciding separately about every edit it produced.

Reversibility also supports deliberate experimentation. Cursor can produce multiple outputs from the same input in parallel using different models. The user begins with the expectation that all but ideally one result will be discarded. Rejection is therefore part of the intended workflow, rather than an exceptional failure. The value of undo is that users can explore alternatives with less downside, within the scope of changes the product can restore.

The last example places reversibility inside a familiar editor. Harvey’s Word add-in runs within Microsoft Word, where users already work with document revisions. Swanepoel describes an integration with the native Word API that lets users make and view the agent’s changes as a reviewer or editor normally would. The agent’s contribution enters an existing review workflow, giving users a familiar way to inspect changes instead of asking them to accept an opaque replacement document.