// post

· 7 min read

Keepup: I handed my agent setup maintenance to the agent itself

// My coding agent setup is a pile of skills, MCP servers, plugins, hooks, and helper CLIs, each with its own update path and its own way of quietly going stale. I audited it by hand for far too long before it occurred to me that the agent could do the audit, so I wrote keepup, an open-source Agent Skill that inventories the setup, checks every item against its source, and applies only the fixes I approve.

// contents
  1. The chore I kept doing by hand
  2. The obvious thing I missed
  3. The skills repo
  4. How keepup works
  5. What it does not solve

My agent environment has grown into a small estate. Claude Code itself, a handful of skills from different sources, several MCP servers launched three different ways, plugins from a couple of marketplaces, hooks that call helper CLIs, a status line, and instruction files at user and project level. Every one of those things has its own release cadence, its own update command, and its own way of going quietly out of date.

Keeping it current was a chore I did by hand, and I kept doing it by hand for longer than I like to admit.

The chore I kept doing by hand

There is no single “update everything” button for an agent setup, because there is no single owner. Skills installed with the skills CLI update with npx skills update. Hand-copied skills update when you remember where you copied them from. An MCP server launched with npx -y pulls the latest on each start (unless the npx cache holds it back), one launched with uvx has its own cache, a pinned one stays pinned forever, and a local binary has its own upgrade subcommand. Plugins need their marketplace refreshed before the version comparison even means anything. The agent updates itself, mostly, unless an environment variable has turned that off.

Versions are the easy part, though. The expensive part is deprecation, because nothing breaks on the day it happens. A good example is the batch of reference MCP servers (GitHub, Slack, Brave Search, Puppeteer, PostgreSQL and others) that were moved to the archived modelcontextprotocol/servers-archived repo: npm marks them deprecated, they keep launching, and the replacement lives under a different name entirely. The same goes for an MCP server still configured with the deprecated HTTP+SSE transport, a settings key like includeCoAuthoredBy that Claude Code replaced with attribution, a retired model ID in a config file, or a line in CLAUDE.md pointing the agent at a tool that is no longer installed. None of these throw an error. They just sit there being wrong.

This is fine meme: the dog sits in a burning room under the label "nothing is throwing an error" and says "This is fine."
An archived MCP server still launches. The only signal is a deprecated flag in npm metadata nobody reads.

So, periodically, I went through the list. Run claude --version and compare it with npm. Run npx skills check. Open ~/.claude.json, read each MCP entry, look up each package on npm or PyPI, check whether its repo was archived. Read the changelog for anything renamed. Skim settings.json for keys that look old. It was tedious, and I was never sure I had covered everything.

The obvious thing I missed

Here is the embarrassing part. Every single step in that routine is something my coding agent is better at than I am. It has a shell. It can read config files in any format. It can call npm view, query PyPI, and ask the GitHub API whether a repo is archived. It can read a changelog faster than I can find the link to it. And it already knows where its own configuration lives, since it is the thing reading it.

I kept doing the agent’s housekeeping for it, by hand, while the agent sat in the next terminal tab waiting for work. Too dumb to see it earlier, plainly put. The job did not need a new tool. It needed written-down instructions that turn “check everything” into a repeatable procedure, which is exactly what an Agent Skill is.

Expanding brain meme in four stages: "Update nothing.", "Check versions by hand.", "Write a checklist.", and, with the brightest brain, "Give the checklist to the agent as a skill."
Keepup is stage four: the checklist lives in SKILL.md and references/checks.md.

The skills repo

I put it in a new public repository, lezli01/skills, which I intend to grow into a home for skills I write for my own work. Everything in it follows the open Agent Skills specification, so a skill is a folder with a SKILL.md (instructions plus frontmatter) and optional scripts/ and references/ that the agent loads only when the task calls for them.

Two rules hold for every skill in the repo. They are agent-agnostic: no dependence on one vendor’s features, and where a feature exists in only one agent the skill carries a fallback for the others. And they are cross-platform: helper scripts are plain Node.js, and CI runs the tests on Windows, macOS, and Linux, alongside a validator that checks each skill’s frontmatter, README, links, and discovery by the skills CLI. MIT licensed.

