Frequently Asked Questions About Swanepoel's Best Agents Four-Pattern Framework
23 answers covering everything from basics to advanced usage.
// Basics
What is the difference between Focus Modes and just having different prompts for different tasks?
Focus Modes go far beyond swapping prompts. Each mode constrains the agent's entire action space — including which tools are available, what system prompt governs behavior, and what the user is told to expect. Different prompts alone don't restrict tool access, set user expectations, or enable mode-specific evaluation. Focus Modes treat each task type as a distinct, optimizable product surface.
Can I apply only one of the four patterns without the others?
Yes, each pattern is independently valuable and you can implement them incrementally. However, the patterns are synergistic — Focus Modes make Personalization and evaluation easier; Transparent Execution builds trust needed for users to rely on Reversibility. Start with whichever pattern addresses your biggest pain point, but plan to layer in the others over time for compounding returns.
What is the Steal Like an Artist principle in Swanepoel's framework?
It's the foundational research principle: before building your agent, deeply study what the best agents in your space are already doing. Understand their patterns, internalize their design decisions, then use that understanding to create something better and unique. This is not copying — it's the prerequisite to originality. Skip this and you risk reinventing the wheel badly.
Should I implement all four patterns at once or incrementally?
Incrementally, starting with whichever pattern addresses your biggest user pain point. If users don't trust outputs, start with Transparent Execution. If outputs are generic, start with Personalization. If the agent is confused and inconsistent, start with Focus Modes. If users won't try high-value tasks, start with Reversibility. The audit step (Step 1 of the workflow) tells you which pattern is your highest-leverage starting point.
What's the biggest mistake people make when building AI agents according to this framework?
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 what to expect, and makes evaluation intractable. The second biggest mistake is optimizing for Speed to Outcome (fast output) instead of Speed to Understanding (right output). Fast but wrong outputs are worse than slower correct ones.
Can I use this framework to evaluate third-party AI agents I'm considering buying?
Yes, it's an excellent evaluation rubric. Score any agent against the four patterns: Does it have Focus Modes or is it a generic do-anything interface? Does it show its process (Transparent Execution) or just final results? Does it learn your preferences and methods (Personalization) or give generic outputs? Can you undo its actions (Reversibility) or are mistakes permanent? Agents scoring low across patterns are likely to produce low-trust, low-value results.
// How To
How many Focus Modes should my agent have?
Aim for 2–5 distinct modes based on the real task types your agent performs. Too few and you're not constraining enough; too many and you fragment the experience. Identify the natural clusters of tasks — for example, a coding agent might have Planning Mode, Implementation Mode, and Debug Mode. Each mode should have clearly different tool sets and user expectations.
How do I build a Playbook for my agent's Personalization layer?
Document how your team or organization actually does the task the agent will perform. Include decision criteria, source hierarchies, formatting conventions, analytical frameworks, and common judgment calls. Write it as if you were onboarding a new hire who needs to produce work indistinguishable from the team's existing output. Feed this document to the agent as part of its system prompt or retrieval context.
How do I implement Reversibility for actions that call external APIs?
Stage all external-facing actions as pending-confirmation before execution, showing the user exactly what will happen. Log a rollback path for each action. Where APIs support it, use draft or sandbox modes first. For APIs without native undo, implement compensating transactions — a second call that reverses the effect. Integrate with platform change-tracking features like Word's track-changes or Git's version control where applicable.
How do I show Transparent Execution without overwhelming the user?
Use progressive disclosure. Show a high-level task list by default — completed steps, current step, upcoming steps. Let users expand any step to see tool calls, inputs, outputs, and assumptions. Surface uncertainties and assumptions prominently since those are where intervention matters most. The goal is that users can scan the overview in seconds but drill into details when needed.
How do I evaluate each Focus Mode independently?
Create mode-specific evaluation sets (e-vals) with inputs and expected outputs tailored to each mode's constrained task type. Because the action space is smaller per mode, your test cases are more focused and your metrics more meaningful. Run evaluations per mode, track scores separately, and improve each mode without risking regressions in others. This is dramatically more effective than holistic evaluation of a do-anything agent.
// Troubleshooting
My agent is slow because it asks too many questions — am I implementing Speed to Understanding wrong?
Possibly. Speed to Understanding doesn't mean interrogating the user. It means the agent should rapidly gather context from all available sources — including Personalization artifacts like Playbooks and Memory — before asking the user. Only ask questions the agent cannot answer from existing context. Pre-fill assumptions and let the user confirm or correct. The goal is understanding, not an interview.
Users still don't trust my agent even though I added Transparent Execution — what's wrong?
Check whether your transparency is genuinely useful or performative. Are you showing real tool calls with real inputs and outputs, or just generic 'Searching...' messages? Are uncertainties and assumptions surfaced, or hidden? Can users actually intervene mid-process? Also verify that the other three patterns are in place — transparency alone can't fix generic outputs (missing Personalization), confusing behavior (missing Focus Modes), or fear of irreversible actions (missing Reversibility).
My agent works fine for simple tasks but fails on complex ones — which pattern should I fix first?
Start with Focus Modes. Complex tasks often fail because the agent is trying to do everything at once in one undifferentiated mode. Split the complex workflow into sequential modes — for example, Research Mode → Analysis Mode → Drafting Mode. Each mode gets a constrained tool set and focused prompt. Then layer in Personalization (Playbooks for each mode) and Transparent Execution so users can intervene between modes.
// Comparisons
How does Swanepoel's framework compare to the ReAct or Chain-of-Thought patterns?
ReAct and Chain-of-Thought are reasoning patterns — they govern how the LLM thinks internally (interleaving reasoning and actions, or showing reasoning steps). Swanepoel's framework is a structural design framework — it governs how you architect the entire agent experience across four dimensions. They operate at different levels. You can and should use ReAct or CoT inside agents built with the Four-Pattern Framework; they're complementary, not competing.
How does this framework compare to building agents with LangChain or CrewAI?
LangChain and CrewAI are implementation frameworks — they provide tools, chains, and multi-agent orchestration. Swanepoel's framework is a design framework — it tells you what structural patterns your agent should have regardless of what tools you build it with. You can implement Focus Modes, Transparent Execution, Personalization, and Reversibility inside LangChain, CrewAI, or any other stack. The Four-Pattern Framework is tool-agnostic.
Is Reversibility just the same thing as adding a confirmation step before actions?
Confirmation is one part, but Reversibility is much broader. It includes undo at multiple granularity levels (line, file, conversation state), rollback paths logged for every action, parallel output generation where all but the best can be discarded, and integration with native platform change-tracking (like Git or Word track-changes). The goal is bounding the downside of the entire interaction, not just adding a 'Are you sure?' prompt.
How does Personalization differ from just fine-tuning the model?
Fine-tuning changes the model's weights to shift its general behavior. Personalization in this framework operates at the application layer — Playbooks, Memory, and Connected Systems are context provided to the model at inference time. This is more flexible (no retraining needed), more transparent (users can see and edit what the agent knows about them), and more dynamic (Memory updates every session). They can be complementary but serve different purposes.
// Advanced
How do I implement Memory for Personalization across sessions?
After each interaction, have the agent extract key learnings — user preferences, corrections, domain-specific terminology, approved approaches — and store them in a persistent store (vector DB, structured DB, or user profile). On subsequent sessions, retrieve relevant memories as part of the agent's context. Periodically prune or consolidate memories to avoid context window bloat. The user should be able to view, edit, and delete stored memories for trust and control.
Can I use the Four-Pattern Framework for multi-agent systems?
Absolutely. Apply Focus Modes by assigning each agent in the system a constrained role (essentially each agent is a mode). Use Transparent Execution to show users which agent is active and what it's doing. Personalization should be centralized so all agents share the same Playbooks, Memory, and context. Reversibility must span the entire system — users need to roll back multi-agent workflows, not just individual agent actions.
How do I handle Focus Mode transitions — should the user switch modes or should the agent?
Both approaches work, but explicit user-initiated switching is safer for high-stakes domains. The user knows they're in a specific mode with specific expectations. For lower-stakes workflows, the agent can suggest mode transitions based on task context ('It looks like we're done researching — switch to Drafting Mode?'). Avoid silent automatic switching, which undermines the clarity Focus Modes are designed to provide.
What if my agent's domain doesn't have an obvious Playbook to encode?
Every domain has implicit methods — they're just not always documented. Interview the target users: how do they approach the task? What do they check first? What shortcuts do they take? What quality criteria do they use? Document these as the Playbook. If the agent serves general consumers, use best-practice methods from the domain (e.g., standard research methodology) and refine with Memory as users interact.
How does the Four-Pattern Framework apply to autonomous agents that run without user supervision?
All four patterns still apply but shift emphasis. Focus Modes constrain what the autonomous agent attempts per run. Transparent Execution becomes asynchronous logging — the user reviews the agent's process after the fact. Personalization via Playbooks is even more critical since there's no real-time user input. Reversibility becomes essential since mistakes happen without oversight — every action must be rollbackable and the worst case must be bounded.