# inference.sh skills: agent skills for images, video, models and search

> The inference-sh skills repository is a set of agent skill packages that give a coding assistant access to hosted models through the inference.sh CLI, covering image generation, video generation, LLM calls, web search, and a Twitter API, plus SDK and UI components and a set of writing and design guides. It installs as a Claude Code plugin, with npx or a manual copy as alternatives.

**inference-sh/skills** — inference.sh Agent skills for using our API to give your agents access to hundreds of apps and other agents

- Repository: https://github.com/inference-sh/skills
- Stars: 776 · Forks: 106
- Language: Shell
- License: not declared
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/inference-sh-skills

## A skill is a directory of instructions

The inference-sh skills repository is a set of agent skills for models via the inference.sh CLI. The short version of what it does is in the README's first line: generate images, videos, call LLMs, search the web, and more. The repository description frames it as giving your agents access to hundreds of apps and other agents through their API.

The distribution format is what makes it worth reading. A skill here is a directory, and the repository is organised by kind: tools for the capabilities, sdk for the client libraries, ui for interface components, and guides for the written material. There is also a .claude-plugin directory, which is the plugin manifest, and a skills.sh.json file, which appears to be the manifest for the skills.sh installer.

The model is the one that has become common for agent tooling. Instead of a program with a callable API, a skill is a directory that an agent reads, containing the documentation, the commands, and the reference material it needs to use a particular capability correctly. The value of putting these in a repository rather than in a prompt is that they are versioned, reviewable, and installed the same way as a package.

What the repository is really a front end for is the inference.sh platform, which has a website, an app store, documentation, and a blog, and the documentation in this repository links into the platform docs for getting started, for running apps, for CLI setup, and for the API and SDK.

The repository is not archived, the last push was on 2026-10-15, there are no releases, and the licence is recorded as unknown even though the README carries an MIT badge, which is a small mismatch to check in the file itself before you rely on it.

## Three installation routes, and which one you want

There are three ways to install, and the choice depends on how the agent you use discovers skills.

The first is as a Claude Code plugin, and it is a single command.

```bash
/plugin install inference-sh
```

Or from GitHub, by adding the marketplace and then installing from it.

```bash
/plugin marketplace add inference-sh/skills
/plugin install inference-sh@inference-sh-skills
```

After that the skills are available as slash commands with a namespace, and the README gives two examples, an image skill and a video skill, invoked as a namespaced command.

The second route is the skills.sh installer, and it also takes a single command for the whole set.

```bash
npx skills add inference-sh/skills
```

Individual skills can be installed by naming them, which is the same command with a skill name appended.

```bash
npx skills add inference-sh/skills@flux-image
npx skills add inference-sh/skills@google-veo
npx skills add inference-sh/skills@llm-models
npx skills add inference-sh/skills@web-search
```

The third route is manual, and it is one copy command, because the four directories sit side by side in the repository.

```bash
cp -r tools/* ui/* sdk/* guides/* ~/.claude/skills/
```

The manual route is the one to pick if your agent does not understand either of the plugin formats, and it has the pleasant property of being obvious about what it does, since it copies four directories into the skills directory of the agent and nothing else.

The skills named in the install examples are also the fastest way to understand the naming scheme, because they are the internal names rather than the display names used in the tables later on.

## Everything runs through the belt command

Underneath the skills there is a command line tool, and the README is explicit that it is a requirement: these skills need the inference.sh CLI, called belt, and the install instructions for it live in a separate file in the repository.

Setup is a login.

```bash
belt login
```

And the way to see what is available is the app list command, `belt app list`.

That second command is the more interesting one, because it tells you the model of the platform. An app is something you run, and the apps are what the skills are wrappers around. The skills directory names give the shape: a tool skill for image generation, a tool skill for video generation, one for language models, one for web search, and one for Twitter automation.

The implication for a skill author is that the skill is a description of how to use a particular app, and the app is the thing that actually does the work. That is why the skills directory has one entry per capability rather than one entry per model, and why the model names appear in the descriptions rather than in the directory names: the FLUX and Gemini and Reve models are all reachable through the same image generation skill, and the Veo, Seedance, and Wan models through the same video skill.

It also means the dependency is not optional. A skill installed without the CLI and without a login is a set of instructions an agent will follow and fail at the first command, which is worth knowing before you install the whole set into an environment you have not tested.

## The tool skills, and how many models each one reaches

The tools table is the core of the repository, and the numbers in it are the interesting part.

The image generation skill covers more than fifty image models, with FLUX, Gemini, and Reve named as examples. The video generation skill covers more than forty video models, with Veo, Seedance, and Wan named. The language model skill lists Claude, Gemini, Kimi, and GLM. The web search skill lists Tavily and Exa search. And the Twitter automation skill covers the X and Twitter API.

The reason to bundle this way is that an agent choosing a model needs a single place that says what exists, rather than a dozen provider specific tools. One image skill that knows fifty models is a decision an agent can make once, and the skill is the document that tells it which model fits which job.

The count is also a maintenance statement. Keeping a list of fifty image models current is work, and it is work that has to happen every time a provider adds a model or retires one, which is why the repository has a last push date as recent as 2026-10-15 and no releases at all, since the skills are updated in place and pulled by the installer rather than versioned as a release train.

