New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Xybrid Init

by xybrid-ai in xybrid-ai/xybrid

Generate model metadata for an ML model so it works with xybrid.

Apache-2.0Auto-check passedAI & LLM Engineering

Install Xybrid Init

skills CLI
$ npx skills add xybrid-ai/xybrid --skill xybrid-init -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install xybrid-ai/xybrid xybrid-init --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/xybrid-ai/xybrid.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/xybrid-init .claude/skills/xybrid-init && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
xybrid-init
GitHub stars
469
Token cost
~3k tokens
SKILL.md length
734 words
Files
1
Skills in repo
2
Repo updated
First seen
Licence
Apache-2.0

At a glance

Generate model metadata for an ML model so it works with xybrid.

  • Works in 8 steps: Determine Source → Gather Context → Analyze and Generate → …
  • Tasks that involve Model hubs and datasets
  • SKILL.md covers Step 1: Determine Source, Step 2: Gather Context, Step 3: Analyze and Generate and Step 4: Validate, plus 4 more sections
  • Calls python3, curl and cargo; reaches huggingface.co

What it does

Xybrid Init is an agent skill from xybrid-ai/xybrid. Generate model metadata for an ML model so it works with xybrid.

Its SKILL.md is about 3k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in AI & LLM Engineering, covering Model hubs and datasets, Machine learning and Speech recognition and synthesis. It works with ONNX, Hugging Face, llama.cpp and Ollama. The repository describes itself as: Cross-platform on-device AI toolkit. The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Model hubs and datasets
  • Tasks that involve Machine learning
  • Tasks that involve Speech recognition and synthesis

Example prompts

  • “/xybrid-init”

Requirements

  • Python 3

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  1. Determine Source
  2. Gather Context
  3. Analyze and Generate
  4. Validate
  5. Real Examples for Reference
  6. Present and Save
  7. Download Model Files (if HuggingFace)
  8. Next Steps

What it can do on your machine

Read from SKILL.md and the folder at commit b0673b4. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python3
    • curl
    • cargo

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • huggingface.co

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Xybrid Init loads about 3k tokens when it runs. Until then it costs about 19 tokens; SKILL.md has 734 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~19
When it runs · the whole SKILL.md, loaded when a task matches
~3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from xybrid-ai/xybrid at commit b0673b4, republished under its Apache-2.0 licence (© xybrid-ai). 734 words, ~2,974 tokens.

