How RunningHub Turned 170+ APIs into One OpenClaw Skill (And Why You Should Too)
Most people think of OpenClaw skills as simple instruction files. Write some markdown, maybe add a script, publish it on ClawHub. Useful, but small.
RunningHub did something different. They took their entire media generation platform β 170+ API endpoints covering image generation, video creation, audio synthesis, 3D modeling, and multimodal text understanding β and packaged it into a single OpenClaw skill.
One skill. One install command. And suddenly, any OpenClaw agent can generate Midjourney-style images, create videos from text prompts, clone voices, and build 3D models β all through natural language conversation.
This isn't just a cool technical achievement. It's a business model worth studying.
What RunningHub Actually Built
Let's break down the numbers:
| Category | Endpoints | What It Does |
|---|---|---|
| Image | 42 | Text-to-image, image-to-image, upscaling, Midjourney-style generation |
| Video | 94 | Text-to-video, image-to-video, video editing, motion control, frame interpolation |
| Audio | 8 | Text-to-speech, music generation, voice cloning |
| 3D | 12 | Text-to-3D, image-to-3D, multi-image-to-3D |
| Text | 14 | Image understanding, video understanding, text processing |
That's 170+ specialized API endpoints, each with its own parameters, model options, and output formats. Without the skill, using RunningHub's API means reading documentation, writing API calls, handling authentication, managing async job polling, and downloading results. Doable, but tedious.
With the skill installed, the interaction looks like this:
You: "Draw me a puppy playing in a park"
Agent: automatically selects the best image generation endpoint, sends the request, polls for completion, downloads the result, and shows you the image
Or:
You: "Turn this photo into a video"
Agent: presents 8 video model options, lets you pick one, handles the entire generation pipeline
The agent doesn't need to know which of the 170+ endpoints to call. The skill handles routing automatically.
The Architecture: How It Works
The skill's file structure is clean:
runninghub/
βββ SKILL.md # Routing table + interaction rules
βββ scripts/
β βββ runninghub.py # Universal API client
β βββ build_capabilities.py # Generates capabilities.json from registry
βββ data/
βββ capabilities.json # Complete endpoint catalog (auto-generated)
Three key components make this work:
1. capabilities.json β The Endpoint Catalog
This is an auto-generated JSON file that describes every available API endpoint: what it does, what parameters it accepts, what it outputs, and what task categories it belongs to. Think of it as a machine-readable menu.
When RunningHub adds new endpoints to their platform, they regenerate this file:
python3 scripts/build_capabilities.py \
--registry /path/to/models_registry.json \
--output data/capabilities.json
One command, and the skill knows about every new capability. No manual SKILL.md editing required.
2. SKILL.md β The Routing Brain
The SKILL.md file doesn't list 170 endpoints. Instead, it defines routing rules: "If the user wants to generate an image, look up image endpoints in capabilities.json and pick the best match. If the user wants video, present the top 8 models and let them choose."
This is the clever part. The SKILL.md teaches the agent how to think about the API, not how to call every endpoint. The agent reads the routing rules, consults capabilities.json, and makes intelligent decisions about which endpoint to use.
3. runninghub.py β The Universal Client
A single Python script handles all 170+ endpoints. It supports multiple modes:
# Check API key and balance
python3 runninghub.py --check
# List available endpoints
python3 runninghub.py --list --type image
# Get details on a specific endpoint
python3 runninghub.py --info endpoint_name
# Execute with auto-routing (skill picks the best endpoint)
python3 runninghub.py --task "text-to-image" --prompt "a sunset over mountains" -o /tmp/output.jpg
# Execute with a specific endpoint
python3 runninghub.py --endpoint specific_model --prompt "..." -o /tmp/output.jpg
One script, multiple modes, all endpoints. The agent calls the same script regardless of whether it's generating an image or cloning a voice.
Why This Is a Genius Business Model
Here's where it gets interesting from a money perspective.
The skill is free on ClawHub. Anyone can install it. Zero cost, zero friction.
But every API call costs credits. Users need a RunningHub account with balance to actually generate anything. The skill is the distribution channel; the API usage is the revenue.
Think about what this means:
- Zero customer acquisition cost β ClawHub handles discovery and distribution
- Try-before-you-buy built in β users install the skill, see how easy it is, then add credits
- Recurring revenue β every image, video, or audio generation burns credits
- Network effects β happy users share the skill, bringing more users to RunningHub's API
- Lock-in through convenience β once your agent knows how to use RunningHub, switching to a competitor means installing a different skill and learning new workflows
This is the API-as-a-service model, but with AI agent distribution instead of traditional developer marketing. RunningHub doesn't need to convince developers to read their API docs. They just need OpenClaw users to say "draw me a picture."
What You Can Learn From This
You don't need 170 endpoints to replicate this model. The pattern works at any scale.
If you have an API or SaaS product:
Your existing API is already the hard part. Packaging it as an OpenClaw skill is the easy part β and it opens up an entirely new distribution channel.
If you're a developer looking for a business model:
Find an API that doesn't have an OpenClaw skill yet. Build the skill, negotiate a revenue share or affiliate deal with the API provider, and publish it on ClawHub. You become the bridge between the API and the OpenClaw ecosystem.
If you're building a new product:
Consider building the OpenClaw skill first, before the web UI. Your earliest users might be OpenClaw agents, not humans clicking buttons.
Build Your Own Version: A Step-by-Step Mini Guide
Let's say you have a small API β maybe 5 endpoints for image processing (resize, crop, filter, watermark, compress). Here's how to package it as an OpenClaw skill.
Step 1: Create the skill directory
mkdir -p my-image-skill/scripts my-image-skill/data
Step 2: Write the API client
Create scripts/image_api.py:
import argparse
import requests
import json
API_BASE = "https://your-api.com/v1"
def call_endpoint(endpoint, params, api_key, output_path):
headers = {"Authorization": f"Bearer {api_key}"}
response = requests.post(
f"{API_BASE}/{endpoint}",
json=params,
headers=headers
)
response.raise_for_status()
result = response.json()
# Download the result image
if "url" in result:
img = requests.get(result["url"])
with open(output_path, "wb") as f:
f.write(img.content)
print(f"Saved to {output_path}")
return result
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--endpoint", required=True)
parser.add_argument("--params", type=json.loads, default={})
parser.add_argument("--api-key", required=True)
parser.add_argument("-o", "--output", default="/tmp/output.jpg")
args = parser.parse_args()
call_endpoint(args.endpoint, args.params, args.api_key, args.output)
Step 3: Define capabilities
Create data/capabilities.json:
{
"endpoints": [
{
"name": "resize",
"task": "image-resize",
"description": "Resize an image to specified dimensions",
"params": ["input_url", "width", "height", "maintain_aspect"]
},
{
"name": "crop",
"task": "image-crop",
"description": "Crop an image to a specific region",
"params": ["input_url", "x", "y", "width", "height"]
},
{
"name": "filter",
"task": "image-filter",
"description": "Apply visual filters (blur, sharpen, grayscale, sepia)",
"params": ["input_url", "filter_type", "intensity"]
},
{
"name": "watermark",
"task": "image-watermark",
"description": "Add text or image watermark",
"params": ["input_url", "watermark_text", "position", "opacity"]
},
{
"name": "compress",
"task": "image-compress",
"description": "Compress image to reduce file size",
"params": ["input_url", "quality", "format"]
}
]
}
Step 4: Write the SKILL.md
# Image Processing Skill
## Trigger
When the user asks to resize, crop, filter, watermark, or compress an image.
## How to Route
1. Read `data/capabilities.json` to find the matching endpoint
2. Ask the user for any missing required parameters
3. Execute via: `python3 scripts/image_api.py --endpoint {name} --params '{...}' --api-key $IMAGE_API_KEY -o /tmp/result.jpg`
4. Show the result to the user
## Examples
- "Resize this image to 800x600" β endpoint: resize
- "Make this photo grayscale" β endpoint: filter, filter_type: grayscale
- "Add a watermark saying 'Draft'" β endpoint: watermark
Step 5: Publish to ClawHub
cd my-image-skill
clawhub publish
That's it. Five endpoints, one skill, and you've just created a distribution channel for your API inside the OpenClaw ecosystem.
The Bigger Picture
RunningHub's approach reveals something important about where the AI agent economy is heading. The value isn't just in building agents β it's in building the infrastructure that agents use.
Every API, every SaaS tool, every data source that doesn't have an OpenClaw skill is a gap in the ecosystem. And gaps are opportunities.
You don't need to build the next RunningHub. Start with 5 endpoints. Start with a wrapper around someone else's API (with permission). Start with a skill that solves one specific problem really well.
The OpenClaw skill marketplace is where the Shopify App Store was in its early days. The developers who build now β while the ecosystem is still young and the competition is thin β will have the strongest positions when it matures.
RunningHub figured this out early. The question is: what are you going to build?