Agent Skills - Archetype AI Documentation

What are Agent Skills?

Agent Skills are packaged, reusable instructions that teach an AI coding agent how to handle a specific Newton task — for example, “evaluate the assembly steps shown in this video,” “embed these vibration windows and flag the anomalies,” or “scaffold a branded dashboard for the demo front-end.” Each skill is a folder containing a SKILL.md (plus optional runnable reference scripts and tests) that the agent loads on demand. Skills give agents the institutional knowledge you’d otherwise have to repeat in every prompt: which endpoint to call, what the request body looks like, and the empirical gotchas we’ve already verified against production. They’re the difference between “explain the Direct Query API” (you do the synthesis) and “run this clip through Newton and tell me if the assembly passed” (the agent already knows how). The canonical source is the archetypeai/agent-skills repository.

Install

Any coding agent (recommended)

The skills are published on skills.sh. One command detects your coding agent (Claude Code, Cursor, Codex, Copilot, and 20+ others) and installs to the right location:

# Install into the current project
npx skills add archetypeai/agent-skills

# Or install globally (available in all projects)
npx skills add archetypeai/agent-skills -g

Manual install (Claude Code)

Alternatively, copy the skills folder into Claude Code’s skills directory:

# Clone the repo
git clone https://github.com/archetypeai/agent-skills.git
cd agent-skills

