Your Agent Is Smart. It Just Doesn't Know Your System.

There is a particular kind of expensive afternoon that anyone running coding agents will recognise.

The agent is good. It reads the code correctly, forms a sensible hypothesis, tests it, and reports back with confidence. Everything it did was reasonable. And it was wrong for a reason nobody could have inferred from the code — the build cached a layer, the container was running a file it imported forty minutes before your edit, the healthcheck was green because it never touched the broken path.

You lose the afternoon. Then next week, in a fresh session, a fresh agent walks into the same trap with exactly the same confidence.

That is not a capability problem. It is an amnesia problem. And it is the one thing that gets worse as models get better, because a faster agent re-derives a wrong conclusion faster.

What a skill actually is

A skill is a short document that loads into an agent's context at the moment it becomes relevant — triggered by the shape of the task, not by someone remembering to paste it.

That timing is the whole trick. Documentation nobody opens is worth nothing. A rule in a style guide is worth nothing at 2am. A skill fires when the agent is about to run docker compose up, or about to claim a fix is deployed, or about to conclude a service is down — the exact instant the knowledge changes what happens next.

aither-skills is MIT-licensed and installs in about ten minutes. It's the residue of running a real platform — 260 services, ~166 containers, three repos — with agents doing most of the typing, across 27,939 prompts and 3,183 sessions over 210 days, re-measured on a disjoint 34-day window so the numbers aren't a happy accident.

Here is every one of them.

---

Start here: get an agent running on your own machine

aither-start — zero to a working agent for someone who has never written code. Detects your hardware, installs the toolkit, downloads a model sized to what you actually have.

install-skills — installs this pack into whatever you already use: Claude Code, OpenClaw, Hermes, Cursor, Goose, Codex, Gemini CLI, or anything Agent-Skills-compatible. Start here if you already have an agent you like.

aither-adk — your own AI agent, on your machine, in three commands.

openclaw — install the local-first personal assistant and point it at a local model instead of a paid API.

tau — a minimalist terminal coding agent in Python, pointed at your own model via a local catalogue.

hermes-agent — Nous Research's self-improving agent: persistent memory, autonomous skill creation, cron automation, running on your model.

deer-flow — ByteDance's LangGraph super-agent harness for autonomous research, coding and content, with sub-agents and persistent memory.

ods — one installer that turns a PC, Mac or Linux box into a private AI server with local inference and a chat surface.

Run models on hardware you already own

local-inference — the decision you get wrong first: which backend (Ollama, llama.cpp, vLLM) suits the machine you actually have, not the one in the benchmark.

bonsai-27b — run a 27B model in ~3.8 GB on a plain CPU box. No GPU.

model-quantization — 4-bit with AutoRound, free on local CPU+GPU. Keeps lm_head/projectors in bf16 and dodges the new-architecture crashes that make naive quantization fail.

split-inference — shard one model across multiple machines' GPUs with llama.cpp RPC. Two half-sized boxes become one that fits the model.

gpu-vram-attribution — one GPU, a dozen containers, something is starving, and every per-process API lies to you. On Windows/WSL2 nvidia-smi returns [N/A] for every process and the OS sees your whole fleet as one VM worker. That negative result costs a day to establish and is documented nowhere. Then: the technique that does work.

aithernode — turn a machine's hardware into something your agents can actually reach and use.

omninode-node — join the OmniNode P2P inference mesh in one command.

How to work with agents — the doctrine

This is the part most people skip and then pay for.

code-like-david — the measured operating doctrine for running an agentic tool at program scale: prompt shape, live-proof gates, plan documents, persistent memory. Derived from the telemetry above, not from taste.

ramble-driven-development — stop writing careful prompts. Ramble to load intent, poke to steer, and put the precision in the harness instead. Counter-intuitive, and it's the measured prompt-shape law behind the rest.

adversarial-verification — the antidote to the single most expensive agent failure: reading your own diff, deciding it's correct, reporting success. A green healthcheck, an HTTP 200 and a passing import can all be true while the feature is completely inert. More care doesn't fix that. Structure does.

prove-it-live — the verification standard. Green tests, a 200, and "deployed" are not proof. Demand a check that can fail, hunt the silent no-op, and refuse to call something done on evidence that couldn't have come out any other way.

aither-agent-notebook — turn "build X" into a reviewable, re-runnable plan instead of a wall of output nobody audits.

repo-is-not-a-runtime — the architecture doctrine for agent-driven repos. What's in the repo is not what's running, and organising around that fact changes how you lay code out.

debt-ledger — a tech-debt ledger that actually gets written to: severity tables, collision-free ids, and the discipline that stops it becoming a write-only archive.

concurrent-safe-git — committing in a worktree you do not have to yourself, when several agents and a maintenance loop are all editing at once. Contains two commit forms that are each safe against a different hazard and each re-expose the other one.

