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

Open Weights

by ericrisco in ericrisco/rsc-harness

A skill your agent uses when choosing an open-weight LLM and clearing it for use — which family and size fit the task, the hardware and the budget, and above all whether the license permits shipping.

MITAuto-check passedAI & LLM Engineering

Install Open Weights

skills CLI
$ npx skills add ericrisco/rsc-harness --skill open-weights -a claude-code

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

GitHub CLI
$ gh skill install ericrisco/rsc-harness open-weights --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/ericrisco/rsc-harness.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/open-weights .claude/skills/open-weights && 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
open-weights
GitHub stars
167
Token cost
~4.1k tokens
SKILL.md length
2,087 words
Files
6 (incl. references)
Skills in repo
227
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when choosing an open-weight LLM and clearing it for use — which family and size fit the task, the hardware and the budget, and above all whether the license permits shipping.

  • Works in 6 steps: How to choose an open model → Model families → Licenses → …
  • Choosing an open-weight LLM and clearing it for use — which family and size fit the task
  • SKILL.md covers The one rule (read before you…, 1. How to choose an open model, 2. Model families and 3. Licenses, plus 6 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Open Weights is an agent skill from ericrisco/rsc-harness. Use when choosing an open-weight LLM and clearing it for use — which family and size fit the task, the hardware and the budget, and above all whether the license permits shipping. Owns the license-class map (OSI-open versus custom-community versus non-commercial), the always-verify-the-model-card rule, size-to-VRAM budgeting and the quant formats. This layer decides WHICH model and whether the license allows it, then hands off. NOT downloading or hosting on the Hub (that is huggingface), NOT running it locally…

Its SKILL.md is about 4.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including reference files (for example `evals/README.md`, `evals/cases.yaml` and `references/licenses.md`).

It sits in AI & LLM Engineering, covering Model hubs and datasets, LLM inference and serving and Budgeting and forecasting. It works with Hugging Face, Ollama, vLLM and DeepSeek. The repository describes itself as: Your agent invents things because it has no memory, and can't touch your database because it has no arms. rsc is the meta-harness that gives it both, plus the trade to know the… The licence is MIT.

When your agent uses it

  • Choosing an open-weight LLM and clearing it for use — which family and size fit the task
  • The hardware and the budget
  • Above all whether the license permits shipping

Example prompts

  • “/open-weights”

Workflow steps

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

  1. How to choose an open model
  2. Model families
  3. Licenses
  4. Size ↔ VRAM
  5. Quant / formats
  6. Where to get it + how to run it (routing)

What it can do on your machine

Read from SKILL.md and the folder at commit e3d5b33. 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

    No scripts in the folder and no shell commands in SKILL.md.

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

  • Network

    Links to these hosts (documentation or services it may open):

    • ai.google.dev
    • 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

Open Weights loads about 4.1k tokens when it runs, and up to ~8.3k if it reads all its reference files. Until then it costs about 159 tokens; SKILL.md has 2,087 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~159
When it runs · the whole SKILL.md, loaded when a task matches
~4.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~8.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 ericrisco/rsc-harness at commit e3d5b33, republished under its MIT licence (© ericrisco). 2,087 words, ~4,140 tokens.

Download SKILL.mdSave it as .claude/skills/open-weights/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
open-weights
description
Use when choosing an open-weight LLM and clearing it for use — which family and size fit the task, the hardware and the budget, and above all whether the license permits shipping. Owns the license-class map (OSI-open versus custom-community versus non-commercial), the always-verify-the-model-card rule, size-to-VRAM budgeting and the quant formats. This layer decides WHICH model and whether the license allows it, then hands off. NOT downloading or hosting on the Hub (that is `huggingface`), NOT running it locally (that is `ollama`), NOT serving at throughput (that is `vllm`), NOT fine-tuning it (that is `finetuning`).
tags
open-weights, open-source-llm, model-selection, model-licenses, llama-qwen-mistral-gemma
recommends
huggingface, ollama, finetuning, vllm
origin
risco

Open weights — pick the model, then clear the license

This is the CHOICE layer. Given a task, a box, and a shipping constraint, it tells you which open model to reach for and whether the license lets you ship it. It does not download, run, serve, or fine-tune anything — it feeds the skills that do (see Related skills).

The one rule (read before you name a model)

Model names and their licenses change monthly. Never state a license from memory — open the model card and confirm it, every time. This file was authored against cards live in mid-2026; by the time you read it, versions have shipped and terms have moved. So:

  • Treat every specific version/license line below as [verify the card], not as settled fact.
  • State the license class (OSI-open vs custom-community vs restricted), then send the reader to the actual LICENSE / terms page for the exact model + size they intend to ship.
  • The decision framework and the class taxonomy are the durable parts. The version list is the perishable part. Weight your trust accordingly.

Real, verified-mid-2026 examples of why this rule exists — all confirmed against the source, and all things that were different at my Jan-2026 cutoff:

  • Gemma 4 moved to Apache-2.0, while Gemma 1–3 stay on the custom Gemma Terms of Use (confirmed on ai.google.dev/gemma/terms, accessed 2026-07-18). Same brand, opposite license class depending on version.
  • Codestral 2 was relicensed Apache-2.0 (per Mistral, Apr 2026), while the original Codestral stays non-production (MNPL). Same name, opposite shippability depending on release.
  • DeepSeek-R1 is MIT, but the original DeepSeek-V3 weights ship under a custom DeepSeek License Agreement with OpenRAIL-style use restrictions (confirmed on the V3 LICENSE-MODEL), not MIT. Same family, different license per model.

If three of the load-bearing facts moved in one release cycle, yours have too. Check the card.

1. How to choose an open model

Five gates, in this order. The license gate can veto everything above it, so never fall in love with a model before you clear it.

  1. Task fit — match the model's design to the job:
    • General chat / instruct → Llama, Qwen, Mistral, Gemma instruct variants.
    • Coding → Qwen-Coder, Codestral (license!), DeepSeek-Coder, gpt-oss.
    • Reasoning / math → DeepSeek-R1-style reasoning models, gpt-oss, Qwen reasoning variants.
    • Multilingual → Qwen and Gemma tend to lead; check the card's language list.
    • Multimodal (vision) → Llama vision, Qwen-VL, Gemma vision, PaliGemma, Phi multimodal.
    • Embeddings / retrieval → a dedicated embedding model, not a chat LLM → embeddings-search.
    • Small / edge → 0.5B–4B (Qwen small, Gemma small, Phi-mini, gpt-oss-20b class).
  2. Size vs your hardware class — can it even fit? See §4. A 70B at fp16 is ~140 GB; if you have one 24 GB GPU, that model is off the table unless you quantize and accept the quality/throughput cost. Pick a size your box can hold before you compare quality.
  3. License / shippability — the gate that matters most (see §3). Decide up front: is this a hobby/internal use, or a commercial product you distribute? "Open weights" does not mean "open source" and does not guarantee commercial rights. Verify the card.
  4. Hardware target — consumer GPU (8–24 GB), data-center GPU (A100/H100 80 GB), Apple unified memory, or CPU/edge. This narrows both size and quant format (GGUF for CPU/Mac/llama.cpp; AWQ/GPTQ for GPU serving).
  5. Community support — a proxy for "will this actually work Monday morning": are there ready-made GGUF/AWQ quants on the Hub, is it supported by your runtime (llama.cpp/Ollama/vLLM), are there fine-tunes and recent downloads? A model with no quants and no runtime support is a research artifact, not a shippable choice.

Rule of thumb: smallest model that passes your eval wins. Don't reach for 70B when a well-chosen 8B clears the bar — it's cheaper to run, faster, and fits more hardware. Prove it with agent-eval.

2. Model families

Families and typical size ladders below. Specific version claims are marked — [verify] at author time; the family and its rough sizing are the durable part. Full per-family notes, strengths, and license pointers in references/model-families.md.

FamilyMakerTypical open sizesNotes / current line [verify]
LlamaMeta~1B–~400B (dense + MoE)Llama 4 (Scout/Maverick, MoE) current line; custom Community License, gated
QwenAlibaba0.5B–235B+ (dense + MoE), strong Coder/VLmostly Apache-2.0 but per-size variance — check each card
Mistral / MixtralMistral AI7B dense, 8x7B/8x22B MoE, "Small/Large"open ones Apache-2.0; Codestral original = MNPL non-production
GemmaGoogle~1B–~27B, plus PaliGemma/CodeGemma/ShieldGemmaGemma 1–3 = custom Gemma Terms; Gemma 4 = Apache-2.0 [verify]
DeepSeekDeepSeekV3-class MoE (~600B+), R1 reasoning, distillsper-model license split — R1 MIT, original V3 custom; verify
PhiMicrosoft~3B–15B ("mini", reasoning, multimodal)MIT across the Phi-4 family [verify]
gpt-ossOpenAI20B and 120B (MoE, open weights)Apache-2.0 [verify]; OpenAI's first open-weight LLMs since GPT-2
Othersvarious—SmolLM, OLMo (fully-open incl. data), Falcon, Yi, Command — check card

3. Licenses

This is the load-bearing section. Get it wrong and you ship something you have no right to ship. Every model falls into one of three classes. Identify the class, then open the card.

The three classes
ClassExamples (class, not a promise)What it means for shipping
OSI-open (Apache-2.0, MIT)Qwen (most), Mistral open, Phi, gpt-oss, DeepSeek-R1, Gemma 4Commercial use, modify, redistribute — permissive. Still read the card for attribution/notice.
Custom / communityLlama (Meta Community), Gemma 1–3 (Gemma Terms)Broad free use but with conditions: acceptable-use policy, attribution, sometimes a scale cap. NOT OSI-open.
Non-commercial / restrictedoriginal Codestral (MNPL), any "research-only", some RAIL, some "≥$X revenue → buy a license"You cannot ship it in a commercial product without a separate license. Fatal if missed.

"Open weights" describes availability of the weights file — it says nothing about your legal rights. A model can be a free download and still be non-commercial. The download button is not a license.

Per-family license notes (state the class, then verify the exact card)
  • Llama = Meta Llama Community License — NOT OSI-open. Carries an Acceptable Use Policy, a "Built with Llama" attribution requirement on derivatives/products, naming rules, and a >700M-monthly-active-users clause (above that you must request a separate license from Meta, granted at Meta's discretion). Gated on the Hub (accept terms first). Verify the current Llama version's terms — Meta has revised them across releases.
  • Gemma = custom Gemma Terms of Use + Prohibited Use Policy for Gemma 1–3 (not Apache), with a duty to pass the restrictions downstream to every user and to ship the terms/notice file. Gemma 4 reportedly moved to Apache-2.0 — a textbook reason to check the version's card.
  • Qwen = mostly Apache-2.0, but with per-size variance. Historically some sizes (often the very largest or a special tier) carried a separate Qwen license instead of Apache. Check each size's card — do not assume "Qwen = Apache" for the whole family.
  • Mistral / Mixtral open models = Apache-2.0, but the original Codestral is MNPL (non-production) — free for research/eval, not for commercial deployment. Codestral 2 was relicensed Apache-2.0; verify which Codestral release you actually have. Note some newer Mistral models use a "Modified MIT" with a revenue-threshold commercial clause — verify.
  • DeepSeek = per-model split. Code repos are MIT; DeepSeek-R1 weights are MIT; but the original DeepSeek-V3 weights ship under a custom DeepSeek License Agreement with OpenRAIL- style use-based restrictions. "DeepSeek = MIT" is too simple — verify the specific model.
  • Phi = MIT across the Phi-4 family [verify] — genuinely permissive, commercial-friendly.
  • gpt-oss (OpenAI open-weight models, 20B/120B) = Apache-2.0 [verify] — permissive.
Commercial-use checklist (run before you ship)
  • Opened the exact model + size card and read its LICENSE / terms — not a blog, not this file.
  • Confirmed the class: OSI-open, custom-community, or restricted/non-commercial.
  • If custom/community: identified the conditions (attribution string, acceptable-use policy, MAU/revenue caps, downstream pass-through duty) and can meet them.
  • If restricted: confirmed you are not deploying commercially, or obtained a separate license.
  • Checked whether the model is gated (accept terms on the Hub before download).
  • Checked the base model license — a fine-tune inherits the base's obligations (a Llama fine-tune still owes "Built with Llama"; a distill can inherit the teacher's terms).

Deeper class breakdown, gated-model mechanics, and the fine-tune-inheritance trap: references/licenses.md.

Show full SKILL.md (785 more words)Show less

4. Size ↔ VRAM

A selection-time budget: will this size class even fit your hardware? (Operational per-request KV-cache math lives in ollama/vllm — this is the "before I pick it" estimate.)

text
weights_GB ≈ params(B) × bytes_per_param      # then add KV cache + runtime overhead on top
  fp16/bf16 → 2.0   (≈ 2 GB per 1B params)
  8-bit     → ~1.0  (≈ 1 GB per 1B params)
  4-bit     → ~0.6  (≈ 0.6 GB per 1B + cache + overhead; conservative ~0.5–0.6/param)

What that means per hardware class (weights only — leave headroom for context/KV cache):

Hardwarefp16 ceilingPractical pick (4-bit)
8 GB consumer GPU~3B7–8B at 4-bit (~5 GB)
16 GB~7B13–14B at 4-bit
24 GB (e.g. 3090/4090)~10B~32B at 4-bit (~20 GB)
80 GB (A100/H100)~34B70B at 4-bit (~40 GB), or a big-MoE like gpt-oss-120b
Apple unified (e.g. 64 GB)shares with the OSbudget against total unified memory
multi-GPU / 2×80 GB+70B fp16 (~140 GB) via tensor-parallelfull-precision large models

A 70B at fp16 is ~140 GB — it does not fit one GPU. You either quantize (4-bit ≈ ~40 GB, fits one 80 GB card) or split across GPUs with tensor parallelism (that's a vllm job). Longer context grows the KV cache on top of weights, so keep a margin. Full derivation + KV math: references/sizing-and-quant.md.

5. Quant / formats

Quantization shrinks weights (fewer bits/param) to fit smaller hardware, trading a little quality. Which format you pick is driven by your runtime:

FormatWhere it runsUse it for
GGUFllama.cpp, Ollama, LM StudioCPU, Apple Silicon, single-box local; the everyday local format
AWQvLLM, TGI, transformersGPU serving — activation-aware 4-bit, strong quality/latency
GPTQvLLM, TGI, transformersGPU serving — older, widely available 4-bit
bitsandbytes (NF4)transformersquick load-time 4/8-bit for experiments/fine-tuning
EXL2ExLlamaV2flexible bit-rates on consumer GPUs

Decoding a GGUF quant tag like Q4_K_M: Q4 = ~4-bit weights; _K = a k-quant (mixed precision — keeps the more sensitive tensors at higher bit-depth); _M = the medium size/quality tier (_S smaller/lower, _L larger/higher). Q4_K_M is the standard default — roughly half the memory of fp16 for a few percent quality loss. Q8_0 is near-lossless (~1 byte/param); below Q4, quality drops off fast. Don't go sub-Q4 to force a too-big model onto a too-small box — pick a smaller model instead. More in references/sizing-and-quant.md.

6. Where to get it + how to run it (routing)

You've chosen a model and cleared its license. Now hand off — this skill stops here.

  • Get the weights / host on HF → huggingface (Hub download/upload, Inference Providers, endpoints). Also where you convert to GGUF.
  • Run it locally on one box (laptop/desktop, GGUF via Ollama) → ollama.
  • Serve it at throughput / with tensor-parallel (production, batching, big models) → vllm.
  • Fine-tune it (LoRA/QLoRA, SFT, preference tuning) → finetuning.
  • Prove the small model is enough before committing → agent-eval.

The Hub filters (task + license + size + recent downloads) and the Ollama library are where you actually find candidates — that mechanics lives in huggingface / ollama, not here.

Guardrails / gotchas

  • Never assert a license from memory. State the class, open the card. Licenses change per version, per size, and per release month.
  • "Open weights" ≠ "open source" ≠ "commercial-use OK". Three different things.
  • A fine-tune inherits its base license. Fine-tuning Llama does not launder away "Built with Llama" or the acceptable-use policy; a distill can inherit the teacher model's terms.
  • Gated ≠ restricted. Gemma/Llama are gated (accept terms to download) yet usable commercially under their conditions; a "research-only" card is restricted regardless of gating.
  • Don't sub-Q4 a too-big model onto a too-small GPU. Quality collapses and it still may OOM at real context. Choose a size that fits.
  • Newest ≠ best for you. The smallest model that passes your eval wins on cost, speed, and fit.
  • MoE total vs active params. A "120B" MoE may activate only ~5B/token (fast) but you still need VRAM for all experts — size against total params, not active.
  • huggingface — get/host: Hub download/upload, Inference Providers, endpoints, GGUF conversion. This skill tells you which repo to pull; huggingface pulls it.
  • ollama — run one model locally (GGUF, single box, VRAM sizing at request time). This skill says which model + quant class fits; ollama runs it and does the KV-cache math.
  • vllm — serve at throughput, batching, tensor-parallel for models too big for one GPU.
  • finetuning — adapt a chosen base with LoRA/QLoRA/SFT. Choose+clear the base here first.
  • Boundary: this skill is selection + licensing knowledge only. It never re-teaches calling, running, serving, or training — it feeds those four.

Checklist

  • Named the task and matched a family designed for it (chat/code/reasoning/vision/embeddings/edge).
  • Picked the smallest size likely to pass the eval, and confirmed it fits the hardware class.
  • Identified the license class (OSI-open / custom-community / restricted).
  • Opened the exact model + size card and confirmed the license — not from memory, not from a blog.
  • For commercial use: met the conditions (attribution, acceptable-use, MAU/revenue caps) or confirmed permissive.
  • Checked the base model license if it's a fine-tune/distill.
  • Picked a quant format matching the runtime (GGUF local / AWQ-GPTQ serving) and a sane tier (Q4_K_M default).
  • Handed off: huggingface (get), ollama (run local), vllm (serve), finetuning (adapt).

© ericrisco, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (references) in skills/open-weights of ericrisco/rsc-harness.

  • SKILL.md
  • evals/README.md
  • evals/cases.yaml
  • references/licenses.md
  • references/model-families.md
  • references/sizing-and-quant.md

Open the folder on GitHubat commit e3d5b33

Compare with similar skills

Open Weights 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.

Open Weights compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Open Weights this skillericrisco/rsc-harness167—~4.1kAutomated safety check: PassMIT
Add Modelguoqingbao/xinfer333—~4.2kAutomated safety check: NotesMIT
Resolvealexziskind1/model-shelf130—~792Automated safety check: PassMIT
SageMaker Serving Image Selectionhuggingface/skills11k1 repos~4.6kAutomated safety check: PassApache-2.0
Hugging Face LLM Trainerhuggingface/skills11k3 repos~7.2kAutomated safety check: PassApache-2.0
Hugging Face Local Model Evalshuggingface/skills11k2 repos~1.6kAutomated safety check: PassApache-2.0

Similar skills

  • Add Model

    guoqingbao/xinfer

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

    333 GitHub stars~4.2k tokensUpdated 28 days 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

  • SageMaker Serving Image Selection

    huggingface/skills

    Official

    Chooses the right serving container and current image URI for deploying a Hugging Face model to a SageMaker endpoint, preferring Hugging Face images over generic ones.

    11k GitHub starsUsed in 1 repo~4.6k tokens
    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 3 repos~7.2k tokens
    AI & LLM EngineeringAuto-check passed

  • Hugging Face Local Model Evals

    huggingface/skills

    Official

    Runs evaluations of Hugging Face Hub models on local hardware with inspect-ai or lighteval, and helps choose between vLLM, Transformers and accelerate backends.

    11k GitHub starsUsed in 2 repos~1.6k tokens
    AI & LLM EngineeringAuto-check passed

  • Check Model

    guoqingbao/xinfer

    Check model compatibility with xinfer before loading. An agent skill from guoqingbao/xinfer.

    333 GitHub stars~3.8k tokensUpdated 28 days ago
    AI & LLM EngineeringAuto-check passed

More from ericrisco/rsc-harness

All 227 skills in this repo

  • Ab Testing

    ericrisco/rsc-harness

    A skill your agent uses when designing or analyzing a controlled experiment — falsifiable hypothesis, sample size from an MDE, reading significance/CI/power, CUPED, or rescuing tests that won't go…

    167 GitHub stars~2.4k tokensUpdated today
    Auto-check passed

  • Accessibility

    ericrisco/rsc-harness

    A skill your agent uses when making a web UI conform to WCAG 2.2 Level AA — axe-core or Lighthouse a11y violations, keyboard operability, focus management, ARIA roles/names/live regions, contrast…

    167 GitHub stars~3.4k tokensUpdated today
    Auto-check passed

  • Ads

    ericrisco/rsc-harness

    A skill your agent uses when running or fixing paid acquisition on Google or Meta — campaign structure (Performance Max, Demand Gen, Search, Advantage+), platform-fit creative, budget/scaling rules…

    167 GitHub stars~2.2k tokensUpdated today
    Auto-check passed

  • Agent Eval

    ericrisco/rsc-harness

    A skill your agent uses when measuring whether an LLM or agent system actually got better and gating merges on it: golden sets, fixing an inflated LLM-as-judge, scoring RAG (faithfulness, contextual…

    167 GitHub stars~3.2k tokensUpdated today
    Auto-check passed

  • AI Media

    ericrisco/rsc-harness

    A skill your agent uses when a creative goal must become a finished media file: pick and order generative-media models per modality — AI voiceover, image-to-video clips, score — then glue them with…

    167 GitHub stars~3.3k tokensUpdated today
    Auto-check passed

  • Analytics

    ericrisco/rsc-harness

    A skill your agent uses when instrumenting product or web analytics — GA4/PostHog SDK wiring, event taxonomy, funnels, double-counted events, consent gating, PII scrubbing.

    167 GitHub stars~2.8k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Open Weights

What does Open Weights do?

A skill your agent uses when choosing an open-weight LLM and clearing it for use — which family and size fit the task, the hardware and the budget, and above all whether the license permits shipping. Open Weights is an agent skill from ericrisco/rsc-harness. Use when choosing an open-weight LLM and clearing it for use — which family and size fit the task, the hardware and the budget, and above all whether the license permits shipping.

When should I use Open Weights?

Open Weights fits situations like: choosing an open-weight LLM and clearing it for use — which family and size fit the task; the hardware and the budget; above all whether the license permits shipping.

How do I install Open Weights in Claude Code?

Run `npx skills add ericrisco/rsc-harness --skill open-weights -a claude-code`. Or copy the skill folder (skills/open-weights in ericrisco/rsc-harness) into .claude/skills/open-weights in your project. Claude Code loads it when a task matches its description.

How do I install Open Weights in Codex?

Run `npx skills add ericrisco/rsc-harness --skill open-weights -a codex`. Or copy the skill folder (skills/open-weights in ericrisco/rsc-harness) into .agents/skills/open-weights in your project. Codex loads it when a task matches its description.

Can I use Open Weights 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 ericrisco/rsc-harness --skill open-weights -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/open-weights, .gemini/skills/open-weights, .github/skills/open-weights and .opencode/skills/open-weights in your project.

What does Open Weights need to run?

SKILL.md names no scripts, command-line tools or credentials: Open Weights is instructions for the agent only.

Does Open Weights access the network?

SKILL.md names 2 domains. As links in the text: ai.google.dev and huggingface.co. This is read from the text; nothing was executed.

Is Open Weights 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 Open Weights use?

Open Weights is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Open Weights use?

About 4.1k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.2k tokens, read only when the agent opens those files.

What are the alternatives to Open Weights?

Skills that share tags, products or a category with Open Weights: Add Model (guoqingbao/xinfer, 333 stars), Resolve (alexziskind1/model-shelf, 130 stars), SageMaker Serving Image Selection (huggingface/skills, 11k stars) and Hugging Face LLM Trainer (huggingface/skills, 11k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Open Weights?

ericrisco (a GitHub user) maintains it in ericrisco/rsc-harness, which has 167 GitHub stars. The repository holds 227 skills in this directory. The repository was last updated on October 7, 2026.

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