Hugging Face Model Finder
Recommends AI models by task, benchmark performance, and available device memory.
The skill explicitly reads a local Hugging Face token and sends it in an Authorization header to external APIs, creating credential-exposure and external data-flow risks. It does not require user confirmation or document sensitive-data handling, least privilege, isolation, rollback, or source validation, so points are deducted. No malware, covert exfiltration, or destructive default is evident.
The steps are broadly coherent and include device budgeting, leaderboard failures, and missing model metadata fallbacks. However, they depend on curl, jq, a token, hf-cli, and specific API endpoints without tests, version pinning, timeout/retry policy, response validation, or diagnostic failure messages; under static calibration the score remains at or below 10.
Trigger phrases, task categories, device inputs, and clarification behavior are reasonably clear. Non-fit boundaries, false-trigger constraints, and Chinese-language handling are not specified, and the core workflow depends on Hugging Face services whose mainland-China reachability is not established, so points are deducted.
The document has useful stepwise organization, parameter rules, examples, an output template, and error handling. Repository context supplies Apache-2.0 licensing, CI validation, and a security-reporting channel. The skill itself lacks versioning, changelog, explicit maintenance ownership, update path, and FAQs, and references a missing “curated fallback table,” so points are deducted.
When the leaderboard APIs work and return the expected schema, the workflow can produce a model comparison table and account for device capacity. The output still requires manual validation; benchmark selection, result authenticity, licensing, and runnability are not verified, the fallback is incomplete, and follow-up behavior requires additional judgment, so the static score is below the cap.
The skill provides concrete API commands and fields, and repository CI validates generated artifacts, but there are no committed tests covering this skill’s key paths, execution evidence, or independent corroboration. Evidence is therefore limited to auditable source text; under static calibration the score is at or below 5.
- Obtain confirmation before reading and transmitting the local Hugging Face token, and ensure sensitive user data is not included in queries.
- Hugging Face APIs, leaderboard endpoints, and schemas may be unavailable or change; validate responses, benchmark provenance, licenses, and scores before making recommendations.
- The workflow depends on overseas Hugging Face services; confirm reachability for mainland-China users and provide a usable offline or unavailable-service alternative.
- The referenced curated fallback table is absent from the supplied file, so that fallback path may not be directly executable.
What does this skill do, and when should you use it?
This skill handles requests for the best model, model recommendations, and model comparisons. It searches official Hugging Face benchmark datasets, collects leaderboard results, and enriches candidates with parameter-size and license metadata. When a device is specified, it estimates fp16 and Q4 parameter limits from available memory and filters candidates accordingly. It returns a comparison table with benchmark scores, model size, license, and device fit.
Parses the requested task and device constraints; calls the Hugging Face datasets API to list official benchmarks; queries relevant leaderboards for leading models and scores; uses the model API or hf-cli to obtain parameter size, tags, and model-card data; filters by device memory and ranks by benchmark score, returning the top 5–8 models. Unavailable leaderboards are skipped and noted; if all leaderboard requests fail, it falls back to popularity-based model search.
- A developer needs to choose a strong model for code generation and compare benchmark scores.
- A MacBook, RTX GPU, or CPU user needs models that fit local memory constraints.
- A researcher wants to compare candidates for math, reasoning, OCR, retrieval, or speech-recognition tasks.
- A team needs to narrow model choices using parameter size, license, and leaderboard performance.
What are this skill's strengths and limitations?
- Covers request parsing, official benchmark lookup, model metadata enrichment, and device-fit filtering.
- Defines fp16 and Q4 parameter budgets and can retain highly ranked models that are slightly over budget with a quantization note.
- Provides fallback behavior for leaderboard errors and complete leaderboard failure.
- Requires network access, `curl`, `jq`, and a Hugging Face access token.
- Results depend on relevant official leaderboards being available and accessible.
- The source does not provide a test suite, independent performance validation, or a standalone installation workflow.
How do you install this skill?
The README does not document a standalone installation command for this skill. With Codex, copy or symlink skills/huggingface-best into a standard .agents/skills location, such as .agents/skills in the repository or a user-level .agents/skills directory. With Claude Code, register huggingface/skills as a plugin marketplace and follow the repository instructions to install or add the skill.
How do you use this skill?
After installation, ask a concrete model-selection question, for example: Recommend a model for code generation on my 16GB MacBook and compare the benchmark scores. If no device is specified, the skill skips size filtering and prioritizes high-performing models; it asks one clarifying question when the task is genuinely ambiguous.