Frequently Asked Questions About Swanepoel's Best Agents Four-Pattern Framework
21 answers covering everything from basics to advanced usage.
// Basics
What is a Playbook in the context of agent Personalization?
A Playbook is a Personalization artifact that encodes a team or organization's domain-specific methods, principles, and approaches to a task type. For example, a legal firm's contract review playbook might specify clause priorities, risk thresholds, and formatting conventions. Providing this to the agent ensures it executes tasks the way the organization would, producing outputs that look like the user's own work rather than generic AI output.
How does agent Memory work in the Four-Pattern Framework?
Memory is a Personalization mechanism where the agent creates and stores learnings from past interactions — user preferences, correction patterns, domain context — and draws on them in subsequent sessions. This creates a compounding improvement loop: each interaction teaches the agent more about the user's implicit standards. Memory can be implemented via vector stores, structured preference logs, or conversation summaries persisted across sessions.
Why does the framework say 'steal like an artist' — isn't that just copying other agents?
The 'Steal Like an Artist' principle is about deep study, not copying. It means before building, you should examine what the best agents are doing, internalize their patterns, and understand why those patterns work. This deep understanding is the prerequisite to originality — you can only innovate beyond existing patterns once you truly understand them. The framework itself is the product of this process: distilling patterns from studying the best agents into a reusable structure.
Can I use the Four-Pattern Framework for agents built with different LLM providers?
Yes. The framework is LLM-agnostic — it addresses structural design patterns, not model-specific capabilities. Focus Modes, Transparent Execution, Personalization, and Reversibility can be implemented on top of any LLM (OpenAI, Anthropic, open-source models, etc.) and any agent framework (LangChain, CrewAI, AutoGen, custom). The patterns operate at the architecture and UX layer, not the model layer.
Does the Four-Pattern Framework work for simple chatbots or only complex agents?
It works for any agent that takes actions or produces outputs users depend on. Even a simple chatbot benefits from Transparent Execution (citing sources), Personalization (remembering user preferences), and Focus Modes (separate FAQ mode from escalation mode). Reversibility matters less for read-only chatbots but becomes critical the moment the agent can modify data, send messages, or trigger workflows. Scale the implementation depth to your agent's complexity.
// How To
Do I need to implement all four patterns at once?
No. Start by auditing your agent against all four and scoring each as absent, partial, or present. Then prioritize the pattern that addresses your biggest pain point. If users don't trust outputs, start with Transparent Execution. If outputs are generic, start with Personalization. If users fear mistakes, start with Reversibility. If the agent underperforms across task types, start with Focus Modes. The framework is designed for incremental adoption.
How do I implement Reversibility for agents that interact with external APIs?
Identify every external action and design a rollback path for each. Stage destructive actions as pending-confirmation before execution. Use platform-native undo mechanisms where available (e.g., soft deletes, version history APIs). Log every action with enough state to reconstruct the previous state. Where true undo is impossible (e.g., sending an email), implement a confirmation gate with a preview. The goal is bounding the downside, even if perfect undo isn't always feasible.
What does Transparent Execution look like in a chat-based agent?
In a chat interface, Transparent Execution means the agent shows a live progress indicator listing completed and upcoming steps, cites which tools or documents it consulted with summaries of what it found, surfaces assumptions it's making, and flags uncertainties before presenting a final answer. Think of it as a visible scratchpad the user can monitor. This lets users intervene mid-process rather than discovering errors only in the final output.
How many Focus Modes should a typical agent have?
Most agents benefit from 2 to 5 Focus Modes. Identify the distinct task types the agent performs — for example, a coding agent might have Plan Mode, Code Mode, Debug Mode, and Review Mode. Each mode should have a meaningfully different tool set and system prompt. Too few modes means you're still building a generic agent; too many creates cognitive overhead for users. Start with the most distinct task types and split further only when evaluation reveals a need.
How do I convince my team to adopt the Four-Pattern Framework?
Start with the audit step: map your current agent against all four patterns and score each as absent, partial, or present. This usually reveals obvious gaps that correlate with known user complaints. Then pick the single highest-leverage pattern and implement it as a focused sprint. Measurable improvement in user trust, task completion rates, or error recovery builds the case for implementing the remaining patterns. The framework's incremental nature makes it low-risk to pilot.
// Troubleshooting
What happens if I skip Personalization and just use a really good system prompt?
A good system prompt provides static instructions but doesn't adapt to the specific user's preferences, past interactions, or organizational methods. Without Personalization, every user gets the same generic output regardless of their context. The agent does something rather than the right thing. Personalization through Playbooks, Memory, and Connected Systems makes outputs feel like the user produced them — which is the difference between a demo and a production tool.
My agent's outputs are correct but users still don't trust them — what pattern should I focus on?
Transparent Execution. When users can't see how the agent arrived at a correct answer, they have no basis for trust. Showing the process — which sources were consulted, what reasoning was applied, what assumptions were made — gives users the evidence they need to verify correctness themselves. Trust requires visibility. Even a perfect result delivered as a black box will be doubted, especially in high-stakes domains like legal, medical, or financial tasks.
How do I handle edge cases where an agent action is truly irreversible?
For truly irreversible actions (sending emails, publishing content, executing financial transactions), implement a confirmation gate: preview the exact action, show the user what will happen, require explicit approval, and log the action for audit. You can also offer a dry-run mode that simulates the action without executing it. The principle of bounding the downside still applies — even if you can't undo, you can prevent accidental execution and make the risk explicit.
What's the biggest mistake people make when building AI agents?
Building a do-anything, ask-anything agent without Focus Modes. This makes it impossible to optimize quality on any single task type, leaves users unsure how to get the best result, and makes evaluation intractable. The second biggest mistake is optimizing for speed to outcome instead of speed to understanding — generating fast output that misses the user's implicit preferences. The Four-Pattern Framework exists specifically to counter these common anti-patterns.
// Comparisons
What is the difference between Focus Modes and just using different prompts for different tasks?
Focus Modes go beyond prompt variation. Each mode constrains the agent's tool access, narrows the action space, sets explicit user-facing expectations, and enables independent evaluation. A different prompt alone doesn't restrict which APIs the agent can call, doesn't signal to the user what behavior to expect, and doesn't let you run targeted evals on a specific task type. Focus Modes are an architectural commitment, not a prompt swap.
How is the Four-Pattern Framework different from generic agent best practices?
Generic best practices tend to focus on prompt engineering, tool selection, and error handling. The Four-Pattern Framework prescribes four specific structural patterns — Focus Modes, Transparent Execution, Personalization, and Reversibility — each with concrete implementation guidance. It also introduces the principle of speed to understanding over speed to outcome, and provides a mode-by-mode evaluation methodology. These are opinionated design commitments, not general advice.
How does the Four-Pattern Framework relate to human-in-the-loop design?
Transparent Execution and Reversibility are specific implementations of human-in-the-loop principles. Transparent Execution gives humans visibility to intervene during execution, not just after. Reversibility gives humans the ability to undo actions after execution. Together with Focus Modes (which set clear expectations for human input) and Personalization (which reduces the need for human correction), the framework provides a structured approach to human-in-the-loop that goes beyond a simple approval gate.
// Advanced
What if my agent only does one thing — do I still need Focus Modes?
If your agent genuinely performs a single task type with a single tool set, you already have an implicit Focus Mode. Formalize it by naming it, constraining the tool set explicitly, and setting clear user expectations. Even single-task agents often have sub-modes (e.g., a writing agent might have Draft Mode and Edit Mode). Identifying these sub-modes lets you optimize each independently and gives users clearer mental models.
How do I measure speed to understanding versus speed to outcome?
Measure speed to understanding by tracking how many interactions it takes before the agent produces an output the user accepts without revision. A low number means the agent quickly grasped the user's intent and context. Compare this against raw time-to-first-output (speed to outcome). An agent that asks two clarifying questions but produces an accepted output on the first try has better speed to understanding than one that instantly generates three rejected drafts.
Is the Four-Pattern Framework only for customer-facing agents or also for internal tools?
It applies equally to both. Internal agents serving employees benefit from the same patterns: Focus Modes help specialists use the agent efficiently, Transparent Execution builds trust among teams that need to verify outputs, Personalization encodes team-specific workflows, and Reversibility protects against costly internal mistakes. Internal agents often get less UX investment, which makes these patterns even more impactful for adoption and trust.
Can I apply the Four-Pattern Framework to a multi-agent system?
Yes. In a multi-agent system, each agent can implement its own Focus Modes and Personalization layer, while Transparent Execution surfaces the inter-agent coordination process to the user. Reversibility becomes even more critical because cascading actions across agents can compound errors. Apply the framework to each agent individually and then to the orchestration layer. The mode-by-mode evaluation approach is especially valuable for isolating which agent in the chain needs improvement.