How Skillry Protects Creator Skills
By Skillry Editorial · Updated October 28, 2026
A Skillry Skill is valuable because it encodes a creator’s expertise: the prompt chain, the quality checks, the tool calls, and the exact way a deliverable is assembled. If that bundle ships to the client, it can be copied, repackaged, or resold. That is why Skillry runs every real Skill on the server and exposes only a thin client to the user.
This page explains the architecture, the request flow, and the model fleet that powers the work.
How this article was made. This guide was drafted with AI assistance and edited by Skillry Editorial. Model descriptions and facts are drawn from the Skillry model catalogue, last updated October 28, 2026.
Why server-side skills matter
Most AI marketplaces treat a Skill as a prompt file the user downloads and runs locally. That model has three problems:
- IP leaks. The prompt, the tool chain, and the verification logic are visible to anyone who installs the Skill.
- Key sprawl. The creator’s API keys, model credentials, and third-party tokens have to be shared with every user.
- Inconsistent output. A Skill that depends on a local model, a local browser, or a local file system behaves differently on every machine.
Skillry solves this by keeping the Skill in a secure runtime. The user sends inputs; the server runs the Skill; the user receives only the finished asset or result. The Skill itself never reaches the client.
Architecture overview
The diagram above shows the whole path: a thin client talks to an API gateway, the gateway hands off to a sandboxed Skill runtime, the runtime loads the real Skill and routes to the right models, and the final asset is stored and delivered through a signed CDN URL.
Thin client
The Skillry client is intentionally thin. It collects user inputs, shows previews, and renders results. It does not:
- store the Skill source,
- hold model API keys,
- run the model locally, or
- expose the prompt chain.
That means a Skill can work on any device with a browser, and creators do not have to trust end users with their intellectual property.
API gateway
Every request passes through an API gateway that handles authentication, rate limiting, and routing. Rate limits are per user and per Skill, which makes large-scale extraction attempts expensive and obvious.
Skill runtime
The Skill runtime is the heart of the system. When a request arrives, the runtime:
- loads the encrypted Skill package from secure storage,
- validates inputs against the Skill’s schema,
- fetches any required secrets from the vault,
- executes the Skill inside a sandbox,
- routes model calls through the model router, and
- applies post-processing, verification, and safety filters before returning anything.
The Skill package contains SKILL.md instructions, tool definitions, quality checks, and metadata. It is never sent to the client.
Secret vault
API keys for OpenAI, Anthropic, Moonshot, ByteDance, Kuaishou, Alibaba, MiniMax, and every other provider live in a secret vault. Only the Skill runtime can read them, and only for the specific call it is making. Creators do not share keys with users; users do not need their own subscriptions.
Model router
Not every Skill needs the same model. A coding Skill might need long-context reasoning; a video Skill needs a video generation model; a front-end Skill needs strong layout taste. The model router picks the right engine for the job, falls back gracefully if a provider is slow, and keeps costs predictable.
Asset store and CDN
Generated images, videos, code archives, decks, and landing pages are stored in an asset store and served through a CDN with signed, time-limited URLs. The client receives only the finished deliverable, not the intermediate prompts, model outputs, or tool logs.
Call flow: one request end to end
- Request. The thin client sends the user’s inputs, file references, and Skill selection to Skillry.
- Validate. The API gateway checks authentication, quotas, and rate limits.
- Load Skill. The runtime loads the encrypted Skill package and input schema.
- Route model. The router selects the agentic LLM, image model, or video model the Skill calls for.
- Generate. The chosen model runs inside Skillry’s provider account, using Skillry’s keys.
- Post-process. The runtime verifies output quality, runs safety filters, and applies any watermark or attribution.
- Store asset. Images, videos, code, decks, or pages are written to the asset store.
- Sign URL. A signed CDN link is generated for media and large deliverables.
- Return. The runtime sends the result summary and asset URL back to the client.
- Render. The client displays the result. The Skill source never left the server.
Models behind the skills
The footer model list is the fleet the Skillry catalogue is written against. A Skill is just a folder of instructions; the model is what turns those instructions into work.
Agentic LLMs
These models handle reasoning, planning, coding, writing, and long-horizon tasks.
| Model | Maker | Context | Best at |
|---|---|---|---|
| Opus 5.5 | Anthropic | 1M tokens | Agentic coding and long tasks |
| GPT-6 Astra | OpenAI | ≈1M tokens | End-to-end agentic work |
| Fable 5.1 | Anthropic | 1M tokens | Demanding reasoning |
| Opus 5 | Anthropic | 1M tokens | Complex coding and enterprise work |
| Kimi K3 | Moonshot AI | 1M tokens | Front-end web development |
| Grok 4.6 | xAI | 500K tokens | Interactive and visual builds |
| GLM 5.3 Flash | Z.ai | 1M tokens | Fast, low-cost coding |
| DeepSeek V4.1 Flash | DeepSeek | 552B / 8B–16B active | Cheap batch runs |
| Qwen 3.8 Max | Alibaba | — | 3D, games, and front-end |
Image and video models
These models produce the visual assets that creative Skills deliver.
| Model | Maker | Output | Best at |
|---|---|---|---|
| Seedance 2.5 | ByteDance | 30s, extendable, native audio | One-take storytelling |
| Seedance 2.0 | ByteDance | 15s multi-shot | Multimodal reference |
| Kling 4.0 | Kuaishou | 30s, 4K / 1080p HDR | Production-grade footage |
| Wan 3.0 | Alibaba | 30s at 30fps | Documents and web pages to video |
| MiniMax H3 | MiniMax | 4–15s, 2K regenerate | Open weights, native stereo |
A Skill declares which model families it supports. The runtime chooses the actual model based on availability, cost, and the user’s plan.
Protection layers
Beyond the architecture, Skillry uses several guardrails to protect creators:
- Encrypted skill storage. Skill packages are encrypted at rest and decrypted only inside the runtime.
- Sandboxed execution. Each Skill runs in an isolated environment with no access to other Skills or user data.
- No source shipping. SKILL.md, prompt chains, and tool definitions never travel to the client.
- Key isolation. Provider keys are held in a vault and injected per call.
- Output attribution. Generated media can carry invisible or visible attribution back to the Skill and the creator.
- Audit logging. Every request, model call, and error is logged for debugging and abuse detection.
- Rate and spend limits. Per-user quotas prevent scraping and unexpected bills.
Frequently asked questions
Why not let users run Skills locally? Local execution exposes the Skill source and forces creators to share API keys. Server-side execution keeps the IP safe and the output consistent.
Does the client ever see the prompt? No. The client sees only the input form and the final result. The prompt chain, model logs, and intermediate artifacts stay on the server.
Which models can a Skill use? A Skill can target any model in the Skillry fleet, including the agentic LLMs and the image/video models listed above. The creator declares supported models; the runtime picks the best available option.
What happens if a model provider is down? The model router can fall back to an equivalent model in the same family when one provider is slow or unavailable.
How do creators publish a Skill? Creators upload a Skill package through the publish flow. The package is reviewed, encrypted, and deployed to the runtime. The creator keeps ownership and earns each time the Skill runs.
Start building protected Skills
Server-side execution lets creators ship real expertise without giving it away. If you have a workflow that produces decks, pages, images, videos, or code, you can turn it into a Skill and keep the source safely on Skillry.
About this guide
This article was written by Skillry Editorial. It explains how Skillry runs Skills on secure servers, protects creator intellectual property, and routes work to the agentic and media models listed in the Skillry footer. Model facts are drawn from the Skillry model catalogue and updated as new models are added.
