Tool-as-Guide: A Pattern for Reliable AI Agents

[mazzucci]

Pre-submission Checklist

• This post follows the MCP community guidelines

What would you like to share?

An architectural pattern for building reliable, auditable AI agents by separating workflow control from execution

🎬 See It In Action

Pizza Ordering with Claude Desktop

What you just saw:

• User asks "what do you recommend?" → Claude explains each option with reasoning
• User says "pick something for me" → Claude intelligently selects and explains why
• Questions follow a strict order (crust → category → toppings → size)
• Natural, helpful conversation, but protocol-enforced

The key insight: The guide controls the workflow. Claude provides the intelligence.

---

🎯 The Problem

Autonomous AI agents are powerful but unreliable for critical workflows:

• ❌ Skip important steps
• ❌ Inconsistent behavior across runs
• ❌ Hard to audit or debug
• ❌ Can't guarantee protocol compliance
• ❌ Unsuitable for regulated domains

Current solutions don't solve this:

• Prompts: Too fragile ("please follow these steps...")
• Traditional workflows: LLM is passive, no agency
• Agent frameworks: Too unpredictable for critical systems

---

💡 The Solution: Tool-as-Guide Pattern

TL;DR: The Tool-as-Guide pattern is a workflow engine with inversion of control, acting as a protocol-driven supervisor for agentic systems.

🗺️ Think of It Like GPS Navigation

When you're driving through a city:

• You're the intelligent, capable driver - You navigate traffic, make decisions, handle unexpected situations
• GPS provides turn-by-turn instructions - Tells you which route to follow, which turn to take next
• GPS doesn't drive for you - But it ensures you don't miss critical turns or get lost

Tool-as-Guide works the same way:

• Agent is the intelligent worker - Capable of reasoning, adapting, executing tasks
• Guide provides step-by-step instructions - What to do next, what protocol to follow
• Guide doesn't do the work - But it ensures critical steps aren't skipped and protocols are followed

The agent stays intelligent and autonomous. The guide ensures reliability and compliance.

---

🔌 Why MCP is Perfect for This

The Model Context Protocol makes this pattern elegant and powerful:

1. Natural inversion of control - The LLM actively queries the guide tool (via MCP), rather than the guide controlling the LLM
2. Seamless integration - Works with Claude Desktop, Cursor, or any MCP client
3. Stateful sessions - The guide maintains workflow state across multiple tool calls
4. Standard protocol - No custom APIs or SDKs needed

The workflow guide is just another MCP tool - but one that returns instructions instead of data.

---

💡 Key Learnings

1. The pattern works for both chat and autonomous workflows

Built two working examples:

• 🍕 Pizza ordering - Chat interface with Claude Desktop (shown above)
• 🏥 Medical triage - Autonomous agent using Jupyter + Gemma (local LLM)

Same core pattern, different execution contexts. Both demonstrate protocol enforcement with agent intelligence.

2. LLMs stay intelligent within protocol bounds

The guide doesn't make agents "dumb" - quite the opposite:

• User: "What do you recommend?" → Claude provides detailed reasoning
• User: "Pick something for me" → Claude makes smart choices and explains them
• The deterministic flow is enforced by the tool, not fragile prompts

3. Efficiency benefits

Progressive disclosure:

• Agent receives only the current instruction
• Not the entire workflow tree or decision logic
• Smaller context windows → lower token costs
• Faster execution (deterministic protocol logic runs outside the LLM)

---

🤔 Questions for the Community

1. Have you encountered similar patterns? Curious if others have explored workflow engines as MCP tools
2. Other use cases? Where else could deterministic protocols + agent intelligence be valuable?
3. Improvements? Always looking for feedback on the architecture

Would love to hear your thoughts! 💬

Relevant Links

Repository: https://github.com/mazzucci/tool-as-guide

What's included:

🍕 Pizza Ordering Example

• Chat interface demo with Claude Desktop or Cursor
• Shows the pattern with conversational AI
• Full MCP server implementation

🏥 Medical Triage Example

• Autonomous agent demo (Jupyter + Ollama/Gemma)
• Shows the pattern for critical systems
• Protocol enforcement with emergency escalation

📖 Documentation

• Pattern explanation and architecture
• Setup instructions for both examples
• Mermaid diagrams and code examples

Open source (MIT). Feedback and contributions welcome!

[mazzucci]

How is this different from workflow engines?

While tools like mcp-workflow are workflow engines built on MCP, Tool-as-Guide inverts the relationship:

Traditional workflow engines (mcp-workflow, etc.):

• Engine: "I'll execute this activity for you"
• LLM: Passive (just triggers workflow steps)
• The engine does the work

Tool-as-Guide pattern:

• Guide: "Here's what to do next"
• LLM: Active (executes, reasons, adapts within each step)
• The agent does the work

Think of it as:

• Autopilot (workflow executes for you) vs.
• GPS (guide tells you what to do, you drive)

Both solve orchestration, but from opposite directions. Traditional engines reduce agent autonomy. Tool-as-Guide preserves it while enforcing protocol.