akashi

akashi

RoninForge Akashi is an MCP server health checker that probes a Model Context Protocol server with only public, unauthenticated signals and reports whether it is healthy, degraded, or dead. It is MIT licensed, runs entirely on your machine, and requires no API keys.

Part of RoninForge.org, an independent open-source workshop that keeps dated, reproducible records of the AI developer tooling economy. Akashi is the tool that produces the State of MCP census.

It emits an embeddable "verified on DATE" badge for the healthy ones. Not affiliated with the AKASHI attendance service.

The name means "proof" or "certificate" (証) in Japanese.

Zero keys, by construction. akashi reads only public endpoints and never authenticates to a probed server, never runs one of its tools, and never sends a user secret to one. Why that holds and what it rules out: https://roninforge.org/akashi/

Install

curl -fsSL https://roninforge.org/akashi/install.sh | sh

Or with Go:

go install github.com/RoninForge/akashi/cmd/akashi@latest

Usage

akashi check <server>

<server> may be:

• an official-registry server name (io.github.owner/name)
• a GitHub repository URL (https://github.com/owner/repo)
• a remote endpoint URL (https://mcp.example.com/sse)

A healthy server that ships an npm package:

$ akashi check ai.adeu/adeu

ai.adeu/adeu  checked 2026-07-02 UTC, keyless

  PASS  registry status                 active
  PASS  server.json valid               validates against its declared JSON Schema
  PASS  repo reachable                  exists
  PASS  repo freshness                  pushed 0d ago
  PASS  package npm                     published (1.18.1)
  PASS  at least one live entrypoint    2 alive
  PASS  license present                 MIT

  OK    healthy

A healthy hosted server, with its tools listed over a full MCP session:

$ akashi check ac.tandem/docs-mcp

ac.tandem/docs-mcp  checked 2026-07-02 UTC, keyless

  PASS  registry status                 active
  PASS  server.json valid               validates against its declared JSON Schema
  PASS  repo reachable                  exists
  PASS  remote reachable                HTTP 200 via initialize
  PASS  MCP conformance                 initialize handshake ok
  PASS  tools/list                      13 tools: search_docs, get_doc, ...
  PASS  at least one live entrypoint    2 alive

  OK    healthy

A dead one:

$ akashi check io.github.akutishevsky/spotify

io.github.akutishevsky/spotify  checked 2026-07-01 UTC, keyless

  PASS  registry status                 active
  FAIL  repo reachable                  404 (repository gone)
  FAIL  remote reachable                unreachable
  FAIL  at least one live entrypoint    nothing installable or reachable

  DEAD  dead (nothing works)
     reasons: repo_404, remote_unreachable

Output formats

akashi check <server> --json     # the full result row, for scripts and CI
akashi check <server> --badge    # a shields.io endpoint badge JSON

Exit codes

Census: scan the whole registry

akashi scan runs the same keyless check set as akashi check against every server in the official MCP registry and writes a dated dataset.

akashi scan --out ./census              # the whole registry
akashi scan --out ./census --limit 500  # a sample

It writes two files into --out:

• records.jsonl - one probe result per server, one JSON line each. Each line is byte-identical to akashi check <server> --json, so any row is independently reproducible with a single-server check.
• summary.json - verdict counts and rates, a remote-bearing segment, name validation findings, and the run's reproducibility parameters.

A scan resumes automatically: rerun with the same --out and servers already recorded are not re-probed. Concurrency, the per-server timeout, and the server count are tunable with --concurrency, --timeout, and --limit.

A long scan is not a snapshot

A full census takes hours, and over a window that long a single operator's outage lands in the data as if it were a property of its servers. Point --compare at the previous census and a second pass re-probes every namespace whose aggregate signal rates moved against it:

akashi scan --out ./census-2026-09-09 --compare ./census-2026-08-03

That writes a third file, reprobe.jsonl, holding the second reading for each re-probed server, and a reprobe report in summary.json saying which namespaces moved, on which signal, and whether the second reading agreed.

It never edits records.jsonl. The census stays exactly as it was observed and the second reading is recorded beside it, so what gets published is still one dated observation plus the evidence needed to read it honestly.

A namespace needs at least --reprobe-min-servers servers (default 25) to qualify, because one server blinking is a large percentage of a small namespace, and the pass stops after --reprobe-max-servers (default 3000), recording truncated rather than reading as a clean result it did not earn.

What it checks

Health: registry status, repository reachable and fresh, package published, remote endpoint answers, at least one live entrypoint.

Conformance: server.json validates against its declared schema, the initialize handshake negotiates a protocol version, the JSON-RPC response echoes the request id, tools/list resolves over a full MCP session, a license is declared.

An auth-gated remote (401/403 to initialize) is treated as alive, not broken. akashi never supplies credentials to reach past it.

Every check, what it does and does not downgrade, and why: the full check catalog.

Verdicts

• healthy - at least one live entrypoint and nothing broken.
• degraded - usable, but something is broken (a 404 repo link while the package still installs, a stale-over-a-year repo, a deprecated registry entry, a down remote while a package works).
• dead - registry-deleted, or every probed entrypoint is broken.
• unknown - only entrypoints akashi cannot probe without a key were declared.

A degraded, dead, deprecated, or unknown server never renders a green "verified" badge.

Badge

--badge emits a shields.io endpoint JSON. Host it and embed:

![MCP health](https://img.shields.io/endpoint?url=https://your.host/akashi-badge.json)

A healthy server reads verified <date> in green; anything else reads its verdict, so a stale or broken server can never masquerade as verified.

GitHub Action

Fail CI when a server you depend on is not healthy:

- uses: RoninForge/akashi@v0
  with:
    server: io.github.owner/name
    # allow-degraded: true   # optional: only dead/unknown fails

License

MIT. See LICENSE.

Docs

• Every check, the verdict rules and the FAQ
• State of MCP: what the whole registry looks like, measured with akashi
• 2026-07-28 spec-readiness across the registry
• hanko, the Claude Code plugin manifest validator
• tsuba, the skill and plugin scaffolder

akashi is part of RoninForge.org.