Replace MCP prompts with Skills or make prompts invokable by Agent

[Traddoo]

Feature Request: Replace MCP Prompts with Skills Pattern

Summary

We propose deprecating the current MCP “prompts” primitive in favor of a more powerful “skills” pattern that enables agent-invokable, composable workflows rather than just user-triggered templates.

Problem with Current Prompts

Current State:

• Prompts are user-controlled only - they must be manually triggered through UI elements (buttons, slash commands, modals)
• Agents cannot discover or invoke prompts autonomously
• Limited to simple templating with argument substitution
• Create friction in enterprise scenarios where multiple servers expose dozens of prompts

Key Limitation:

User: "Help me find housing assistance in zip code 12345"
Agent: [Cannot use the find-housing-assistance prompt - must wait for user to click button]

The agent knows the task requires housing assistance but cannot leverage the carefully-crafted prompt that exists on the MCP server.

Proposed Solution: Skills Pattern

Replace prompts with Skills - comprehensive, agent-discoverable instruction sets that combine:

• Multi-step workflows (not just single templates)
• Context about when to use (so agents can invoke autonomously)
• Best practices and examples (similar to Anthropic’s Skills feature)
• Tool orchestration patterns (how to use tools in the right sequence)

Example Comparison

Current Prompt (User-Only):

{
  "name": "find-housing-assistance",
  "description": "Find housing programs",
  "arguments": [
    {"name": "zipCode", "required": true},
    {"name": "householdSize", "required": true}
  ]
}

Proposed Skill (Agent-Discoverable):

{
  "name": "find-housing-assistance",
  "description": "Helps users find eligible housing assistance programs",
  "invocableBy": "agent",  // NEW: Agent can call this automatically
  "triggerPatterns": [     // NEW: When to use this skill
    "user asks about housing",
    "user mentions eviction or homelessness",
    "user needs rental assistance"
  ],
  "workflow": {            // NEW: Multi-step instructions
    "steps": [
      "Use get_location tool if zip code not provided",
      "Call search_housing_programs with filters",
      "For each program, check eligibility using verify_eligibility tool",
      "Format results with program names, eligibility status, and application deadlines"
    ]
  },
  "bestPractices": [       // NEW: Quality guidance
    "Always explain eligibility requirements clearly",
    "Provide next steps for application",
    "Mention application deadlines prominently"
  ]
}

Benefits

1. Autonomous Agent Behavior

Agents can proactively use skills when they detect relevant user needs, rather than waiting for manual prompt selection.

2. Reduced UI Complexity

• No need to expose 50+ prompt buttons/slash commands per server
• Users can speak naturally instead of learning prompt catalogs
• Better for non-technical end users (government residents, not developers)

3. Better Tool Orchestration

Skills encode the correct sequence of tool calls, preventing agents from:

• Calling tools in the wrong order
• Missing critical steps
• Making redundant API calls

4. Enterprise Governance

• Skills can include approval requirements for sensitive operations
• Can specify required context or prerequisites
• Better audit trail of why an action was taken

5. Backward Compatible

Skills could support a userControlled: true flag to preserve prompt-like behavior where needed.

Real-World Use Case: Government AI Assistant Platform

We’re building a multi-tenant platform where agencies create AI assistants for residents. Each agency might have 10+ MCP servers (housing, healthcare, benefits, permits, etc.), each with 5-10 prompts.

Current Problem:

• 50-100 prompts per agent = overwhelming UI
• Residents must know which prompt to click
• Breaks natural conversation flow

With Skills:

Resident: "I'm being evicted, can you help?"
Agent: [Detects housing crisis]
       [Invokes housing-assistance skill automatically]
       [Uses find-emergency-housing tool]
       [Checks eligibility]
       [Returns personalized results]

No button clicks, no slash commands, just natural conversation.

Implementation Considerations

Migration Path

1. Keep prompts for backward compatibility
2. Add new skills capability
3. Skills take precedence when both exist
4. Deprecate prompts in future version

Security

• Skills with invocableBy: "agent" should support approval policies
• Platform can require human-in-the-loop for sensitive skills
• Audit logging for all autonomous skill invocations

Discovery

Skills use same list and get pattern as prompts:

• skills/list - Returns available skills
• skills/get - Returns skill definition
• skills/invoke - Executes skill (new)

Alternative Considered

“Just use Tools” - Why not encode workflows as tools?

• Tools are atomic actions (send email, query database)
• Skills are strategies for combining tools
• Skills provide the “how” and “when”, tools provide the “what”
• Skills bridge the gap between user intent and tool execution

Conclusion

MCP prompts were a good first step for standardizing interactions, but they’re fundamentally limited by being user-controlled templates. As we move toward more autonomous agents in enterprise settings, we need a pattern that enables:

• Agent-driven workflow execution
• Complex multi-tool orchestration
• Best practice encoding
• Natural conversation flows

Skills represent the evolution from “templates users click” to “strategies agents employ.”

---

Related Work:

• Anthropic’s Skills feature (.claude/skills/)
• LangGraph’s workflow patterns
• OpenAI’s GPTs with custom instructions

Team: State Government AI Assistant Platform
Priority: High - blocking enterprise deployments
Timeline: Needed before we can roll out to 20+ agencies

[maxious]

Given #322 on server side tool search was just closed, exposing skills as they are currently implemented for anthropic models would allow consistency for client side search.

[rsxdalv]

I encounter this a lot where I could encode it all as 'tools' but it isn't working out as well. Like I could make a tool that returns a 20 page document for 'skill' background, but the importance is of selectively getting a skill/instruction, and many MCPs are just not sufficient to guarantee a model's success (especially looking at you gpt-pick-the-first-tool-and-yolo-mini-5

[dougrday]

I think the simplicity of the existing prompts standard is powerful, and more extensible. Going with skills patterns is too opinionated, and could easily change as experiments run and we find what does and doesn't work. i.e. skill discovery is like tool discovery, non-deterministic and not guaranteed to be used when desired; whereas agents like Claude Code can simply discover prompts and expose them as slash / commands. At that point, the invocation is intentional and escapes the problems of non-deterministic LLMs that decide when a skill is (or is not) invoked.

That said, I wouldn't be opposed to adding an experimental 'skills' section to the standard. Just don't try to replace the existing prompts standard.