resume-all — snapshot your sessions before a reboot and restore them after, as terminal tabs or tmux windows.

Make agents smarter about your codebase

aither-codegraph — a call-graph-aware code index your agents can query, instead of grepping and guessing.

aither-prospector — a semantic file-explorer that tells an agent where to look before it burns context looking.

aither-code-intelligence — stand up agent code-search, and prove it actually works rather than assuming the index is populated.

graph-a-repo — turn a repo or knowledge base into a graph an agent can answer from: pick the right embedder, ingest, and prove both halves work.

graph-rag-agent — build the knowledge graph and the agent that owns it.

aither-headroom — cut token cost with reversible context compression. Reversible is the load-bearing word.

Infrastructure that bites, and how it bites

docker-network-ops — diagnose container DNS without fooling yourself. Contains the measurement traps that each produced a confidently wrong root cause.

docker-wsl2-build-safety — stop bulk builds from killing Docker Desktop, and don't blame the disk.

docker-wsl2-disk-reclaim — your drive is full and docker system df is lying to you.

recover-docker — hard-recover Docker Desktop from the WSL2 wedge (API 500, "did not receive an exit event") and bring the exited containers back.

agent-disk-hygiene — your coding agents are quietly eating your disk.

event-loop-debugger — detect, pin and fix asyncio event-loop stalls: a sync call or CPU-bound work blocking the loop, including on free-threaded builds. On a single-loop service this isn't "slow", it's an outage for every concurrent request.

performance — find the bottleneck rather than the thing you assumed was the bottleneck.

Security and release hygiene

fail-closed-authz — six auth/tenancy/entitlement defect classes that ruff and mypy structurally cannot see because they're semantic. A gate returning True in its exception handler. An identity read from the request body instead of the verified session.

security-audit — audits across code, dependencies and configuration.

secretguard — scan for leaked secrets and purge them from git history.

moat-guard — open-core release hygiene: verify a build doesn't leak private code before publishing, and purge what already shipped.

dependencies — updates, vulnerabilities, and the tree.

Ship it

ship-an-app-free — idea to a working app at a public URL on free tiers only: Pages for the site, Actions for the build, a free serverless backend.

repo-to-website — turn any repo into a real website with a proper landing page, instead of a raw README.

website-as-code — Pages frontend + Cloudflare Tunnel backend on any machine, with an automated never-show-a-raw-error fallback. $0/month.

aitherzero — provision any machine from one config file and a library of numbered automation scripts.

hetzner-fleet — provision bare metal and VPS straight into your mesh.

aithermesh — stand up a private mesh and onboard nodes and agents onto it.

aitherconnect — wire your machine, agent and browser into the platform.

compare-versions — structural and behavioural diffs between two versions of a file, commit or release.

refactor — structure, readability, maintainability, with the extract/rename/optimise paths spelled out.

---

Why this beats a longer prompt

The instinct is to put it all in a system prompt. It doesn't work, for three reasons.

Context is a budget. Fifty-one skills of standing instructions is a context window spent before the agent reads a single file. Skills load on relevance — the GPU one is absent until there's a GPU problem.

Relevance beats volume. A rule buried at line 400 of a mega-prompt competes with 399 others. The same rule, surfaced precisely when the agent reaches for docker compose, is the only thing in view.

Knowledge has to be revisable. When a trap turns out subtler than you thought, you edit one file and every future session inherits the correction. We rewrote a git rule mid-session this week after it caused the exact failure it was meant to prevent — the fix was one paragraph, and it caught a real collision on its very next use.

The part that makes them trustworthy

Every claim is measured. Not "this is slow" — p99 was 1014ms on TCP versus 0.17ms on UDP, same names, same moment. Not "check your DNS" — 13 of 40 lookups failed from four containers over several hours while the alternative resolver was 40/40.

That matters more than it sounds. An agent reading a vague warning hedges, or ignores it. An agent reading a number acts on it. And a skill with real numbers in it is one you can falsify — if the measurement stops being true you find out, and you fix the skill instead of quietly building on sand.

Several of them also document a fix that was tried first and was wrong, and why. The wrong fix is usually the obvious one, and an agent that only sees the final answer will propose the discarded one again.

Ten minutes

git clone https://github.com/Aitherium/aither-skills

Take all 52, or the four that match your stack. They're written for Claude Code, and install-skills ports them to Cursor, Goose, Codex, Gemini CLI, OpenClaw or Hermes.

The models will keep getting better. They will not, on their own, start knowing that your build silently cached a layer, or that the container reporting healthy is running last week's code. That part is yours to hand them — and it only has to be learned once.

aither-skills is MIT-licensed and free. Contributions welcome, particularly measurements that contradict ours.