Keepup is the first skill in it, and its folder carries a README written for humans next to the SKILL.md written for the agent:

The lezli01/skills repository on GitHub, showing the skills/keepup folder with references, scripts, README.md and SKILL.md, and the rendered README describing the Deprecated, Stale, Update and Needs you statuses above the install commands
skills/keepup on the master branch. references/ holds the per-agent config map and the check rules; scripts/ holds the inventory script and its tests.

Installing keepup globally, so it runs from any project:

npx skills add lezli01/skills --skill keepup -g

The repo root is also a Claude Code plugin marketplace, so in Claude Code /plugin install lezli01 --marketplace lezli01/skills installs every skill in it, namespaced as lezli01:<skill-name>.

How keepup works

Keepup (currently 0.2.0) runs one pass in five steps: inventory, check, report, apply, verify. The first three are read-only. Nothing changes until I approve the report.

The inventory is a dependency-free Node script, scripts/inventory.mjs, which the agent runs with its own ID:

node <this-skill-dir>/scripts/inventory.mjs --agent claude-code

It prints JSON covering the agent’s version and install path (and duplicate installs), MCP servers, every skill the agent loads, skill lock entries, plugins and marketplaces, hooks and the status line along with the helper CLIs they call, configured models, instruction files, and leftover .bak or .tmp files. It redacts env values, headers, secret-looking args, and URL query strings, so no token ends up in the agent’s context or the report. The agent then cross-checks with its own listing commands (claude mcp list, claude plugin list), which can see managed config the script cannot.

The check step gives every item exactly one status, backed by evidence: a command’s output, a registry response, or a link to a changelog or deprecation notice. The statuses are Deprecated, Stale (no update exists, but the item no longer holds up: it duplicates something, points at something removed, or is cruft), Update, OK, and Unknown. Unknown is a valid answer; silently skipping an item is not. The skill tells the agent explicitly to verify every deprecation claim against a primary source, because its training data is out of date for exactly these facts. Items that need me (a restart, sudo, a sign-in, or a choice between replacements) are flagged as such.

What I get back is one numbered action list, and I answer with all, a list of numbers, or none. Then the apply step backs up every file it will touch to ~/.keepup-backups/<timestamp>/, and works in dependency order: helper CLIs first, then MCP servers, then skills and plugins, then config cleanups, and the agent itself last, because its update may need a restart. Removed files are moved into the backup folder, not deleted. Instruction files are only edited with approval of the exact change. Finally it re-runs the inventory and the checks for everything it changed and tells me what moved, what failed, and what is still waiting on me.

The scope is deliberately narrow: keepup audits only the agent it runs in. It knows the config layout of Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, Cursor, Copilot CLI, OpenCode, and Windsurf, and if it finds several of them installed it lists the others at the end of the report and suggests running it inside each one, rather than reaching into their config itself. The one exception is shared items, such as a skill in ~/.agents/skills or a helper CLI, which it updates because the running agent depends on them, but a removal or breaking change there always asks first.

What it does not solve

The honest catch is that keepup is itself a snapshot. Its references/agents.md documents where each agent keeps its config “as of 2026-11”, and agents move faster than any reference file. The skill handles this by telling the agent to trust its own --help and docs over the file when they disagree, and to note the difference in the report. That softens the problem without removing it, which is why keepup lives in a repo that npx skills update can pull from. The skill that keeps things current needs keeping current, and since it is installed like any other skill, it shows up on its own list.

Yo dawg meme with Xzibit laughing, captioned "Yo dawg, I heard your keepup skill goes stale, so it audits itself as the first item on its own list."
Strictly speaking it is not first: helper CLIs and MCP servers go before skills in the apply order.

It also costs a run’s worth of tokens and wall-clock time, and it needs network access to npm, PyPI, and GitHub. That is a fair trade against me opening config files one by one, and the agent is more thorough about it than I was.

The trade, named plainly: I give up some control over when and how the audit happens, and I get an audit that happens at all, with evidence attached to every finding. The rest of what I build is over at lezli01.is-a.dev.

// thoughts? reply by email

// comments

// comments load as you scroll here. They live in GitHub Discussions; sign in with GitHub to join in.

← all posts