AGENT SKILLS

Teach agents expert workflows

Import from catalogs, AI-generate from text, or upload manually. Portable skill packages following the agentskills.io spec.

Get Started
Agent Skills catalog showing skills from Anthropic, OpenAI, and Skills.sh sources

Agent Skills catalog — browse and import skills from Anthropic, OpenAI, and Skills.sh

HOW IT WORKS

From intent to expert agent in minutes

Three Ways to Create

Import skills from the Anthropic catalog or skills.sh community registry. AI-generate a skill from a natural language description. Or upload a SKILL.md file directly. Every skill follows the agentskills.io open spec.

Playground with agent chat, tools list, and skills loaded

Progressive Loading

Level 1: skill metadata loads at startup — just 50 tokens. Level 2: the full SKILL.md loads when relevant — up to 5K tokens. Level 3: additional files and scripts load on demand. This keeps agent context windows lean while having deep knowledge available when needed.

Level 1
Metadata~50 tokens
Level 2
Full SKILL.md~5K tokens
Level 3
Scripts & ResourcesOn demand

AI Skill Generation

Describe what you want in plain English. The Deep Agent generates a complete SKILL.md with metadata, instructions, workflow steps, and tool references. Streamed via SSE so you see progress in real time.

mcpgateway-sdk
from mcpgateway_sdk import MCPGateway
 
gw = MCPGateway()
 
# AI-generate a skill from plain English
skill = await gw.skills.create(
name="security-pr-reviewer",
skill_md_content="Review PRs for security vulnerabilities"
)
 
print(skill.name) # security-pr-reviewer
print(skill.description)
Deep Agent generates a complete SKILL.md

Install on Sandboxes

Skills are portable ZIP packages containing a SKILL.md plus optional scripts and resources. Install them directly into sandboxes where agents can reference the instructions and execute the bundled scripts.

mcpgateway-sdk
# Install skills into a sandbox
result = await gw.sandboxes.install_skills(
sandbox_id="my-sandbox",
skill_ids=["abc123", "def456"]
)
 
print(result)
# {"installed": ["security-pr-reviewer", "data-analyzer"]}
Portable .skill packages (ZIP)

SDK ACCESS

Skills that call tools programmatically

Skills can use mcpgateway-sdk to call MCP tools, search tools, and cache data. The gateway injects a scoped token at runtime — script authors write zero authentication code.

Call any MCP tool from Python

The gateway SDK gives scripts full access to the tool graph. Call tools by name, search semantically, cache results for follow-up questions. The gateway injects a scoped token at runtime — no API keys in your code.

mcpgateway-sdk
from mcpgateway_sdk import MCPGateway
gw = MCPGateway() # auto-auth from injected token
 
# Call any MCP tool — gateway handles credentials
opps = await gw.tools.execute(
"salesforce_opportunities_list",
{"quarter": "Q1-2026"}
)
 
# Search tools semantically
tools = await gw.tools.search("pipeline deals")
 
# Cache for follow-up questions
await gw.cache.set("accounts", data, ttl=600)
pip install mcpgateway-sdk · 81 methods · 6 resources

From 51 tool calls to 1

Without SDK access, an agent calling raw tools gets 200KB responses per call. With a skill script using the SDK, the same workflow returns 800 bytes. The agent sees a normal tool — zero awareness that scripts are involved.

mcpgateway-sdkagent_call.py
# Agent calls the script tool (same interface)
result = await gw.tools.execute(
"summarize_pipeline",
{"quarter": "Q1-2026"}
)
 
# Response: compact joined result (800 bytes)
{"quarter": "Q1-2026",
"total_deals": 12,
"total_pipeline_value": 2340000,
"deals": [{ "name": "Acme Corp", ...}, ...]
}
800 bytes · 51 calls collapsed into 1 · Cached for follow-ups
Read the SDK access docs

SCRIPT TOOLS

Declare tools the gateway enforces

Script tools are MCP Gateway's proposal to solve the token bloat problem. Package Python scripts in a tools/ folder with a workflow.json manifest. When attached to a server, the gateway registers them as first-class MCP tools — with schema validation, response budgets, scoped tokens, and exposure mode control.

Skill packages with script tools

A skill package contains SKILL.md guidance, a workflow.json manifest declaring tool schemas, and Python scripts in tools/. When attached to a server, the gateway registers each script as an MCP tool — the agent never sees the raw APIs behind them.

salesforce-workflows.skill
Runs in sandbox

Skill Package

▼ salesforce-workflows/

SKILL.md

workflow.json

▼ tools/

summarize_pipeline.py

Gateway registers tools/ as MCP tools on attach

tools/summarize_pipeline.py

from mcpgateway_sdk import MCPGateway
gw = MCPGateway() # auto-auth from env

# 1. Fetch opportunities via SDK
opps = await gw.tools.execute(
    "salesforce_opportunities_list",
    {"quarter": "Q1-2026"}
)

# 2. Filter and join
return {"total_deals": len(opps), ...} # 800 bytes
● Script runs in Docker/K8s sandbox·SDK auto-injects scoped token·Agent receives 800 bytes, not 1.2 MB

From prototype to production

Agent-Mediated

scripts/ folder

Agent reads SKILL.md, decides when to run. Wildcard SDK token scope. No schema validation. Best for prototyping.

  • Agent reads SKILL.md, decides when to run
  • Wildcard SDK token scope
  • No schema validation
  • Best for: prototyping

Gateway-Enforced

tools/ + workflow.json

Gateway dispatches on tool call. Scoped token, schema validation, response budgets. Best for production.

  • Gateway dispatches on tool call
  • Scoped token (allowed_tools only)
  • Schema validation + response budgets
  • Best for: production

Upgrade path: Start with scripts/ to iterate quickly. Move to tools/ when ready for production guardrails. Both live in the same skill package.

Read the script tools docs

SDK REFERENCE

Python SDK

Import, generate, manage, and distribute skills programmatically.

mcpgateway-sdk
# Browse the Anthropic skill catalog
catalog = await gw.skills.catalog("anthropics")
 
for entry in catalog:
print(entry.name, entry.version)
 
# github-pr-reviewer 1.2.0
# data-pipeline 1.0.3
# ... (24 total)
Anthropic + skills.sh catalogs
mcpgateway-sdk
# Import a skill from a catalog
skill = await gw.skills.import_from_catalog(
"anthropics",
"github-pr-reviewer"
)
 
print(skill.id) # abc123...
print(skill.source_type) # imported
One-line catalog import
mcpgateway-sdk
# Generate a skill from natural language
skill = await gw.skills.create(
name="data-analyzer",
skill_md_content="Analyze CSV data and produce charts"
)
 
print(skill.name, skill.source_type)
# data-analyzer created
Streamed via Server-Sent Events
mcpgateway-sdk
# Download a skill as a portable package
pkg = await gw.skills.download_package(skill.id)
 
# Save the .skill file locally
with open("pr-reviewer.skill", "wb") as f:
f.write(pkg)
 
# 4,096 bytes — SKILL.md + scripts/
Portable .skill ZIP package

Ready to teach your agents?

Import skills from the community or generate your own. Give every agent expert-level workflows.

Get Started