The two directories worth noting in the table are the ones where the tool skill is not the only thing in the directory. The image generation skill and the video generation skill have their own directories under tools, and the language model skill is listed with a path that also serves the web search skill, which suggests the two share a directory with different entry points.

## SDK skills, UI components, and the guides

The other three directories are for things an agent needs that are not a hosted model call.

The SDK skills are the client libraries. The JavaScript SDK skill covers a JavaScript and TypeScript SDK with streaming, tools, and React, and the Python SDK skill covers a Python SDK with async and streaming. The React mention in the JavaScript one is the detail that matters, because a streaming SDK and a React integration are different problems, and the skill that documents them together is aimed at an agent writing a front end that talks to the platform.

The UI components are three directories. The agent UI skill is a full agent interface, the chat UI skill is chat components, and the tools UI skill is for rendering tool calls and results. That last one is the piece an agent building an agent interface keeps needing, because a tool call is a data structure and rendering it well, with the arguments and the result, is a UI problem that every project otherwise solves badly.

The guides are seven categories of written material, and they read like a content production manual. The prompting guide covers prompt engineering and video prompts. The design guide covers landing pages, thumbnails, and logos. The video guide covers storyboards, explainers, and ads. The writing guide covers blogs, case studies, and newsletters. The social guide covers LinkedIn, Twitter threads, and carousels. The product guide covers competitor analysis, personas, and launches. And the agent guide covers agent self-regulation when stuck or looping.

That last one is the outlier and the most interesting. A guide about an agent that has noticed it is looping and needs to correct itself is not about content production at all, it is about the failure mode of the thing these skills are for, and it is the only one of the seven that is about the agent rather than about the output.

## What you are actually installing

It is worth being clear about what a user gets, because the name invites a different expectation.

You do not get a model. You get a directory of instructions that tells an agent how to use someone else's models through someone else's CLI, with a login to that service. The platform is inference.sh, and the skills are the client side of it. The documentation links in the repository point at the platform's getting started guide, its guide to running apps, its CLI setup guide, and its API and SDK overview.

That has consequences worth weighing before you install it broadly.

The first is that every skill that calls a model sends the prompt, and whatever else is in the request, to a hosted service. The skill for image generation sends a prompt, the skill for video generation sends more, and the skills for language models and web search send your text and your query. If what you send is sensitive, that decision belongs to you, and the skills are the place where it becomes visible.

The second is that the skills are only as current as the platform. The model lists, the CLI commands, and the app names are all moving targets, and the skills.sh.json manifest and the directory structure are what the installer relies on, so a rename upstream becomes a broken install until the skills are updated.

The third is the licence. The README carries an MIT badge and links to the MIT text, but the repository's licence field is recorded as unknown, and the repository also has a CONTRIBUTING.md and a TODO.md, which is the pattern of a project that is still defining its own rules. For a set of instructions you are going to paste into an agent, reading the terms is worth the minute it takes.

None of that makes the repository a bad idea. It is a well organised, thoughtfully scoped set of agent skills, and the fact that one skill is about agents regulating themselves when they get stuck tells you the author is thinking about the failure modes rather than only the happy path.

## Conclusion

inference.sh skills fits a team running an agent in Claude Code that needs to produce images or video, call hosted models, or search the web without building and hosting those models itself, and that is comfortable with the skills calling a third party service on their behalf. It does not fit a team that cannot send its prompts and assets to a hosted API, and it does not fit a workflow that needs the SDK and UI components in an application rather than in an agent session. Verify first that you have the inference.sh CLI installed and signed in, since every skill depends on the belt command, that the model identifiers you want are among the ones the skills cover, and that the platform handles the hosted model calls and the data that goes with them under your own policy.

## FAQ

### How do I install the inference.sh skills?

As a Claude Code plugin with the plugin install command, through the skills.sh installer with npx skills add inference-sh/skills, which also accepts a skill name for one skill, or manually by copying the tools, ui, sdk, and guides directories into the skills directory of your agent.

### What do the inference.sh skills do?

They give an agent access to hosted models through the inference.sh CLI: image generation with more than fifty models, video generation with more than forty, calls to Claude, Gemini, Kimi, and GLM, web search through Tavily and Exa, and the X and Twitter API.

### What does the inference.sh skills repository require?

The inference.sh CLI, called belt, and an account signed in through belt login. The README links to a separate install instructions file for the CLI, and the way to see the available apps is belt app list.

### What is in the SDK and UI sections of the inference.sh skills?

A JavaScript and TypeScript SDK skill with streaming, tools, and React, a Python SDK skill with async and streaming, and three UI skills: a full agent interface, chat components, and a renderer for tool calls and results.

### What guides ship with the inference.sh skills?

Seven categories: prompting for prompt engineering and video prompts, design for landing pages, thumbnails and logos, video for storyboards, explainers and ads, writing for blogs, case studies and newsletters, social for LinkedIn, Twitter threads and carousels, product for competitor analysis, personas and launches, and an agent guide about self-regulation when stuck or looping.

## Sources

- [inference-sh/skills on GitHub](https://github.com/inference-sh/skills)
- [Issues](https://github.com/inference-sh/skills/issues)
- [README](https://github.com/inference-sh/skills/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/inference-sh-skills