# neta-skills: agent skills for the Neta Art API

> neta-skills turns a hosted multimedia API into a set of installable agent skills plus a CLI, covering image, video and song generation, character and element management, taxonomy discovery, story campaigns and premium subscriptions. It is a client for someone else's models, and it is built around agents rather than around code.

**netaart/neta-skills** — Neta - Agent-first Creative Kit

- Repository: https://github.com/netaart/neta-skills
- Website: https://www.neta.art
- Stars: 665 · Forks: 10
- Language: TypeScript
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/netaart-neta-skills

## A client for someone else's models, packaged for agents

The repository describes itself as a collection of AI agent skills and CLI tools for interacting with the Neta Art API, and the description in the package manifest is blunter still, calling it an API coding agent skills package for generating images, videos and songs and for managing characters and elements. Two design choices follow from that framing. The first is that the intelligence is not here. There is no model in this repository, no inference code and no weights. What there is a documented HTTP API, a set of commands over it, and a set of skill files that teach an agent how and when to use those commands. The second is that the delivery mechanism is a skill rather than a library. The primary way to use the project, as the README says, is by installing the skills into your agent environment, and the tools are meant to plug into whatever agent framework you already run. That is a different contract from an SDK. An SDK gives you functions, and the function calls are your problem. A skill gives your agent the vocabulary, the argument shapes and the order of operations, which is why this project ships as a skills directory with a CLI beside it.

## One unified skill, or eight focused ones

The installation story is a single command, and the tool that runs it is a generic installer rather than something this project wrote.

```bash
npx skills add talesofai/neta-skills/skills/neta
```

That installs the unified neta skill, whose definition is the file skills/neta/SKILL.md. If your agent prefers more granular capabilities, the README lists the specialised skills and the same installer command for each, with a comment naming the domain of each one. There is a community exploration skill for hashtags, spaces and the interactive feed, a creative skill for image, video and song workflows together with the premium subscription flows, a suggest skill for keywords, tags, categories and content discovery, a space skill for space navigation, a character skill and an elementum skill for creating and managing those two kinds of token, and an adventure skill for AI driven interactive story campaigns. The repository has a skills directory with those eight, and the validation script in the package manifest lists exactly those eight paths, which is a useful detail because it tells you the granularity is a fixed set rather than a growing pile of loose files.

## A token in the environment, or a device flow on the global host

Authentication has two shapes and the choice depends on where your agent runs. The default is a token, NETA_TOKEN, which you get from the Neta Open Portal and place in the environment, and the repository ships an example environment file showing exactly that.

```bash
NETA_TOKEN=your_api_token_here

# Optional: API Base URL (default: https://api.talesofai.com)
# NETA_API_URL=https://api.talesofai.com

# Optional: disable CLI usage analytics (see README)
# DISABLE_TELEMETRY=1
```

The alternative is the CLI login command, which uses OAuth device authorization and, on the global API host at api.talesofai.com, stores the tokens locally on success instead of requiring the token in every environment. The command table spells out the two phases, request-code to start the flow and verify-code to complete it, and there is a matching logout that clears the stored session and any in progress device flow, plus a me command that reports the authenticated user's profile, AP balance and asset totals. Two details are worth flagging for a team. The device flow is only offered on the global host, so a deployment pointed at another API base URL falls back to the token. And the environment file documents a telemetry switch, DISABLE_TELEMETRY, which is the setting to reach for if the CLI runs somewhere you do not want usage analytics enabled.

## Forty-nine commands, grouped by the job they do

The command table is the substance of the project and it is worth reading as a map of the API. The user group is the smallest, with login, logout and me. The creation group is the one most people will use, with make_image from text prompts, make_video from images and prompts, make_song from prompts and lyrics, remove_background for images, edit_collection and publish_collection for collection metadata, search_character_or_elementum for reusable building blocks, upload for turning a local or remote file into a media artifact, list_my_artifacts for the generated assets, and the AP pair get_ap_info and get_ap_history, which report the balance breakdown and a paginated history of consumption and recharge. The VToken group covers characters and elementa, each with create, update and list commands, and creating one consumes credits. The community group is discovery oriented, with hashtag lookups, curated collections under a hashtag, list_spaces, list_space_topics, request_interactive_feed, a set of suggest commands for keywords, tags and categories, validate_tax_path for checking a taxonomy path, and suggest_content for searching or filtering. The adventure group covers creating, updating, listing and loading AI driven story campaigns. The naming is worth noticing, because it tells you what the API itself thinks it is doing, with commands grouped by domain rather than by HTTP verb.

## Credits, tiers and a Stripe checkout inside the CLI

