MeshVault
4,418 skills,
and the command that counts them.
A skill is a Markdown file with instructions for one job. They sit on the node's disk and are pulled in one at a time, so a model reaches for the one it needs without carrying the other 4,417 in context.
Count it yourself.
The number is the claim most likely to be checked by the audience this page is for, so here is the command that produces it. Run it against the library root:
cd ~/.meshvault/skill-library/current
find . -mindepth 3 -maxdepth 3 -name SKILL.md -type f -printf '%h\n' \
| sed 's|.*/||' | sort -u | grep -vc skillspectorThat is distinct skill names at depth two, with the adversarial test fixtures excluded. It returned 4,418 at 03:29Z on 2026-07-27, and again when this page was written.
Two other counts exist for the same directory, and both are larger. Neither belongs in a sentence about capability.
| Rule | Returns | What it actually counts |
|---|---|---|
Every SKILL.md at any depth | 13,477 | Counts a skill's own reference and example files as skills. Roughly three times over. |
| Directories at depth two | 5,255 | Counts mirrors twice. About 800 names exist in two roots at once. |
| Distinct names, fixtures excluded | 4,418 | The one to use. |
The library drifts by a few skills an hour while agents write to it, so any figure is a timestamp rather than a constant. Say which rule produced it and give the date, or the number means nothing.
The router binary reports its own usable_estimate, which is the all-depth walk wearing a trustworthy name. It is not what the count above measures and it is not what the product publishes. One find disproves it, in front of exactly the people most likely to run that find.
Three arms, fused on rank.
No vector database. The whole stack is TypeScript in the repository, and it runs on the node.
Dense
Embeddings from Ollama, L2 normalised on the way out so similarity at query time is a plain dot product. Stored as binary Float32 shards, 2,000 chunks each, with JSON sidecars.
Search is a linear cosine scan across every shard. The source marks the revisit point at about 200,000 chunks.
Lexical
BM25 built in process over the vault's Markdown, k1 1.2 and b 0.75. The tokenizer keeps identifiers whole and split, so agents:stripe-best-practices yields the whole form plus its parts.
The stoplist is 26 words, deliberately tiny, because this corpus is full of short meaningful tokens.
Skill router
A subprocess call to the router binary. Measured at 42ms standalone and 240ms or worse from inside the server under load, which is why retrieval caps it at three calls per query and caches results for 60 seconds.
Every call is capped at 15 seconds. A body comes back capped at 40,000 characters.
The three result lists are combined with reciprocal rank fusion at k = 60. Rank-based fusion lets a cosine in the range minus one to one and a BM25 score in the range zero to thirty combine without calibrating either.
One rule sits above the fusion: for an identifier-shaped query, an exact literal match is placed ahead of the fused order entirely. That is a measurement, not a preference. Across twelve identifier queries the lexical arm answered twelve out of twelve at rank one and the dense arm answered six; letting agreement reorder a literal match dropped mean reciprocal rank from 1.000 to 0.656.
It refuses rather than guesses.
Retrieved chunks pass a floor on the dense cosine, default 0.60, set against 20 in-corpus probes, 5 out-of-corpus probes and 4 gibberish probes. What survives is packed into a 6,000 character budget that charges the whole emitted block rather than only the chunk text.
Ordering within that block puts the strongest evidence at the top and the bottom and buries the weakest in the middle, which is where a long context is least reliable.
When nothing clears the floor, the answer is a deterministic refusal written by the retrieval layer. Asking a model to admit it has no context is a request it can decline, so the code does not ask.
Lexical-only hits carry a score of zero into that gate on purpose. A document the embedder never scored has no cosine, and inventing one would corrupt a gate that exists to refuse.
Slugs, not sentences.
The router matches path substrings. It does not do natural language. invoice returns nine results; "chase an overdue invoice" returns nothing at all, even though the skill exists. Search single words and slugs.
Fetching a skill returns one body, and only when you ask for it. Nothing preloads the library, nothing bulk-copies bodies into context, and there is no stale cache to fall back on when the router is unreachable. A missing router binary is reported as an error rather than an empty result, because a silent empty list reads like "no such skill".
The library above is what runs on a node. The $49 Agent Skills Starter Pack is a separate thing: 35 editable Markdown files that work on the agent setup you already run. It is the one purchasable item on this site today.