Download SKILL.mdSave it as .claude/skills/xybrid-init/SKILL.md (or your agent's skills folder).
name
xybrid-init
description
Generate model metadata for an ML model so it works with xybrid.

Generate a model_metadata.json for any ML model so it works with xybrid.

The user may provide a HuggingFace repo, a local directory, or nothing (in which case ask).

Input: $ARGUMENTS (optional — HuggingFace repo ID, URL, or local path)

Step 1: Determine Source

If $ARGUMENTS is provided, use it. Otherwise ask:

What model do you want to set up?

  • Paste a HuggingFace repo (e.g. hexgrad/Kokoro-82M-v1.0-ONNX)
  • Or a local directory path (e.g. ./my-model/)

Detect the source type:

  • Contains huggingface.co/ or matches org/repo pattern → HuggingFace
  • Is a local path that exists → Local directory
  • Otherwise → ask the user to clarify

Step 2: Gather Context

If HuggingFace:

Fetch these three resources (use WebFetch for each):

  1. Model card: https://huggingface.co/{repo}/raw/main/README.md
  2. File listing: https://huggingface.co/api/models/{repo} (look at the siblings array for file names and sizes)
  3. Config file (if exists): https://huggingface.co/{repo}/raw/main/config.json

Also check for these files (fetch if they exist in the file listing):

  • tokenizer_config.json
  • tokenizer.json
  • generation_config.json
If Local directory:
  1. List all files in the directory
  2. Read any README.md, config.json, tokenizer_config.json if present
  3. If Python is available and there's an .onnx file, inspect it:
    bash
    python3 -c "import onnx; m = onnx.load('MODEL.onnx'); print('Inputs:', [(i.name, [d.dim_value for d in i.type.tensor_type.shape.dim]) for i in m.graph.input]); print('Outputs:', [(o.name, [d.dim_value for d in o.type.tensor_type.shape.dim]) for o in m.graph.output])"

Step 3: Analyze and Generate

Using ALL the gathered context (model card, file list, config, ONNX inputs/outputs), generate a valid model_metadata.json.

Decision Tree

Use the model card description, file extensions, and config to determine the model type:

File-based detection:

  • .gguf file → LLM (Gguf template)
  • GGML Whisper weights (ggml-*.bin, or a .bin whose model card says whisper.cpp / GGML) → ASR (GgmlWhisper template) — the default ASR path
  • .safetensors + whisper architecture → ASR (SafeTensors template, Candle runtime) — opt-in only, needs --features candle; prefer the GGML bundle above
  • .onnx file → continue to task detection below
  • .mlmodel / .mlpackage → CoreML template
  • .tflite → TfLite template

Task detection (from model card + config):

  • Model card mentions "text-to-speech", "TTS", "speech synthesis" → TTS
  • Model card mentions "speech recognition", "ASR", "transcription" → ASR
  • Model card mentions "embedding", "sentence transformer", "similarity" → Embedding
  • Model card mentions "classification", "image", "vision", "ImageNet" → Vision
  • Model card mentions "language model", "text generation", "chat", "instruct" → LLM
  • Model card mentions "object detection", "YOLO", "segmentation" → Vision
Schema Reference

The model_metadata.json must conform to this exact schema:

json
{
  "model_id": "string (required) — kebab-case identifier",
  "version": "string (required) — model version",
  "description": "string (optional) — human-readable description",
  "execution_template": { "type": "...", ... },
  "preprocessing": [ ... ],
  "postprocessing": [ ... ],
  "files": [ "list of all required files" ],
  "metadata": { "task": "...", ... },
  "voices": { "... (TTS only)" }
}

Common optional metadata fields:

  • tool_calling (boolean, LLMs only): advisory declaration that xybrid's local tool calling works end-to-end for this model — the template accepts a tools context AND the model emits a call format xybrid parses (currently LFM2-family pythonic and gemma-4-family call: notation). Declare true only for those verified families; omit when unknown (never infer from architecture); a model whose template renders tools but whose emissions xybrid cannot parse must NOT declare true — it would produce silent no-call responses.
Execution Templates

Choose ONE:

json
// ONNX model
{ "type": "Onnx", "model_file": "model.onnx" }

// GGML Whisper (whisper.cpp — the default ASR path, feature `asr-whispercpp`)
// `language`: omit or null to auto-detect. `audio_ctx`: 0 = no encoder
// truncation (the safe default — truncating is the biggest streaming speed
// lever but too much of it makes the decoder loop, so opt in per model after
// a quality check). `translate`: true translates to English instead of
// transcribing in the source language.
{ "type": "GgmlWhisper", "model_file": "model.bin", "language": "en", "audio_ctx": 0, "translate": false }

// SafeTensors (Candle runtime — Whisper only; opt-in `candle` feature, in no platform preset)
{ "type": "SafeTensors", "model_file": "model.safetensors", "architecture": "whisper", "config_file": "config.json", "tokenizer_file": "tokenizer.json" }

// GGUF (local LLMs via llama.cpp)
{ "type": "Gguf", "model_file": "model.gguf", "context_length": 4096 }

// CoreML (Apple platforms)
{ "type": "CoreMl", "model_file": "model.mlpackage" }

// TFLite (mobile)
{ "type": "TfLite", "model_file": "model.tflite" }
Show full SKILL.md (310 more words)Show less
Preprocessing Steps

Choose the appropriate chain based on task:

TTS (text-to-speech):

json
[{ "type": "Phonemize", "tokens_file": "tokens.txt", "backend": "MisakiDictionary", "add_padding": true, "normalize_text": true }]

Backends: MisakiDictionary (default, pure Rust), EspeakNG (multi-language, needs system install), CmuDictionary (legacy), OpenPhonemizer (hybrid dictionary + neural)

ASR (speech recognition) with ONNX:

json
[{ "type": "AudioDecode", "sample_rate": 16000, "channels": 1 }]

ASR with Whisper SafeTensors: empty [] (Candle handles internally)

Text embedding / NLP:

json
[{ "type": "Tokenize", "vocab_file": "tokenizer.json", "tokenizer_type": "WordPiece", "max_length": 512 }]

Tokenizer types: WordPiece (BERT), BPE (GPT), SentencePiece (T5)

Image classification / vision:

json
[
  { "type": "Resize", "width": 224, "height": 224 },
  { "type": "Normalize", "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] }
]

Use ImageNet normalization values unless model card specifies otherwise.

LLM (GGUF): empty [] (llama.cpp handles internally)

Postprocessing Steps

TTS:

json
[{ "type": "TTSAudioEncode", "sample_rate": 24000, "apply_postprocessing": true }]

ASR (CTC-based, e.g. Wav2Vec2):

json
[{ "type": "CTCDecode", "vocab_file": "vocab.json", "blank_index": 0 }]

ASR (Whisper SafeTensors): empty []

Text embedding:

json
[{ "type": "MeanPool", "dim": 1 }]

Image classification:

json
[{ "type": "Softmax", "dim": 1 }]

Or { "type": "Argmax" } if you just need the class index.

LLM: empty []

Voice Config (TTS only)

If the model has voice embeddings (e.g. voices.bin):

json
{
  "voices": {
    "format": "embedded",
    "file": "voices.bin",
    "loader": "binary_f32_256",
    "default": "voice_id",
    "selection_strategy": "TokenLength",
    "catalog": [
      { "id": "voice_id", "name": "Display Name", "index": 0, "gender": "female", "language": "en-US", "style": "neutral" }
    ]
  }
}

Step 4: Validate

Before presenting the result, verify:

  1. All files in files array exist (in the HF repo or local directory)
  2. model_file matches an actual file name
  3. Preprocessing/postprocessing steps match the model task
  4. Step types are valid — only use the types listed above
  5. The JSON is valid — parseable, no trailing commas

Step 5: Real Examples for Reference

TTS (Kokoro 82M)
json
{
  "model_id": "kokoro-82m",
  "version": "1.0",
  "description": "Kokoro 82M - High-quality TTS with 24 voices",
  "execution_template": { "type": "Onnx", "model_file": "model.onnx" },
  "preprocessing": [{ "type": "Phonemize", "tokens_file": "tokens.txt", "backend": "MisakiDictionary", "add_padding": true, "normalize_text": true }],
  "postprocessing": [{ "type": "TTSAudioEncode", "sample_rate": 24000, "apply_postprocessing": true }],
  "files": ["model.onnx", "voices.bin", "tokens.txt", "misaki/us_gold.json"],
  "metadata": { "task": "text-to-speech", "sample_rate": 24000, "parameters": 82000000, "family": "hexgrad", "license": "Apache-2.0" }
}
LLM (Qwen 3.5 0.8B)
json
{
  "model_id": "qwen3.5-0.8b",
  "version": "1.0",
  "description": "Qwen 3.5 0.8B - Lightweight multilingual LLM",
  "execution_template": { "type": "Gguf", "model_file": "Qwen3.5-0.8B-Q4_K_M.gguf", "context_length": 4096 },
  "preprocessing": [],
  "postprocessing": [],
  "files": ["Qwen3.5-0.8B-Q4_K_M.gguf"],
  "metadata": { "task": "text-generation", "architecture": "qwen35", "backend": "llamacpp", "parameters": 800000000, "license": "Apache-2.0" }
}
Text Embedding (all-MiniLM)
json
{
  "model_id": "all-minilm",
  "version": "L6-v2",
  "execution_template": { "type": "Onnx", "model_file": "model.onnx" },
  "preprocessing": [{ "type": "Tokenize", "vocab_file": "tokenizer.json", "tokenizer_type": "WordPiece", "max_length": 512 }],
  "postprocessing": [{ "type": "MeanPool", "dim": 1 }],
  "files": ["model.onnx", "vocab.txt", "tokenizer.json", "config.json"],
  "metadata": { "task": "text-embedding", "embedding_dim": 384 }
}
ASR (Whisper Tiny — SafeTensors)
json
{
  "model_id": "whisper-tiny",
  "version": "1.0",
  "description": "Whisper Tiny - Fast multilingual ASR (Candle runtime)",
  "execution_template": { "type": "SafeTensors", "model_file": "model.safetensors", "config_file": "config.json", "tokenizer_file": "tokenizer.json" },
  "preprocessing": [],
  "postprocessing": [],
  "files": ["model.safetensors", "config.json", "tokenizer.json", "melfilters.bytes"],
  "metadata": { "task": "speech-recognition", "runtime": "candle", "sample_rate": 16000, "parameters": 39000000 }
}
Image Classification (MNIST)
json
{
  "model_id": "mnist-digit-recognition",
  "version": "12",
  "description": "MNIST handwritten digit recognition",
  "execution_template": { "type": "Onnx", "model_file": "model.onnx" },
  "preprocessing": [
    { "type": "Reshape", "shape": [1, 1, 28, 28] },
    { "type": "Normalize", "mean": [0.0], "std": [255.0] }
  ],
  "postprocessing": [{ "type": "Softmax", "dim": 1 }],
  "files": ["model.onnx"],
  "metadata": { "task": "image_classification", "input_shape": [1, 1, 28, 28], "num_classes": 10 }
}

Step 6: Present and Save

Show the generated model_metadata.json to the user with a brief explanation of the key decisions made (e.g., "Using MisakiDictionary phonemizer because the model card says it's a Kokoro-based TTS model").

Then ask:

Save to {directory}/model_metadata.json?

If the user confirms, write the file.

Step 7: Download Model Files (if HuggingFace)

If the source is HuggingFace and the model files aren't local yet, offer to download:

Download model files (~{size})? This will fetch:

  • model.onnx (150 MB)
  • voices.bin (24 KB)
  • ...

If the user confirms, download each file listed in the files array:

bash
curl -L "https://huggingface.co/{repo}/resolve/main/{file}" -o "{directory}/{file}"

For files in subdirectories (e.g. misaki/us_gold.json), create the subdirectory first.

Step 8: Next Steps

After saving, print:

Your model is ready. Next steps:

# Test it works (use --input-audio <file>.wav for ASR models)
xybrid run --model {model_id} --input-text "test input"

# Or from Rust
cargo run --example your_test -p xybrid-core

# Or use /test-model to validate end-to-end

If /test-model is available (the user has xybrid cloned), suggest running it.

© xybrid-ai, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/xybrid-init of xybrid-ai/xybrid.

Open the folder on GitHubat commit b0673b4

Compare with similar skills

Xybrid Init next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Xybrid Init compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Xybrid Init this skillxybrid-ai/xybrid469—~3kAutomated safety check: PassApache-2.0
Community Model ConversionRisorseArtificiali/anti-vocale118—~2.2kAutomated safety check: PassApache-2.0
Hugging Face LLM Trainerhuggingface/skills11k1 repos~7.2kAutomated safety check: PassApache-2.0
Add Modelguoqingbao/xinfer334—~4.2kAutomated safety check: NotesMIT
Resolvealexziskind1/model-shelf130—~792Automated safety check: PassMIT
Test Modelguoqingbao/xinfer334—~2.6kAutomated safety check: PassMIT

Similar skills

  • Community Model Conversion

    RisorseArtificiali/anti-vocale

    Convert a HuggingFace ASR fine-tune into a sherpa-onnx external model, publish it, and add it to the Anti-Vocale community catalog.

    118 GitHub stars~2.2k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed

  • Hugging Face LLM Trainer

    huggingface/skills

    Official

    Trains or fine-tunes language and vision models with TRL or Unsloth on Hugging Face Jobs cloud GPUs, then converts the results to GGUF.

    11k GitHub starsUsed in 1 repo~7.2k tokens
    AI & LLM EngineeringAuto-check passed

  • Add Model

    guoqingbao/xinfer

    Adapt and port new LLM model architectures to this xinfer project.

    334 GitHub stars~4.2k tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check: notes

  • Resolve

    alexziskind1/model-shelf

    Always resolve Hugging Face models via model-shelf before any download.

    130 GitHub stars~792 tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check passed

  • Test Model

    guoqingbao/xinfer

    Test LLM models served by xinfer for correctness, output quality, and performance.

    334 GitHub stars~2.6k tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check passed

  • Model Scout

    RisorseArtificiali/anti-vocale

    A skill your agent uses when the user asks to "scout for new models", "check for model updates", "find better ASR models", "check sherpa-onnx releases", "look for new Whisper models", "search…

    118 GitHub stars~2.9k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed

More from xybrid-ai/xybrid

  • Test Model

    xybrid-ai/xybrid

    Test a model end-to-end using the xybrid execution system. An agent skill from xybrid-ai/xybrid.

    469 GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Xybrid Init

What does Xybrid Init do?

Generate model metadata for an ML model so it works with xybrid. Xybrid Init is an agent skill from xybrid-ai/xybrid. Generate model metadata for an ML model so it works with xybrid.

When should I use Xybrid Init?

Xybrid Init fits situations like: tasks that involve Model hubs and datasets; tasks that involve Machine learning; tasks that involve Speech recognition and synthesis.

How do I install Xybrid Init in Claude Code?

Run `npx skills add xybrid-ai/xybrid --skill xybrid-init -a claude-code`. Or copy the skill folder (.agents/skills/xybrid-init in xybrid-ai/xybrid) into .claude/skills/xybrid-init in your project. Claude Code loads it when a task matches its description.

How do I install Xybrid Init in Codex?

Run `npx skills add xybrid-ai/xybrid --skill xybrid-init -a codex`. Or copy the skill folder (.agents/skills/xybrid-init in xybrid-ai/xybrid) into .agents/skills/xybrid-init in your project. Codex loads it when a task matches its description.

Can I use Xybrid Init in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add xybrid-ai/xybrid --skill xybrid-init -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/xybrid-init, .gemini/skills/xybrid-init, .github/skills/xybrid-init and .opencode/skills/xybrid-init in your project.

What does Xybrid Init need to run?

Going by SKILL.md and its folder, Xybrid Init needs the command-line tools its instructions call (python3, curl and cargo). Our summary lists: Python 3.

Does Xybrid Init access the network?

SKILL.md names 1 domain. In commands or code: huggingface.co; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Xybrid Init safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Xybrid Init use?

Xybrid Init is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Xybrid Init use?

About 3k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Xybrid Init?

Skills that share tags, products or a category with Xybrid Init: Community Model Conversion (RisorseArtificiali/anti-vocale, 118 stars), Hugging Face LLM Trainer (huggingface/skills, 11k stars), Add Model (guoqingbao/xinfer, 334 stars) and Resolve (alexziskind1/model-shelf, 130 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Xybrid Init?

xybrid-ai (a GitHub organization) maintains it in xybrid-ai/xybrid, which has 469 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 9, 2026.

Source: xybrid-ai/xybrid on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.