The premium group of commands is the one that makes the economics explicit. get_current_premium_plan returns the signed-in user's tier and the subscription end when there is one, list_premium_plans lists the available plans with their SPU UUIDs, create_premium_order creates an order for a plan identified by that UUID, get_premium_order fetches the details of a single order, list_premium_orders lists them with pagination, and pay_premium_order starts payment for an unpaid order, for example through Stripe Checkout. The README notes that these premium commands are for the global API environment. Read together with the AP commands, the picture is of a metered service with a credit balance, a tiered subscription sold through the same interface, and a currency called AP, Action Points, which is what the character and elementum creation commands consume. The consequence for an agent is direct. A generation command is not free, and an agent that loops over a task without checking the balance will fail in the middle of the run, which is why the me command and get_ap_info exist as first class commands rather than afterthoughts.

## How the package is built, linted and validated

The repository is a pnpm workspace package with a conventional toolchain, and the scripts in the manifest show the whole workflow. The build is rimraf of the bin directory followed by tsc, with a postbuild step that runs a script from the scripts directory. Linting is Biome, and the lint script runs it across the project with the write and unsafe flags, so formatting and lint fixes happen as part of the check. Type checking is a separate tsc invocation with no emit, and there is a validate script that runs skills-ref to-prompt over the eight skill directories, which is the specific guard that matters for this project, because a skill file is not just prose, it is a document with a shape that the tooling can generate a prompt from. The combined check script runs lint, type check and validate in sequence, and the release script runs the tests, the type check and changeset publish. Versions move through changesets, with a changelog script, a bump script and the manifest sitting at 0.18.0. The published package is scoped as @talesofai/neta-skills, it declares Node 22 or newer, and it exposes a binary named neta-cli pointing at bin/cli.js.

## Where this fits, and what to decide first

The honest comparison is with calling the API yourself. If your team already has an HTTP client and a token, you can write the same requests directly, and that gives you full control over retries, caching and error handling, with no dependency on a CLI or on skill files that an agent will interpret on its own terms. The skills earn their place in a different situation, where the caller is an agent rather than a program. In that case the value of a skill is that it encodes the sequence, the argument names and the preconditions in a form the agent reads, and 49 commands with consistent naming is a lot of vocabulary to hand write for every project. The limitations follow from the same position. Everything is bound to one hosted service, so the skills are useful only while that service and its API exist and while your account can spend credits, and the environment file shows that the API base URL is configurable, which is the hook for a different deployment. The second limitation is credit consumption, which makes cost control part of the design rather than an afterthought, and the analytics switch is the kind of thing to settle before the CLI runs in a shared environment. The last is that the project publishes no GitHub releases, so you track the package version on npm rather than a tagged release, and the last push was on 2026-07-22.

## Conclusion

Adopt neta-skills if you are building an agent that should generate media through the Neta Art service and you want the workflows described in installable skill files rather than API calls scattered across your own prompts and code. It does not fit a team that wants model-agnostic tooling, since every command targets one hosted API, and it does not fit a deployment that cannot talk to a third party service or spend credits, because generation commands consume an AP balance and the premium commands are about buying more. Before you install, read the authentication section and decide between a NETA_TOKEN in the environment and the device flow login on the global host, and check the analytics setting before you enable the CLI in a shared environment.

## FAQ

### What is neta-skills and what does it do?

It is a collection of AI agent skills and CLI tools for interacting with the Neta Art API, so an agent can generate images, videos and songs, manage characters and elementum tokens, explore community content and run interactive story campaigns. The models themselves are hosted by the service; this repository is the client and the instructions.

### How do I install the neta skills?

Run npx skills add talesofai/neta-skills/skills/neta to install the unified skill, or install one of the specialised skills such as neta-creative, neta-community, neta-suggest, neta-space, neta-character, neta-elementum or neta-adventure individually. The repository keeps one directory per skill and validates all eight.

### How does authentication work for the neta CLI?

The default is a NETA_TOKEN obtained from the Neta Open Portal and placed in the environment, with NETA_API_URL available as an optional base URL override. On the global API host at api.talesofai.com you can instead run neta login, which uses the OAuth device flow in two phases, request-code and verify-code, and stores the tokens locally.

### What are the premium and credit commands in neta-skills?

There is a set of premium commands that read the current plan and subscription end, list available plans with their SPU UUIDs, create and list orders, fetch a single order, and start payment for an unpaid order, for example through Stripe Checkout. Credits appear as an AP balance, with get_ap_info for the breakdown and get_ap_history for consumption and recharge history, and creating a character or elementum consumes credits.

### Can I turn off analytics in the neta CLI?

Yes. The example environment file in the repository lists DISABLE_TELEMETRY=1 as an optional setting to disable CLI usage analytics, alongside NETA_TOKEN and the optional NETA_API_URL override.

## Sources

- [Issues](https://github.com/netaart/neta-skills/issues)
- [License: MIT](https://github.com/netaart/neta-skills/blob/main/LICENSE)
- [netaart/neta-skills on GitHub](https://github.com/netaart/neta-skills)
- [Project website](https://www.neta.art)
- [README](https://github.com/netaart/neta-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/netaart-neta-skills