--- title: "The Proactive Agent Problem: What Claude Fable Got Right" canonical: "https://agenticup.dev/posts/proactive-agent-design-patterns/" pubDate: "2026-06-12T00:00:00.000Z" description: Claude Fable 5 is relentlessly proactive. Two days with it reveals what this means for AI agent builders. Proactivity is a feature when goals are clear and a liability when they are not. tags: [claude-fable, anthropic, proactive-agents, agent-design, autonomy, vertical-agent-method] --- **TL;DR:** Claude Fable 5 acts relentlessly. It holds the goal and works backward through techniques without prompting. For builders, the core design problem isn't proactivity itself but scope control. When goals are clear, proactivity is a feature. When goals are vague, it becomes unpredictable. The Vertical Agent Method's spec-first approach defines the scope an agent can act within. > **Key takeaways:** > - Proactivity is a feature when goals are clear and a liability when goals are vague > - Claude Fable 5 runs browser automation, custom HTTP servers, shadow DOM access, and macOS accessibility APIs from a single prompt > - The security risk isn't refusal but execution: proactive agents act on hidden instructions in content they process > - Don't run frontier-level proactive agents outside a sandbox > - The Vertical Agent Method makes the tradeoff tractable: focused agents with clear goals don't need to guess A scrollbar bug in a web application jump menu. I typed one line: "Look at dependencies to help figure out why there is a horizontal scrollbar here." From that single prompt, the agent ran the dev server, fired up Playwright in Chrome, Firefox, and WebKit, enabled macOS scrollbar settings for testing, identified Safari as the browser showing the bug, built a custom test HTML page, opened Safari using a macOS accessibility API workaround, created a Python CORS server to receive measurement data, injected JavaScript into the site's templates to trigger the modal, accessed the shadow DOM of a Web Component to read textarea computed styles, and confirmed the fix worked. All of that from one line. I did not tell it to run Playwright. I did not tell it to build a CORS server. I did not tell it to access the shadow DOM. I said "fix the scrollbar" and it chose every step because each one was instrumentally useful for that goal. That is the proactive agent. And it's the design problem every AI agent builder needs to think through. ## What proactivity means A reactive agent waits for instructions. You ask it to build a function, it builds a function. You ask it to fix a bug, it fixes the bug. Every action is a response to an explicit prompt. A proactive agent holds the goal and works backward. It sees a scrollbar bug and asks: what tools do I have, which ones apply, what is the fastest path to diagnosing this? It answers those questions without being prompted. The spectrum runs from fully reactive to over-proactive. Claude Fable 5 sits near the top of the spectrum, and its behavior is the textbook case of why the tradeoff matters. A reactive agent would have taken 10x longer and asked for permission at every step. Fable ran the full diagnostic pipeline because every step served the target. This is great when the goal is clear. It's dangerous when the goal is vague. ## Why scope control is the real problem The proactivity problem isn't about capability. It's about scope control. Every builder eventually hits this wall: my agent does more than I asked. Sometimes that is great. Sometimes it changes files I did not know it had access to, runs commands that cost money, or takes an hour on a task that should have taken 2 minutes. This is the exact failure mode the Vertical Agent Method addresses. Pick one workflow, build one agent, ship in 14 days. When your agent has one clear job, proactivity is a feature: it finds the fastest path to the goal. When your agent has vague scope, proactivity becomes unpredictable. The scrollbar bug session proves this. Fable could have stopped after identifying Safari. Instead it ran the complete diagnostic pipeline: server, Playwright, custom HTTP server, shadow DOM access, screenshots. Every step was instrumentally useful. The problem isn't that Fable did too much. The problem is that a reactive agent would have taken 10x longer and asked for permission at every step. The tradeoff isn't binary. More proactive means faster completion and higher surprise cost. More reactive means more control and higher latency per task. The right answer isn't "be less proactive." It's "be proactive within spec." ## The security dimension There is a hard truth underneath this discussion. Coding agents can do anything you can do by typing commands into a terminal. Frontier models know every trick in the book, and evidently a few that nobody has written down before. The security risk with proactive agents isn't that they refuse to do things. It's that they do things you did not ask for, including things an attacker hid in content you process. Code comments, pasted text, issue threads, documentation: all of these can carry hidden instructions that a proactive agent acts on. A proactive agent that reads code, issues, and documentation is a proactive agent that is vulnerable via prompt injection. The practical implication: don't run frontier-level proactive agents outside a sandbox. Not because they are malicious. Because their proactivity makes them effective at both intended and unintended tasks, and an attacker who can put text in front of them can influence which is which. This not a reason to suppress proactivity. It's a reason to scope it. ## The design choice Every time you choose an agent's proactivity level, you are making a tradeoff. The question isn't "how proactive should my agent be?" The question is "how clear is the spec that defines what my agent is allowed to be proactive about?" Fable's behavior in that scrollbar session was a feature, not a bug, because the goal was clear. The scrollbar was the target, and every technique deployed served that target. If the goal had been "explore my codebase and make improvements," that same proactivity would be a liability. The Vertical Agent Method handles this by defining the workflow before building the agent. A spec that says "this agent processes incoming support tickets, categorizes them, drafts a response, and triages to the right team member" gives the agent clear boundaries for proactivity. A spec that says "help me with my codebase" invites unpredictable behavior. Proactivity isn't the problem. Vagueness is. ## FAQ > **What does proactive mean in the context of AI coding agents?** > A proactive agent takes actions toward a goal without being explicitly asked. It identifies a problem, chooses a tool, and executes, even when the user's prompt did not mention the specific step. In one session, Claude Fable used browser automation, built a custom CORS server, accessed shadow DOM, and ran macOS utilities from a single one-line prompt. > > **Is proactivity a feature or a risk?** > Both. Proactivity is what makes agents useful: a reactive agent that waits for every step instruction is an expensive autocomplete. But proactive agents can cause damage when subverted via prompt injection or when they exceed their intended boundaries. The answer is to design proactivity within guardrails. > > **How does Claude Fable 5 compare to other agents?** > Claude Fable 5 sits above Opus 4.8 as a Mythos-class model. It uses techniques like browser automation, macOS accessibility APIs, custom HTTP servers, and shadow DOM access that go beyond typical coding agent tool use. > > **How should builders think about the proactive/reactive tradeoff?** > The tradeoff isn't binary. The right level depends on how much damage the agent can do in your environment and how well-specified the goal is. The Vertical Agent Method's one workflow, one agent approach makes it tractable. ## Related Posts - [Spec-Driven Development and the Vertical Agent Method](/posts/spec-driven-development-vertical-agent-method/): How structured specs define what an agent is allowed to be proactive about. - [The Vertical Agent Method framework](/posts/the-vertical-agent-method-framework/): The full workflow-first approach to agent scoping. [Anthropic's research on proactive agents](https://www.anthropic.com/research/proactive-agents) covers design patterns for autonomous decision-making in AI agents. --- This article was published on Agentic Up (https://agenticup.dev): practical guides for developers and founders building with AI agents. Reach me at hello@agenticup.dev.