load_skill: MCP Playbooks for SEO and Documents

For developers and power users integrating ToolYour into their applications, moving beyond one-off solve_task calls to repeatable, structured workflows is a significant step towards automation. This article explores how to leverage MCP load_skill on ToolYour to execute pre-defined agent playbooks for common tasks like SEO site audits and document processing pipelines. By understanding and implementing load_skill, you can achieve consistent, efficient, and robust results, streamlining your agent-based operations.

ToolYour provides a comprehensive tools platform for humans, applications, and agents, offering a unified catalog, a single API key, and one plan across browser, REST API, and Model Context Protocol (MCP) surfaces. While solve_task serves as a versatile primary agent tool for handling diverse goals in its early phase, load_skill offers a more direct and reliable path for executing predefined, multi-step operations. This guide focuses on integrating these powerful MCP load_skill capabilities into your development workflows.

What MCP skills are on ToolYour

MCP skills on ToolYour represent pre-engineered, repeatable workflows, or "playbooks," designed to accomplish specific, complex tasks by orchestrating multiple ToolYour API-backed tools. These skills encapsulate best practices and sequences of operations, making advanced functionalities accessible with a single load_skill call. ToolYour acts as a remote MCP server, enabling AI agents like Cursor and Claude Desktop to tap into this rich ecosystem of over 200 tools.

These skills are not merely single tool calls; they are intelligent sequences. For example, a full-seo-audit skill might internally invoke a site crawler, a page speed analyzer, and a keyword checker, then aggregate the results. Similarly, a document-convert-pipeline could handle file uploads, conversions (e.g., DOCX to PDF), and then text analysis.

Here are some examples of the job workflows or "skills" available:

• full-seo-audit
• core-web-vitals-job
• full-seo-optimization-job
• internal-link-architecture-job
• technical-seo-audit-job
• social-preview-audit-job
• content-quality-audit-job
• keyword-opportunity-review-job
• document-convert-pipeline

It's important to note that ToolYour's MCP exposes only API-backed tools, ensuring that integrations are robust and programmatic. Browser-only tools, while useful on the ToolYour website, are not available via MCP.

Using these skills, like running any tool through MCP, counts towards your monthly quota. The free plan includes 500 successful requests per month, shared across REST API and MCP usage, with a throughput limit of 5 successful requests per minute. This quota resets on the 1st of each calendar month. Browsing the MCP catalog or receiving status: suggest responses from solve_task does not consume quota; only successful tool executions do. Multiple API keys on one account share this same monthly allowance. You can manage your API keys and monitor usage from your dashboard at https://www.toolyour.com/dashboard/api-keys.

list_skills vs load_skill

Understanding the distinction between list_skills and load_skill is crucial for effective MCP load_skill implementation. Both are meta-tools within the ToolYour MCP ecosystem, but they serve different purposes in your workflow.

Discovering Available Skills with list_skills

The list_skills meta-tool allows you to programmatically discover the full range of pre-defined job workflows (skills) that ToolYour offers through MCP. This is particularly useful when you need to explore capabilities or dynamically select skills based on user input or application logic.

You can invoke list_skills directly using the invoke_tool meta-tool, or sometimes indirectly via solve_task if the goal is clear enough. For example, an agent might ask:

{
  "goal": "list available skills for SEO audits"
}

Or, using a more direct invoke_tool call:

{
  "tool_name": "list_skills",
  "inputs": {}
}

The response from list_skills provides a catalog of available skill names and potentially brief descriptions, helping you identify the exact skill needed for your task.

Executing Skills with load_skill

Once you've identified a specific skill, load_skill is the meta-tool used to execute that pre-defined workflow. Unlike solve_task, which aims to route general goals to the most appropriate tools or skills, load_skill provides explicit control over which skill to run. This makes it ideal for integrating known, repeatable processes into your applications.

For production-critical flows, ToolYour recommends preferring discover_tools → get_tool_schema → invoke_tool for precise tool control, especially since solve_task is still in an early phase of development where routing and tool coverage are continually improving. While solve_task can interpret a goal to execute a skill, load_skill provides direct invocation of a specific skill by name, offering greater reliability and predictability for predefined workflows.

To use load_skill, you typically provide the skill_name and any necessary inputs that the skill requires. Before invoking, you can query the schema of a specific skill using get_tool_schema with load_skill and the skill_name as parameters to understand its expected inputs and outputs. This ensures your integration provides the correct data format.

For full client setup and authentication details, which typically involve sending your X-Api-Key in the request header, refer to the ToolYour developers' guide for MCP at https://www.toolyour.com/developers/mcp. Your API key starts with ty_ and can be found on your dashboard.

SEO site audit skill workflow

User Goal: Automate a comprehensive SEO audit for a specified website URL, generating a detailed report of technical and content issues.

An SEO site audit is a complex task involving multiple steps: crawling, analyzing page speed, checking for broken links, evaluating content, and more. Rather than manually chaining individual tool calls (e.g., page_speed_analyzer, keyword_checker), you can leverage the full-seo-audit skill for a streamlined, repeatable process.

