Bootstrap Tool: load_skills_protocol_guide
The load_skills_protocol_guide tool is a special bootstrap instruction that teaches LLM agents how to use the Skills Protocol.
Overview
The load_skills_protocol_guide tool returns the canonical Skills Protocol Guide—a comprehensive SKILL.md that instructs the LLM on how to discover, inspect, and execute skills.
Every Skills Runtime MUST include this tool and return consistent guide content.
Method definition
Overview
Load the canonical Skills Protocol Guide. This instruction tool teaches LLM agents how to use the remaining 7 tools.
Parameters
None. This method takes no parameters.
Response
Returns the content of the skills.protocol.guide skill's SKILL.md file.
Request
{
"jsonrpc": "2.0",
"id": "8",
"method": "load_skills_protocol_guide",
"params": {}
}
Response
{
"jsonrpc": "2.0",
"id": "8",
"result": {
"content": "# Skills Protocol Overview\n\nAvailable tools:\n\n1. list_skills — Enumerate available skills\n2. describe_skill — Retrieve skill manifest and documentation\n..."
}
}
When to call
Call on first use
LLM agents should call this tool before using any other Skills Protocol tools:
# First call when connecting to a Skills Runtime
guide = client.load_protocol_guide()
print(guide["content"])
# Then proceed to discover and execute skills
skills = client.list_skills()
Include in system prompt
The system prompt should instruct the LLM to load the guide first:
You are connected to a Skills Runtime using the Skills Protocol.
If you have not yet read the Skills Protocol Guide,
you MUST call the `load_skills_protocol_guide` tool before using
any other Skills Protocol tools.
After reading the guide, follow its workflow:
discover → inspect → run or write code → use blobs for large data.
Canonical skill
The guide is served from a built-in instruction skill. Every runtime MUST include:
skill.toml
name = "skills.protocol.guide"
version = "0.1.0"
description = "Intro to the Skills Protocol for LLMs."
kind = "instruction"
namespace = "skills.protocol"
tags = ["guide", "bootstrap"]
SKILL.md
The SKILL.md should cover:
- Overview — Brief intro to the Skills Protocol
- Available tools — List of all 8 tools
- Recommended workflow — How to discover, inspect, and execute
- Best practices — Tips on blob usage, error handling, etc.
Example minimal guide:
---
name: Skills Protocol Guide
short_description: How to use the Skills Protocol tools.
---
# Skills Protocol Overview
Available tools:
1. `list_skills` — Enumerate available skills
2. `describe_skill` — Retrieve skill manifest and documentation
3. `read_skill_file` — Read any file in a skill's directory
4. `execute_skill` — Run a skill's entrypoint
5. `run_code` — Execute LLM-written code with mounted skills
6. `create_blob` — Store large content
7. `read_blob` — Retrieve blob previews
8. `load_skills_protocol_guide` — Bootstrap instruction tool (this guide)
## Recommended Workflow
1. **Discover skills**: Use `list_skills` to see what's available
2. **Inspect documentation**: Use `describe_skill` and `read_skill_file`
3. **Run simple actions**: Use `execute_skill` for single-skill operations
4. **Write multi-step workflows**: Use `run_code` to compose multiple skills
5. **Use blobs for large data**: Store and retrieve large content via `create_blob` and `read_blob`
## Best Practices
- Always use blobs for data larger than a few KB
- Keep `output` fields small; write large results to blobs
- Read skill documentation before executing
- Use deterministic skill discovery (no semantic search in `list_skills`)
System prompt integration
Include guidance in the LLM system prompt:
You are connected to a Skills Runtime using the Skills Protocol.
If you have not yet read the Skills Protocol Guide,
you MUST call the `load_skills_protocol_guide` tool before using
any other Skills Protocol tools.
After reading the guide, follow its workflow:
discover → inspect → run or write code → use blobs for large data.
Example system prompt integration
# Agent Instructions
You are a helpful assistant with access to a Skills Runtime.
You can discover and execute skills to help users accomplish tasks.
## Protocol
1. On startup, call `load_skills_protocol_guide` to learn the protocol
2. Use `list_skills` to discover available capabilities
3. Use `describe_skill` and `read_skill_file` to understand skill details
4. Use `execute_skill` to run skills or `run_code` for custom workflows
5. Use `create_blob` and `read_blob` for large data
Always follow the workflow recommended in the protocol guide.
Implementation notes
Consistency
All runtimes MUST return identical guide content for the canonical skills.protocol.guide skill. This ensures consistent LLM understanding of the protocol.
Customization
While the core guide should be consistent, runtimes MAY include additional implementation-specific information (e.g., available namespaces, permission requirements).
Updates
When the Skills Protocol version updates, runtimes MUST update their guide content accordingly to match the new specification.