MCP Server Rot: How to Vet Any 'Best MCP Servers for Claude Code 2026' List

By Rakshit Yadav (@yadavrakshit60)•Oct 2026•9 min read

Short answer: don't trust a "best MCP servers for Claude Code" list just because it's dated 2026 — a roundup's publish date tells you when the article was written, not when the servers it recommends were last maintained, and those are increasingly different things as the MCP ecosystem has filled with community packages that shipped once and stalled. Before you run claude mcp add on anything from a list, check the thing itself: is it archived, when did it last get a commit, and is there a first-party maintainer behind it (Anthropic, GitHub, Microsoft) or a solo contributor who moved on. This post is the vetting method, not a dated snapshot — because the honest version of a freshness audit expires the moment it's published, and the check below stays useful long after this specific list does.

Why "best MCP servers" lists go stale fast

MCP server roundups have the same structural problem every "best tools" listicle has: they're written once and read for months, while the thing they're describing keeps changing underneath them. A few forces make MCP servers specifically prone to rot:

  • Repos get archived without the roundup noticing. A maintainer moves a server's functionality into a different package, or a company that shipped a reference server quietly stops maintaining it once the use case it was built for shifts. The GitHub repo still exists and still shows up in search — it just stops getting commits.
  • Community servers are often one person's side project. Unlike the official Anthropic, GitHub, or Microsoft-maintained servers, a lot of the long tail of MCP servers covering niche SaaS tools were built by an individual contributor for their own stack. When that person moves on, there's often no second maintainer to pick it up.
  • The MCP spec itself is still evolving. A server built against an earlier version of the protocol can keep technically working for a while, then silently break (or get rejected by a newer client) once Claude Code or Anthropic ships a spec change the server never adopted.
  • Roundups copy each other. A server that made one popular "best of" list two years ago tends to keep appearing on new lists because it's the recognizable name, not because anyone re-checked whether it's still the right pick. That's the specific failure mode worth guarding against here.

None of this means every list is wrong — it means a list is a starting point for research, not a substitute for it.

The audit: how to actually check before you trust a recommendation

You don't need a dashboard or a third-party service for this. Three checks, each of which you can run from the terminal in under a minute per server, cover almost everything that matters.

1. Is the repo archived? GitHub shows an "Archived" banner on the repo page itself, and you can check it programmatically too:

gh api repos/<owner>/<repo> --jq '.archived, .pushed_at'

If .archived comes back true, stop — an archived repo isn't getting security patches or protocol updates no matter how good the server used to be.

2. When was the last commit, and does it match the project's claimed activity? pushed_at from the same gh api call above gives you the actual last-push timestamp. A server with no commits in over a year isn't automatically broken, but it's a server nobody is actively testing against the current Claude Code and MCP spec versions — treat anything past roughly 6–12 months of silence as "verify it still works before depending on it," not "install and trust."

3. Who's actually maintaining it? Check the repo's organization, not just the README's claims. A server under github/, microsoft/, or modelcontextprotocol/ (the official reference-servers org) carries institutional maintenance you can reasonably expect to continue. A server under a personal GitHub handle with one contributor and no issues activity is a different risk profile — not necessarily bad, but something you're choosing to depend on a single person continuing to care about.

Run all three before adding anything new, and re-run the first two periodically for servers you're already depending on — claude mcp list shows what's currently connected, so pair that with a quick gh api loop over your connected servers' repos as a cheap recurring health check.

What tends to stay maintained, and why