# Install globally (available in every project)
cp -r skills/* ~/.claude/skills/

# Or install into a single project
cp -r skills/* /path/to/your-project/.claude/skills/

The SKILL.md format is portable: the same files work with any agent runtime that loads skills from a directory — see each agent’s docs for the directory it reads from.

Invoke

Once installed, invoke any skill in your agent with a slash command:

# Agents
/atai-operational-state-monitoring-agent
/atai-operational-state-monitoring-agent-data-prep
/atai-rare-event-detection-agent
/atai-anomaly-discovery-agent
/atai-manual-generation-agent
/atai-task-verification-agent

# Models
/atai-newton-omega-model-data-prep
/atai-newton-omega-model
/atai-newton-fusion-model

# Integrations
/atai-newton-omega-nvidia-nemotron

# Design
/atai-design-system

Available skills

Four groups: Agents run a maintained pipeline server-side over the Agents API, Models call Newton directly on /query and leave the orchestration to you, Integrations pair a Newton model with a third-party model, and Design covers the demo front-end. Every skill that calls the platform builds its reference scripts on the official python client (pip install archetypeai), declared in each skill’s references/requirements.txt. Three skills call no API: atai-newton-omega-model-data-prep and atai-operational-state-monitoring-agent-data-prep are local data processing, and atai-design-system scaffolds through the ds CLI. One exception, for now: the OSM skill’s Path 2 uses a small stdlib HTTP helper, because the client doesn’t cover the Optimizations, Evals and promote endpoints yet. The Integrations skill uses the official client for its Newton calls and calls the partner model on its own API (for Nemotron, NVIDIA’s hosted API with its own NVIDIA_API_KEY).

Agents

Managed end-to-end pipelines — upload an input, run a pre-packaged bundle or canonical blueprint, poll, download the output. No model to host. OSM can also be fitted to your own data on the platform (Optimizations → promote → Evals → bundle), with its data-prep skill in front. The three sensor agents answer different questions, and the discriminator is what you already have labelled: every regime (OSM), a handful of examples of one named fault (RED), or nothing but normal operation (AD).

Skill	When to use
`atai-operational-state-monitoring-agent`	Classify every operating regime over a sensor CSV, when you have a full labelled library of the states you care about — drilling states, machine modes, process phases. Two paths. Path 1: resolve the pre-packaged “OSM Quick Start” bundle by name (classifier and windowing already pinned), run one agent per input file, poll, and download per-window state predictions with per-class probabilities. Path 2: build an agent on your own labelled data — fit and score windowing and kNN settings with the Optimizations API, promote the best trial to a blueprint, test it once with the Evals API, deliver it as a bundle, and score the delivery against held-back labels.
`atai-operational-state-monitoring-agent-data-prep`	Turn labelled sensor recordings into the role files OSM’s Path 2 accepts — an exact sample grid split at gaps, a check that the sensor can tell the states apart, a group-aware split, library-only z-score, one training file per state, continuous scored files, held-back delivery labels — and preflight every platform rule before upload. Local, no API key.
`atai-rare-event-detection-agent`	Detect a named rare fault recurring — a pump breakdown, a process excursion — from a handful of labelled examples plus normal data. Nearest-prototype classifier over Omega embeddings, so it tolerates the severe class imbalance of one or two incidents against months of normal operation. Covers why incident-level detection and false-alarm rate must be scored separately from window-level accuracy.
`atai-anomaly-discovery-agent`	Flag “this no longer looks like normal operation” on an asset with no fault history — fitted on normal-only reference data, so everything it flags is something it was never shown. Per-window anomaly score from a fitted LOF detector with its threshold pinned. One detector per asset by construction; covers scoring by lead time and false-alarm rate rather than precision and recall.
`atai-manual-generation-agent`	Turn a recording of a procedure into an ordered, timestamped manual — each step traceable to a frame range and time range in the source video. Runs the canonical `mga` blueprint (Newton fusion + Whisper, pinned by the blueprint), so audio matters: spoken-only content such as safety cautions shows up in the output.
`atai-task-verification-agent`	Check whether a recording followed a known procedure — upload the video and a reference SOP, get a per-step `PASSED` / `FAILED` / `MISSING` verdict with a timestamp and a reason. The SOP is a runtime input, so one bundle serves every procedure. Read the skill’s reliability section before trusting a verdict: a skipped step whose tool or part is visible on screen can come back `PASSED`, so `PASSED` verdicts warrant human review.

Models

Direct Query API — one stateless POST /query per request. Use these when you want control over the pipeline, or the raw vectors to build on.

Skill	When to use
`atai-newton-omega-model-data-prep`	Clean, split, and featurize multivariate time-series before the Omega model — gap-aware blocking + imputation, an out-of-time train/test split, and joint-state (X, y) featurization. Use to build a leakage-free n-shot reference set for `atai-newton-omega-model`.
`atai-newton-omega-model`	Get time-series embeddings from the Omega encoder (`OmegaEncoder::omega_embeddings_1_4`) on `/query` — send a window of sensor readings, get back a 768-d vector per channel (one call per channel, fanned out in parallel). Covers the request/response shape, the 16–1024 window-length range, `normalize_input`, and a client-side n-shot KNN classification example.
`atai-newton-fusion-model`	Call the Newton C 2.6 fusion model on `/query` with text, image, or video in one stateless POST — no session lifecycle, no batch job, no SSE. Covers the request shape per modality (including both video paths: `.mp4` + `max_frames`, and client-sampled frames + `query_metadata`), multi-image mode, generation parameters, JSON-output prompting, and the verified gotchas.

Integrations

Newton paired with a third-party model: Newton does the sensing, the other model reasons over what Newton found. For running Newton inside a partner’s stack instead, see NVIDIA VSS with Newton Fusion.

Skill	When to use
`atai-newton-omega-nvidia-nemotron`	Turn Omega + KNN verdicts into operator-facing text with NVIDIA Nemotron on NVIDIA’s hosted API — fault briefs (what changed, likely cause, what to check) or suggested operator actions. Omega senses, Nemotron explains: Nemotron gets the verdict and plain window statistics against a healthy baseline or peer, never the embeddings. Covers NVIDIA key types (an NGC key returns 403), model retirement, turning Nemotron 3’s reasoning off (`chat_template_kwargs`, not `/no_think`), JSON-only prompts with validation in code, and caching. Includes a key/model preflight script and an end-to-end example on the bundled bearing data.

Design

Skill	When to use
`atai-design-system`	Build the front-end for a Newton demo with the Archetype AI Design System — the published npm packages (`@archetypeai/ds-lib-tokens`, the Svelte console/labs component libraries) and the `ds` scaffolding CLI — instead of hand-rolling tokens, components, fonts, or brand styling. Scaffolds a SvelteKit + Tailwind v4 app and installs the design system’s own agent config (`CLAUDE.md`/`AGENTS.md` + `ds-manifest.json`) as the source of truth thereafter. Components ship for Svelte 5 (React port in progress); the tokens package is framework-agnostic.

Example projects

These public repos demonstrate the patterns covered by the skills above — clone them as starting templates: Vision & text reasoning (atai-newton-fusion-model):

traffic-demo — live Caltrans CCTV traffic analysis; samples a burst of frames per interval and sends them as one multi-frame /query clip to reason over flow, incidents, and conditions.
wildfire-demo — wildfire detection across 1,200+ ALERTCalifornia cameras with Newton vision (per-camera smoke/fire/haze + zone Q&A).
earthquake-demo — real-time USGS feed → text reasoning over structured seismic data (aftershock sequences, clustering, regional-risk ranking).
grid-demo — California power grid (CAISO supply/demand) → text reasoning on duck-curve dynamics, ramp, renewable share, and grid-stress risk.
wifi-demo — “is anyone home?” occupancy inference from residential WiFi device-telemetry (GHOST-IoT) — per-window verdict + per-device classification shown against ground truth.

Time-series embeddings + local KNN (atai-newton-omega-model, with atai-newton-omega-model-data-prep for the reference set):

swat-demo-direct-query — 6-stage water-treatment-plant anomaly dashboard: per-channel Omega embeddings + client-side KNN, with PCA-2/UMAP-2 embedding views and per-stage accuracy badges (plus /query text reasoning for operator suggestions).
wind-turbine-demo — Penmanshiel wind-farm SCADA: Omega embeddings + local KNN against a leakage-free n-shot library precomputed offline, detecting a real frequency-converter fault against a healthy peer turbine.
drilling-demo — drilling state classification from 14 North Sea (Volve) wells: Omega embeddings + local KNN against a leakage-free n-shot library built from held-out reference wells, with live accuracy vs ACTC ground truth.

Omega + NVIDIA Nemotron (atai-newton-omega-nvidia-nemotron, on top of atai-newton-omega-model):

swat-demo-nemotron — the SWaT water-treatment dashboard with NVIDIA Nemotron writing the operator suggestions: upstream / local / downstream action cards as JSON, checked in code against the plant topology and each stage’s equipment, cached per anomaly set.
wind-turbine-demo-nemotron — the Penmanshiel monitor with NVIDIA Nemotron fault briefs: when Omega flags a turbine, Nemotron compares the window with the healthy peer over the same hours. It pointed to the pitch system for a real 23-hour pitch-circuit stop, from SCADA alone.

Agent lifecycle on real data (atai-operational-state-monitoring-agent, with atai-operational-state-monitoring-agent-data-prep for the role files):

operational-state-monitoring-agent-example-larco-quickstart — washing-machine vibration (LARCO, 9 channels at 200 Hz) → an OSM agent fitted on the platform: an Optimizations search, the best trial promoted to a blueprint, one Evals test, then a bundle delivered to a second machine and scored against its held-back labels (fill / wash / spin / drain).
operational-state-monitoring-agent-example-larco — the full study behind the quickstart: all 199 cycles of two machines, a simple vibration-level baseline compared at every stage, a 16-trial search, then a test on new settings and delivery to the second machine (106 cycles). Includes the packed role files, so you can skip the data preparation.

If you build something with these skills, open a PR against agent-skills to share your patterns — the empirical gotchas in each SKILL.md came from real production runs and we’d love more.

​What are Agent Skills?

​Install

​Any coding agent (recommended)

​Manual install (Claude Code)

​Invoke

​Available skills

​Agents

​Models

​Integrations

​Design

​Example projects

What are Agent Skills?

Install

Any coding agent (recommended)

Manual install (Claude Code)

Invoke

Available skills

Agents

Models

Integrations

Design

Example projects