Here’s a step-by-step workflow for running an SEO site audit using MCP load_skill:

1. Discover the SEO Audit Skill:

   • You can initially use list_skills or browse the ToolYour MCP documentation to confirm the name of the SEO audit skill. You'll find it's typically named full-seo-audit.

2. Understand Skill Requirements (Schema):

   • Before executing, it's good practice to understand what inputs the full-seo-audit skill expects. You can achieve this by calling get_tool_schema on the load_skill meta-tool, specifying full-seo-audit as the target skill. This will reveal parameters such as target_url and crawl_depth.
   • Example invocation of get_tool_schema for the skill:

   {
     "tool_name": "get_tool_schema",
     "inputs": {
       "tool_name": "load_skill",
       "parameters": {
         "skill_name": "full-seo-audit"
       }
     }
   }
   

   This would return the schema, detailing the required inputs like:

   • target_url: The URL of the website to audit (e.g., https://yoursite.com/).
   • crawl_depth: How many levels deep the crawler should go (e.g., 2).

3. Execute the SEO Audit Skill:

   • With the skill name and input requirements understood, you can now call load_skill. While you can use invoke_tool with load_skill, for simplicity and often how agents interact, you might formulate this as a solve_task goal that maps to load_skill.
   • Example solve_task call to trigger load_skill:

   {
     "goal": "perform a full SEO audit",
     "tool_name": "load_skill",
     "inputs": {
       "skill_name": "full-seo-audit",
       "parameters": {
         "target_url": "https://yoursite.com/",
         "crawl_depth": 2
       }
     }
   }
   

   • Alternatively, a direct invoke_tool for load_skill:

   {
     "tool_name": "load_skill",
     "inputs": {
       "skill_name": "full-seo-audit",
       "parameters": {
         "target_url": "https://yoursite.com/",
         "crawl_depth": 2
       }
     }
   }
   

   Ensure your API key is included in the X-Api-Key header for authentication.

4. Monitor Progress and Retrieve Results:

   • A successful load_skill call will typically return a job ID. You can use this ID to query the status of the ongoing audit and retrieve the final results once completed. Complex audits can take time depending on the crawl_depth and site size.

What Success Looks Like: Upon completion, the full-seo-audit skill will provide a comprehensive report detailing various aspects of your site's SEO health. This might include identified issues related to:

• Page performance (e.g., from digital-tools/page-speed-analyzer)
• Broken links
• Duplicate content
• Missing meta descriptions
• Keyword opportunities (e.g., using digital-tools/keyword-checker insights)
• Technical crawlability problems

This structured report empowers you to prioritize and address critical SEO issues efficiently. For more in-depth information on how SEO audits can be conducted using ToolYour agents, you can refer to the related post: SEO Audit with MCP Agents on ToolYour.

Document pipeline skill workflow

User Goal: Automate the conversion and analysis of a batch of documents, such as converting multiple DOCX files to PDF and extracting key statistics.

The document-convert-pipeline skill simplifies complex document processing tasks that would otherwise require chaining multiple file conversion and analysis tools. This skill can handle various formats, allowing for efficient batch operations.

Here’s a step-by-step workflow for leveraging the document-convert-pipeline skill:

1. Discover the Document Pipeline Skill:

   • Confirm the skill name is document-convert-pipeline using list_skills or by checking the ToolYour MCP documentation.

2. Understand Skill Requirements (Schema):

   • Use get_tool_schema on load_skill for document-convert-pipeline to understand the expected inputs. This might reveal parameters such as document_urls (for documents hosted online), input_format, output_format, or even options for additional processing like extract_text_stats.
   • Example invocation of get_tool_schema for the skill:

   {
     "tool_name": "get_tool_schema",
     "inputs": {
       "tool_name": "load_skill",
       "parameters": {
         "skill_name": "document-convert-pipeline"
       }
     }
   }
   

   This would return the schema, detailing inputs like:

   • document_urls: An array of URLs pointing to the documents (e.g., https://example.com/report.docx, https://example.com/manual.pdf).
   • output_format: The desired output format for conversions (e.g., "pdf", "docx").
   • perform_text_analysis: A boolean to indicate if text statistics should be generated (e.g., true).

3. Execute the Document Pipeline Skill:

   • With the necessary inputs, call load_skill to initiate the document processing pipeline.
   • Example solve_task call to trigger load_skill:

   {
     "goal": "convert multiple documents and get text stats",
     "tool_name": "load_skill",
     "inputs": {
       "skill_name": "document-convert-pipeline",
       "parameters": {
         "document_urls": [
           "https://example.com/invoice.docx",
           "https://example.com/contract.pdf"
         ],
         "output_format": "pdf",
         "perform_text_analysis": true
       }
     }
   }
   

   • Or directly with invoke_tool:

   {
     "tool_name": "load_skill",
     "inputs": {
       "skill_name": "document-convert-pipeline",
       "parameters": {
         "document_urls": [
           "https://example.com/invoice.docx",
           "https://example.com/contract.pdf"
         ],
         "output_format": "pdf",
         "perform_text_analysis": true
       }
     }
   }
   

4. Monitor Progress and Retrieve Results:

   • The load_skill call will provide a job ID, allowing you to track the progress of the document pipeline. Once processing is complete, you can retrieve the converted files and any generated analyses.

What Success Looks Like: The document-convert-pipeline skill will return a collection of converted documents (e.g., invoice.pdf, contract.pdf) and, if requested, associated text statistics (e.g., word count, readability scores from digital-tools/text-stats) for each. This output is ready for download or further integration into your document management system. The skill might internally use tools like file-conversion/docx-to-pdf-converter or file-conversion/pdf-to-docx-converter.

When skills beat ad-hoc goals

While solve_task offers flexibility for a wide range of ad-hoc requests, MCP load_skill provides distinct advantages for specific use cases, particularly for developers aiming for robust, production-grade automation:

1. Repeatability and Consistency: Skills are pre-defined, ensuring that a complex workflow is executed consistently every time. This eliminates variability that can arise from solve_task's early phase routing, where the interpretation of a goal might subtly change.

2. Predictable Outcomes: When you use load_skill with a known skill_name, you have a higher degree of certainty about the sequence of operations that will occur and the expected output format. This is crucial for applications that rely on predictable data structures.

3. Efficiency and Reliability for Complex Tasks: For multi-step processes like a full SEO audit or document pipeline, skills abstract away the complexity of chaining multiple tool calls. ToolYour engineers have optimized these workflows, leading to more efficient execution and fewer points of failure compared to manually orchestrating a series of invoke_tool calls.

4. Production-Critical Workflows: As solve_task is still in an early phase, often returning a status: suggest when it's unsure about the best execution path, load_skill offers a more mature and direct approach for critical applications. For production-critical flows, ToolYour specifically recommends using discover_tools → get_tool_schema → invoke_tool or load_skill when a known workflow exists.

5. Simplified Development: Instead of figuring out how to combine several tools for a common problem, developers can simply call a pre-built skill, reducing development time and maintenance overhead. The MCP load_skill approach encapsulates expert knowledge directly into an executable playbook.

In summary, for tasks that are frequent, complex, and require consistent results, load_skill offers a superior approach, providing the predictability and reliability needed for professional integrations.

FAQ

Q: What is load_skill on ToolYour MCP? A: load_skill is a meta-tool within ToolYour's Model Context Protocol (MCP) that allows you to directly execute pre-defined, multi-step workflows, or "skills," by their specific names. These skills automate complex tasks like SEO audits or document processing pipelines.

Q: How does load_skill differ from solve_task? A: solve_task is ToolYour's primary agent tool for general, ad-hoc goals, attempting to infer the best tools or skills to achieve an objective. load_skill provides explicit control, allowing you to directly invoke a specific, named skill. Given solve_task is in an early phase and may often return status: suggest, load_skill offers a more predictable and robust method for executing known, repeatable workflows.

Q: Do MCP load_skill executions count against my quota? A: Yes, running a skill through load_skill consumes quota. ToolYour's free plan includes 500 successful requests per month, shared across both REST API and MCP usage, with a rate limit of 5 successful requests per minute. Browsing the MCP catalog or receiving suggestions does not use quota; only successful tool and skill executions do.

Q: Where can I find my ToolYour API key? A: You can find your API key, which starts with ty_, in your ToolYour dashboard at https://www.toolyour.com/dashboard/api-keys. This single API key authenticates both your REST API and MCP requests.

Q: Can I use load_skill with any AI agent? A: load_skill is designed for use with MCP-compatible AI agents, such as Cursor, Claude Desktop, and Claude Code. These clients are equipped to interact with ToolYour's remote MCP server at https://api.toolyour.com/mcp.

Q: What happens if I hit my free plan limits? A: If you exceed the 500 successful requests per month or 5 requests per minute throughput limit on the free plan, further requests will be blocked until your quota resets on the 1st of the next calendar month or until you upgrade your plan. Invalid requests generally do not count against your quota.

Q: Are all ToolYour tools available via load_skill or MCP? A: ToolYour's MCP, including skills invoked via load_skill, exposes only API-backed tools. Certain browser-only tools available on the ToolYour website are not accessible through the MCP API.

Conclusion

Leveraging MCP load_skill is a powerful way for developers to build efficient, repeatable, and robust workflows using ToolYour's extensive toolset. By moving beyond ad-hoc solve_task calls to explicitly defined skills, you gain predictability and control over complex operations, whether you're performing comprehensive SEO audits or automating document conversion pipelines. This structured approach ensures consistent results and streamlines your application's integration with ToolYour's capabilities.

To get started with implementing MCP load_skill in your applications, explore the comprehensive developer documentation for ToolYour's MCP:

• MCP Developer Guide: https://www.toolyour.com/developers/mcp
• API Key Management: https://www.toolyour.com/dashboard/api-keys
• Pricing and Plans: https://www.toolyour.com/pricing
• Sign Up for ToolYour: https://www.toolyour.com/signup