# runchr

> A hand-written registry of agent tools — the judgment layer, not another list.

runchr is a curated registry of the agent artifacts a one-person company builds
on: agents, frameworks, MCP servers, skills, plugins, prompts, apps and runtimes.
Each entry is one GitHub repository, classified into one of eight types, tagged
with the tasks it serves, and given a short summary written for a founder
deciding whether to adopt it. Tools live on GitHub and npm; runchr says which
ones are worth the afternoon.

Site: https://runchr.com

## Reading the catalog

No token, no account, no key. Reading is open.

    GET https://api.runchr.com/api/tools

Query parameters (all optional):

- `q` — a search string, matched against the name, summary, description, type
  name and task names. Partial words match; there is no ranking or fuzzing.
- `type` — one of: `agent`, `framework`, `mcp-server`, `skill`, `plugin`,
  `prompt`, `app`, `runtime`
- `task` — one of: `coding`, `multi-agent`, `data`, `browser`, `knowledge`,
  `devops`, `research`, `writing`, `memory`
- `page` — 1-based, default 1
- `limit` — default 50, maximum 100
- `sort` — `stars` (default), `updated`, or `name`

The answer:

```json
{
  "tools": [
    {
      "slug": "context7",
      "name": "Context7",
      "type": "mcp-server",
      "summary": "Feed an agent current library docs instead of its training data.",
      "description": "…",
      "tasks": ["coding", "research"],
      "repoUrl": "https://github.com/upstash/context7",
      "metrics": { "stars": 63888, "language": "TypeScript", "pushedAt": "…" }
    }
  ],
  "total": 143,
  "page": 1,
  "pages": 3
}
```

One entry:

    GET https://api.runchr.com/api/tools/context7

Answers `{ "tool": { … } }`, or `404` if there is no such entry.

## Best by type and task

The two axes together answer a builder's real query. Each page lists the tools
of one type that do one task, most stars first:

    https://runchr.com/best/mcp/coding
    https://runchr.com/best/frameworks/multi-agent

Index: https://runchr.com/best

## Comparisons

Two of a kind, side by side: stars, tasks, last update, license, install. Only
tools of the same type that share a task are compared.

    https://runchr.com/compare/context7-vs-trendradar

Index: https://runchr.com/compare

## Recipes

Agent stacks are community content on top of the registry. Reading is open;
posting requires a signed-in GitHub session on the site.

    GET https://api.runchr.com/api/recipes
    GET https://api.runchr.com/api/recipes/{owner}/{slug}
    GET https://api.runchr.com/api/recipes/{owner}/{slug}/manifest
    GET https://api.runchr.com/api/recipes/{owner}/{slug}/revisions

A recipe is a namespaced artifact: `owner/slug`, where the owner is a member's
login or `runchr` for a crawl-mined stack. It carries a `version`, a `tier`, and
a `manifest` — the machine-readable form a loader pulls. `tier` is one of:

- `curated` — a human verified the stack.
- `draft` — generated from the index, not verified.
- `crawl` — raw, mined from README cross-links.

The recommendation orders them curated, then draft, then crawl.

The manifest is the thing to run:

```json
{
  "manifestVersion": 1,
  "name": "runchr/context7-docs",
  "revision": 1,
  "version": "0.1.0",
  "tier": "crawl",
  "model": "claude-sonnet-4.5",
  "harness": "claude-code",
  "tools": [{ "type": "mcp-server", "ref": "context7", "install": "npx -y @upstash/context7-mcp" }],
  "systemPrompt": "…"
}
```

Only the author of a member recipe or an admin may edit it; crawl-mined stacks
are editable by admins only, and each edit is a new revision.

    PATCH https://api.runchr.com/api/recipes/{owner}/{slug}

Optional list query parameters: `page` (1-based), `limit` (default 50, max 100),
and `tool={entry-slug}` for stacks that include a registry tool.

A recipe is a real stack: two or more registry tools wired together, sourced
from a repository. Low-confidence drafts land in `recipe_queue` for admin review
instead of the public list. A pull request, issue, or commit is not a stack and
is never one.

Human-readable list: https://runchr.com/recipes

A stack's health — whether a pinned revision is behind, and which tools have
been archived or gone quiet, with graph-ranked replacements:

    GET https://api.runchr.com/api/recipes/{owner}/{slug}/check?revision=1

## Loading a stack

`runchr pull` fetches a stack and writes it into a folder:

    node cli/index.mjs pull owner/slug[@rev] [--dir <path>] [--json]

It writes four files: `runchr.json` (the manifest), `AGENTS.md` (the card and
the tools), `mcp.json` (the MCP servers, best effort), and `prompt.md` (the
system prompt and instructions). It fetches before it writes, so a failure
leaves the folder untouched. Each manifest fetch is counted as a pull, and the
recipe page shows the count.

`install` does the same and applies the stack: it merges the MCP servers into a
project `.mcp.json` and, with `--yes`, runs the tool installs. Without `--yes` it
prints them and runs nothing.

Point it at another host with `RUNCHR_API_URL`.

## MCP

The same catalog is served over MCP at `https://api.runchr.com/mcp` — one POST,
JSON-RPC 2.0, no session. Four tools:

- `search_stacks` — find stacks by problem domain or text. Each answer carries
  the tier and the pull count, so an agent can weigh what it finds.
- `get_stack` — one stack's card, with its tools and pull count.
- `get_manifest` — the manifest a loader runs.
- `get_install_plan` — how to install the stack: the MCP servers to configure,
  the shell commands to run, and the notes for the rest.

No token. An agent that speaks MCP reads runchr without a CLI.

## What to expect

- Hidden entries are never returned, never counted, and have no page.
- Answers are cached for five minutes at the edge.
- Reads are limited to 120 requests a minute per IP; over that, `429`.
- A bad parameter (`?type=nonsense`, `?page=0`, `?limit=99999`) is a `400`, not
  a crash and not a silent default.

## The eight types

| id | what it is |
| --- | --- |
| `agent` | A runnable agent: it takes a goal and acts. |
| `framework` | A library you build an agent with. |
| `mcp-server` | A Model Context Protocol server: tools an agent can call. |
| `skill` | Instructions and scripts that teach an existing agent a capability. |
| `plugin` | An extension to a host app or editor. |
| `prompt` | Text you paste: system prompts, prompt packs, templates. |
| `app` | A finished product a person uses directly. |
| `runtime` | The layer an agent executes in: sandboxes, orchestrators, sandboxed execution. |

## Elsewhere

- Human-readable pages: https://runchr.com/tools, /agents, /frameworks, /mcp,
  /recipes
- The API's rules are in this file; there is no separate public document.
  `https://api.runchr.com/api/tools` answers with the live shape.
- A submission that is not here yet: https://runchr.com/submit