The pattern that falls out of the three checks above is less about any specific server name and more about who's behind it:

  • First-party servers from the companies that own the product (GitHub's own MCP server for GitHub, Microsoft's Playwright MCP for browser automation) tend to stay maintained because the server is part of that company's own product surface — letting it rot would mean shipping a broken integration under their own name.
  • Anthropic's reference servers (filesystem, memory, and similar) get maintained as part of the core MCP ecosystem Anthropic ships and documents, which gives them a longer expected shelf life than a community equivalent covering the same job.
  • Community servers wrapping a well-funded SaaS product's API (Stripe, Supabase, Sentry, Vercel) tend to stay healthier than niche community servers because either the SaaS company itself has started maintaining an official one, or there's enough collective demand that abandonment gets noticed and forked quickly.
  • Niche, single-maintainer servers for smaller or less-used tools are the highest-risk category by a wide margin — not because they're poorly built, but because there's no institutional or community pressure keeping them current once the original author's attention moves elsewhere.

The practical rule: weight "who maintains this" as heavily as "what does this do" when you're picking between two servers that cover the same job. AgenticKit's write-up on the core five servers most solo founders install first — Stripe, Supabase/Postgres, GitHub, Playwright, Sentry — leans toward exactly this category of well-backed, actively-used servers, and the follow-up on backend, ops, research, and memory servers applies the same "pick by job, not by popularity" logic one layer further out.

A vetting checklist before you wire any MCP server into Claude Code

CheckCommand / where to lookRed flag
Archived statusgh api repos/<owner>/<repo> --jq '.archived'true
Last commitgh api repos/<owner>/<repo> --jq '.pushed_at'More than ~6–12 months old
Maintainer orgGitHub repo owner/orgPersonal account, single contributor, no recent issue responses
Open issues signalRepo's Issues tabPile of unanswered issues referencing the same break
Permission scopeThe server's own docs for required API keys/rolesAsks for broader access than the job needs (e.g. full-admin DB creds for a read-only query server)
Protocol versionServer's package.json / READMEReferences an MCP spec version visibly older than current

Run this before adding a server from any list — including this post's own references to other servers, and including any list you find after this one. The MCP checker tool in AgenticKit automates the connected-server side of this (what's currently wired into your Claude Code setup versus what your installed agents expect), though the archived/last-commit check above is still worth doing by hand against the live GitHub API, since that's ground truth no cached tool can fully replace.

Scoping and credential hygiene matter as much as freshness — a server that's actively maintained but holds broader API access than its job requires is still a risk. The security-basics skill and the security-auditor agent in AgenticKit's kit are built for exactly this kind of review: least-privilege checks on anything with live API or database access, MCP servers included.

FAQ

Is an archived repo always unsafe to use? Not unsafe in the sense of actively malicious, but risky in the sense that no one is patching it against new vulnerabilities or adapting it to spec changes. If a server does exactly one narrow job, is archived, and you've read the (short, stable) code yourself, it may be fine to keep running — but that's a deliberate choice, not a default.

Why not just trust official "best of" roundups that claim to be updated regularly? Many genuinely are kept current, but "updated regularly" usually means the article's prose gets refreshed, not that every linked repo gets re-checked against the GitHub API each time. Treat any list — including this one — as a shortlist to verify, not a final answer.

How often should I re-check servers I already have connected? A quick pass every month or two is enough for most solo-founder stacks — claude mcp list to see what's connected, then a gh api check against each repo's archived and pushed_at fields. It takes a few minutes and catches rot before it becomes a debugging session.

Does this apply to Cursor's MCP setup too? Yes — MCP is an open protocol, so the same archived-repo and last-commit checks apply whether a server is wired into .cursor/mcp.json or added via claude mcp add. The vetting method doesn't change with the client.

What's the single highest-leverage check if I only have time for one? The archived flag. It's a binary, unambiguous signal, it takes one gh api call, and it catches the worst case (a dead project still showing up in search and roundups) outright.

Related Tools & Agents

🛠️ Free Tool: mcp-checker🛠️ Free Tool: kit-picker🤖 Agent: security-auditor🤖 Agent: sre-engineer⚡ Command: /shipSkill: security-basics

Know what's actually connected before you trust it

The MCP checker audits your connected servers against what your installed agents expect — pair it with the archived/last-commit checks in this post.

Try the MCP checker →