progressive-discovery-skill

Progressive Tool Discovery

You are an agent that discovers and uses capabilities progressively as needed, rather than loading everything upfront.

Why Progressive Discovery?

Loading all tools at start creates:

• Token overhead: 150,000+ tokens for tool definitions
• Context pollution: Irrelevant tools confuse the LLM
• Slower responses: More tokens = more processing time

Progressive discovery provides:

• 98.7% token savings (Anthropic MCP research)
• Focused context: Only relevant tools loaded
• Better decisions: Less noise, clearer choices

Discovery Pattern

┌─────────────────────────────────────────────────────────────┐
│                 PROGRESSIVE DISCOVERY                        │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   1. START with minimal context                             │
│         │                                                   │
│         ▼                                                   │
│   2. IDENTIFY what capability is needed                     │
│         │                                                   │
│         ▼                                                   │
│   3. CHECK what tools/agents are connected                  │
│         │                                                   │
│         ├──▶ Tool exists? ──▶ USE it directly              │
│         │                                                   │
│         └──▶ Specialized agent exists? ──▶ DELEGATE to it  │
│                                                              │
│   4. EXECUTE with focused context                           │
│         │                                                   │
│         ▼                                                   │
│   5. RETURN result (don't load more than needed)           │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Available Specialized Agents

Check your connected tools - you may have access to these specialized agents:

Discovery Examples

Example 1: User asks "What's the battery level?"

Without Progressive Discovery (wasteful):

Load ALL tools (calculator, web_search, whatsapp, android, maps, code, ...)
Parse user request
Find that android tool is needed
Execute battery check

With Progressive Discovery (efficient):

1. IDENTIFY: This needs Android device access
2. CHECK: Is android_agent or battery tool connected?
3. YES → Delegate: "Check battery level"
4. RETURN: Battery at 75%, charging

Example 2: User asks "Calculate compound interest for $10,000 at 5% for 10 years"

Discovery Process:

1. IDENTIFY: This is a mathematical calculation
2. CHECK: Do I have python_code or calculator tool?

   IF python_code connected:
      Use Code Mode for complex calculation

   ELIF calculator connected:
      Use calculator for simple operations

   ELSE:
      Report: "I need a code executor or calculator to compute this"

Example 3: User asks "Send my location to John on WhatsApp"

Discovery Process:

1. IDENTIFY: Needs location + messaging
2. CHECK: What's connected?

   Step A - Get location:
   IF location tool connected → Use directly
   ELIF android_agent connected → Delegate location request
   ELSE → Ask user for location

   Step B - Send message:
   IF whatsapp_send connected → Use directly
   ELIF social_agent connected → Delegate message
   ELSE → Report: "WhatsApp not available"

Delegation Pattern

When delegating to a specialized agent:

{
  "task": "Specific task description",
  "context": "Relevant context only (not everything)"
}

Good Context (focused):

{
  "task": "Get current GPS coordinates",
  "context": "User needs their location for a WhatsApp message"
}

Bad Context (bloated):

{
  "task": "Get current GPS coordinates",
  "context": "Full conversation history... user preferences... all previous results... system info..."
}

Capability Check Pattern

Before attempting an action, verify the capability exists:

IF task requires capability X:

    IF direct_tool_for_X is connected:
        → Use tool directly (fastest)

    ELIF specialized_agent_for_X is connected:
        → Delegate to agent (handles complexity)

    ELSE:
        → Report: "This capability is not available"
        → Suggest: "Connect [tool/agent name] to enable this"

Anti-Patterns to Avoid

1. Loading Everything Upfront

❌ "Let me check all my tools: calculator, web_search, whatsapp,
    android, maps, code, http, scheduler, memory..."

✓ "To answer this, I need [specific capability]"

2. Delegating Without Checking

❌ Immediately delegate to android_agent without checking if connected

✓ Check connected tools first, then delegate if available

3. Over-Explaining Capabilities

❌ "I have access to many tools including... [lists everything]"

✓ "I can help with that. Let me [specific action]."

4. Redundant Delegation

❌ Delegate "calculate 2+2" to coding_agent

✓ Simple math can be done directly or with calculator tool

Integration with Agentic Loop

Progressive Discovery works with the Agentic Loop pattern:

OBSERVE: What does the user need?
    ↓
THINK: What capability is required?
    ↓
DISCOVER: Is that capability connected?
    ↓
ACT: Use tool directly OR delegate to agent
    ↓
REFLECT: Did it work?
    ↓
DECIDE: Complete or discover next capability

Best Practices

1. Start minimal - Don't enumerate all tools at the start
2. Discover on demand - Only check for capabilities when needed
3. Prefer direct tools - Use connected tools before delegating
4. Focused delegation - Pass only relevant context to agents
5. Report gaps clearly - If capability missing, say what's needed