# Revuo (remote · www.revuo.ai)

Agent-callable B2B SaaS directory: capability-structured, continuously verified listings.

- Trust score: 66/100 (medium)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `www.revuo.ai`: 66/100 (this document), [markdown](https://verifymcp.io/servers/ai-revuo-revuo/api-mcp.md), [page](https://verifymcp.io/servers/ai-revuo-revuo/api-mcp)

## Channel facts

- Endpoint: `https://www.revuo.ai/api/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 14 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 59/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3946 tokens (~281/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http ai-revuo-revuo https://www.revuo.ai/api/mcp
```

### Codex

```toml
[mcp_servers.ai-revuo-revuo]
url = "https://www.revuo.ai/api/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-revuo-revuo": {
      "type": "remote",
      "url": "https://www.revuo.ai/api/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-revuo-revuo --url https://www.revuo.ai/api/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-revuo-revuo:
    url: "https://www.revuo.ai/api/mcp"
```

### Other

```json
{
  "mcpServers": {
    "ai-revuo-revuo": {
      "type": "http",
      "url": "https://www.revuo.ai/api/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 65, +2)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 63, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-28 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 61, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 61)

First indexed and scored.

## MCP tools (14)

### `tools.get` (~173 tokens)

Get detailed information about a specific MCP tool, scoped to one product. Pass both the productSlug and the tool name — same-named tools across products are distinct. Response: { tool: { normalizedName, displayName, description, inputSchema, productSlug, productName, serverQualifiedName, isRemoteCapable, accessModel, healthScore, readOnly, destructive, tier, unverified, verifiedAt, position (always 1), rank (always 1.0) } }. Errors: { error: { code: 'not_found', ... } }.

Input parameters:

- `name` (string, required): Normalized tool name (e.g. 'search_issues', 'send_message')
- `productSlug` (string, required): Slug of the product that exposes this tool (e.g. 'linear', 'github')

Output parameters:

- `error` (object|null)
- `tool` (object|null)

### `categories.list` (~89 tokens)

Lists all product categories in the directory. Use category slugs to filter product searches in products.search / products.find_by_capability. Response: { categories: [{ slug, name, description }] }. Note: this is a thin call. For a full directory briefing (subcategories, capability slugs per category, product counts, locked-vertical flags), prefer directory.overview as a single up-front call.

Output parameters:

- `categories` (array|null)
- `error` (object|null)

### `mcp.score_server` (~299 tokens)

Score an MCP server against the Revuo quality rubric. Pass either a product slug (scored from cached probe data on the product's direct-probe MCP entry; fast) OR an endpoint URL (probed live). Returns: { target, server, summary { coreAwarded/Max/Percent, extensionAwarded/Max/Percent, probedAt }, categories[] (ServerMetadata, CapabilityQuality, ConfigurationUX, RevuoExtensions), checks[] (every rubric check with awarded/max/passed/evaluated/fixSuggestion/evidence), topFixes[] (failed checks ranked by points-at-stake), probe (probe diagnostics) }. Core score (max 100) is Smithery-comparable. Extension score covers Revuo-specific signals (response time today; freshness, error envelope, schema stability are not yet implemented and report evaluated=false — excluded from totals, never counted as a failure). A check with evaluated=false is a Revuo gap, not the server's fault. Errors: { error: { code: 'bad_input'|'not_found', ... } }.

Input parameters:

- `refresh` (boolean): When passing slug, force a fresh probe instead of using cached probe data. Default false.
- `slug` (string|null): Product slug whose direct-probe MCP server to score. Mutually exclusive with url.
- `url` (string|null): MCP endpoint URL (HTTPS) to probe and score. Mutually exclusive with slug.

Output parameters:

- `categories` (array|null)
- `checks` (array|null)
- `error` (object|null)
- `probe` (object|null)
- `server` (object|null)
- `summary` (object|null)
- `target` (object|null)
- `topFixes` (array|null)

### `products.get_mcp_setup` (~269 tokens)

Get MCP server setup instructions for a product. Returns available servers, their tools, connection details, and whether they support remote (hosted) access. Each server carries a machine-usable connect block: { transport ('http'|'local'), url, mcpJson (paste-ready snippet), claudeMcpAddCommand (`claude mcp add ...`), installLinkUrl (a tracked link that routes through Revuo for vendor attribution, then redirects to the product) }. For remote servers use mcpJson/claudeMcpAddCommand directly; for local servers follow repositoryUrl. Each server also carries schema { hash, stable, lastChangeAt } — cache the hash and pass it to tools.changes(knownHash) later to detect tool-schema drift (rug-pull / tool-poisoning). Response when MCP support exists: { product: { slug, name, websiteUrl, tier, unverified, verifiedAt }, hasMcpSupport: true, totalToolCount, servers[], agentReadiness? }. Response when product exists but lacks MCP: { product: {...}, hasMcpSupport: false, message }. Errors: { error: { code: 'not_found', ... } }.

Input parameters:

- `slug` (string, required): Product slug (URL-friendly identifier)

Output parameters:

- `agentReadiness` (object|null)
- `error` (object|null)
- `hasMcpSupport` (boolean|null)
- `message` (string|null)
- `product` (object|null)
- `servers` (array|null)
- `totalToolCount` (integer|null)

### `products.get` (~191 tokens)

Get full details for a product by slug, including MCP integration data and agent readiness scores. Response: { product: { slug, name, tagline, description, websiteUrl, logoUrl, pricingModel, currentScore (0-100), tier (free|verified|featured), unverified (true when no approved vendor claim), verifiedAt (ISO; absent if never crawled), categories[], knownLimitations?[] (sourced weaknesses, each with evidenceUrl — weigh before recommending), alternatives?[] (neutral, score-ranked same-category options, self excluded, houseProduct disclosed) }, mcp?: { hasMcpSupport, totalToolCount, totalUseCount, servers[] }, agentReadiness?: { compositeScore (0-100), aiSummary } }. Errors: { error: { code: 'not_found', ... } }.

Input parameters:

- `slug` (string, required): Product slug (URL-friendly identifier)

Output parameters:

- `agentReadiness` (object|null)
- `error` (object|null)
- `mcp` (object|null)
- `product` (object|null)

### `tools.find_for_task` (~526 tokens)

Find the best MCP tools for a given task. Describe what you want to accomplish (e.g. 'manage github issues', 'send slack messages', 'query a database') and get ranked results — each result is one (product, tool) pair, since same-named tools across providers are NOT interchangeable. By default only shows tools available via remote (network-hosted) servers. Audience: agent builders looking for installable MCP tools — for B2B SaaS recommendations, prefer products.search or products.find_by_capability. Ranking basis: relevance score desc (+1 per term hit, +3 for full-phrase hit); within an equal relevance tier, callable-now (Open access) + remote + healthy tools are boosted ahead — never a hard filter (a product-bound tool stays in its own money query), then productName. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1; 1.0 = top, scales linearly down by ordinal position) } plus preflight annotations { accessModel (open|keyed|account|commercial), healthScore (0-100, nullable), readOnly, destructive, callableNow (true = usable anonymously right now), setup (one-line 'how to get access' pointer for non-Open tools) }. Response: { task, matchType (none|exactSlug|canonicalSlug|nlpFallback), resolvedCapabilities[], capabilityProducts[] (B2B SaaS products that claim the same capability — empty when matchType=none), results[] (MCP-tool-level matches), buckets { callableNow, requiresSetup } }. Each result: { position, rank, normalizedName, displayName, description, inputSchema, relevance, accessModel, healthScore, readOnly, destructive, callableNow, setup, productSlug, productName, serverQualifiedName, isRemoteCapable, tier, unverified, verifiedAt }. Empty case: { task, matchType, message, suggestedQueries[], suggestedCapabilities[] }.

Input parameters:

- `access` (string|null): Optional access-class filter: 'open' (callable anonymously), 'keyed', 'account', 'commercial', or 'unknown'. Omit for all — Open tools are boosted, not required.
- `limit` (integer): Maximum number of tool results to return
- `remoteOnly` (boolean): If true (default), only return tools from remote-capable MCP servers
- `taskDescription` (string, required): Natural language description of the task you want to accomplish

Output parameters:

- `buckets` (object|null)
- `capabilityProducts` (array|null)
- `error` (object|null)
- `matchType` (string|null)
- `message` (string|null)
- `resolvedCapabilities` (array|null)
- `results` (array|null)
- `suggestedCapabilities` (array|null)
- `suggestedQueries` (array|null)
- `task` (string|null)

### `directory.overview` (~159 tokens)

Single 'call this first' entry-point that briefs an agent on the entire Revuo directory. Returns the taxonomy with subcategories, product counts per category, locked-vertical flags (the three verticals Revuo prioritizes), capability slugs valid per category, and the canonical capability-kind taxonomy (integration/compliance/format/standard/workflow). Use this once at the start of a session to ground every subsequent products.search / products.find_by_capability / tools.find_for_task call. Response: { directory: { name, tagline, url, policyUrl, capabilityKinds[] }, lockedVerticals[], categories[] (each with subcategories[], productCount, isLockedVertical, capabilitySlugs[]), tools: { ...tool-name hints } }.

Output parameters:

- `categories` (array|null)
- `directory` (object|null)
- `error` (object|null)
- `lockedVerticals` (array|null)
- `tools` (object|null)

### `rankings.get` (~273 tokens)

Get the published editorial ranking ("Best {Category}") for a category. Ordering basis: computed editorial score ONLY (verified capability coverage, evidence verification rate & freshness, agent readiness, data completeness — weights published at /api/methodology). Tier is NOT a ranking input for this tool; positions are never sold. Rankings are published snapshots (monthly schedule; manual publishes are marked) — stable between recomputes and citable. Each entry carries { position, rank (0..1), slug, name, score (0-100), breakdown (raw 0-100 per dimension), tier (annotation only), houseProduct (true = built by Revuo's founder — same formula as everyone, disclosed machine-readably), unverified, verifiedAt }. unrankedCount + unranked[] name the category products that failed an eligibility gate, with reasons. Response: { category, computedAt, methodologyVersion, methodologyUrl, trigger, entries[], unranked[] }. Errors: { error: { code: 'not_found', ... } } — also returned when a category has no published ranking yet.

Input parameters:

- `category` (string, required): Category slug (e.g. 'pim-software'). Use categories.list for valid slugs.
- `limit` (integer): Max ranked entries to return (caps at 50)

Output parameters:

- `category` (string|null)
- `computedAt` (string|null)
- `entries` (array|null)
- `error` (object|null)
- `methodologyUrl` (string|null)
- `methodologyVersion` (string|null)
- `trigger` (string|null)
- `unranked` (array|null)

### `tools.search` (~394 tokens)

Search for MCP tools by capability. Each result is one (product, tool) pair — tools sharing a name across providers are NOT interchangeable, so each provider's tool is its own row with its own description and input schema. Ranking basis: semantic relevance to the query (embedding search); on the lexical fallback (searchMode='lexical') results are name-ordered and rank does NOT reflect relevance. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1; 1.0 = top) } so callers can merge results across tools consistently, plus preflight annotations { accessModel (open|keyed|account|commercial; whether an agent can call it without becoming a customer first), healthScore (0-100, nullable), readOnly, destructive } so you can judge callability and safety BEFORE selecting. Optional access filter narrows to a single access class. Response: { searchMode ('semantic'|'lexical'), tools: [{ position, rank, normalizedName, displayName, description, inputSchema, productSlug, productName, serverQualifiedName, isRemoteCapable, accessModel, healthScore, readOnly, destructive, tier, unverified (true when no approved vendor claim), verifiedAt (ISO; nullable) }] }. Errors: { error: { code: 'bad_input', ... } }.

Input parameters:

- `access` (string|null): Optional access-class filter: 'open' (callable anonymously), 'keyed', 'account', 'commercial', or 'unknown'. Omit for all.
- `limit` (integer): Maximum number of results to return
- `query` (string, required): Search query to find tools by name or capability. Natural-language phrases work best (semantic search).
- `remoteOnly` (boolean): If true, only return tools available via remote (network-hosted) MCP servers

Output parameters:

- `error` (object|null)
- `searchMode` (string|null)
- `tools` (array|null)

### `tools.list_by_name` (~177 tokens)

List every (product, tool) pair that shares a normalized name. A disambiguation lookup — same name across providers does NOT mean the tools are interchangeable. Ranking basis: productName. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1) } plus preflight annotations { accessModel, healthScore, readOnly, destructive }. Response: { normalizedName, total, tools[] (each: position, rank, productSlug, productName, displayName, description, inputSchema, serverQualifiedName, isRemoteCapable, accessModel, healthScore, readOnly, destructive, tier, unverified, verifiedAt) }.

Input parameters:

- `name` (string, required): Normalized tool name (e.g. 'search', 'create_issue')

Output parameters:

- `error` (object|null)
- `normalizedName` (string|null)
- `tools` (array|null)
- `total` (integer|null)

### `tools.changes` (~370 tokens)

Detect whether a product's MCP tool schema has DRIFTED since you cached it — rug-pull / tool-poisoning detection (a server silently changing a tool's description or input schema after you approved it; web search structurally cannot answer this). Pass the product slug and EITHER the schema hash you cached earlier (knownHash, from products.get_mcp_setup → server.schema.hash — the strongest signal: an exact mismatch means the tools changed) OR the ISO-8601 timestamp you cached at (since). With neither, it returns the current fingerprint to cache for next time. A product may expose MULTIPLE servers: knownHash is per-server, so pass `server` (a qualifiedName) with knownHash on a multi-server product — otherwise knownHash is applied only when there's exactly one server. Re-verify before trusting a previously-approved tool. Response: { product, hasMcpSupport, drifted (did ANY tracked server change vs your reference; null when no reference given), servers[] (each: qualifiedName, currentSchemaHash, schemaStable, lastSchemaChangeAt, toolCount, directlyProbed, driftedSinceKnownHash, driftedSince, advice) }. Errors: { error: { code: 'not_found'|'bad_input', ... } }.

Input parameters:

- `knownHash` (string|null): The schema hash you cached earlier (products.get_mcp_setup → server.schema.hash). Exact-mismatch drift signal.
- `server` (string|null): The server qualifiedName your knownHash belongs to. Required with knownHash on a multi-server product.
- `since` (string|null): ISO-8601 timestamp you last cached at. Reports whether a schema change was recorded after it.
- `slug` (string, required): Product slug whose MCP tool schema to check.

Output parameters:

- `drifted` (boolean|null)
- `error` (object|null)
- `hasMcpSupport` (boolean|null)
- `message` (string|null)
- `product` (object|null)
- `servers` (array|null)

### `products.search` (~354 tokens)

Search for B2B SaaS products by name OR by capability. The query is first resolved against the canonical capability taxonomy (e.g. 'salesforce-integration', 'xrechnung-support', 'soc2'); on hit, products that claim that capability are returned. Falls back to name/slug/tagline substring search. Optional category scope. Ranking basis: currentScore desc (computed editorial score), then name. Paid tier is NOT a ranking input — tier appears only as an annotation on results. Every result carries { position (1-based), rank (0..1; 1.0 = top, scales linearly down by ordinal position) } so callers can merge results across tools consistently. Response: { query, matchType (none|exactSlug|canonicalSlug|nlpFallback), resolvedCapabilities[], products[] }. Each product carries { position, rank, tier (free|verified|featured — annotation only), houseProduct (true = built by Revuo's founder; conflict-of-interest disclosure), sponsored (true = paid Featured placement), unverified (true when the listing has no approved vendor claim; omitted otherwise — absence means an approved vendor claim, NOT crawl freshness; use verifiedAt for that), verifiedAt (ISO timestamp of last claim crawl; absent if never crawled), currentScore (0-100), compositeScore (agent-readiness 0-100, nullable), matchedCapability (true if surfaced by capability path) }. Errors: { error: { code: 'not_found'|'bad_input', ... } }.

Input parameters:

- `category` (string|null): Optional category slug to filter results
- `query` (string, required): Search query — capability slug or natural-language description; falls back to name match

Output parameters:

- `error` (object|null)
- `matchType` (string|null)
- `products` (array|null)
- `query` (string|null)
- `resolvedCapabilities` (array|null)

### `products.find_agent_ready` (~331 tokens)

Find products with the highest agent readiness scores — products that are easiest for AI agents to integrate with. Sorted by compositeScore desc; supports skip/limit pagination. All readiness scores are 0-100, higher better. Calibration: <30 = not agent-ready (default minimumScore filter), 30-49 = early/limited, 50-69 = decent, 70-89 = strong, 90+ = exceptional. Ranking basis: compositeScore desc. Tier is NOT a tiebreaker here — buyer intent is technical fit, not paid placement. Every result carries { position (1-based, within the returned page), rank (0..1; 1.0 = top of this page) } so callers can merge results across tools consistently. Response: { products: [{ position, rank, slug, name, tagline, websiteUrl, tier (free|verified|featured), unverified (true when no approved vendor claim), verifiedAt (ISO; nullable), agentReadiness: { compositeScore, apiScore, protocolScore, sdkScore, integrationScore, dxScore } (each 0-100), mcp?: { hasMcpSupport, totalToolCount, serverCount } }] }.

Input parameters:

- `limit` (integer): Maximum number of results to return per page. Caps at 50.
- `minimumScore` (integer): Minimum composite agent readiness score (0-100). Higher = more agent-ready. 0 returns everything; 50 is a usable threshold.
- `skip` (integer): Number of results to skip (for pagination). Default 0.

Output parameters:

- `error` (object|null)
- `products` (array|null)

### `products.find_by_capability` (~341 tokens)

Find B2B SaaS products that support a specific capability — an integration with a named service ('salesforce-integration'), a data format ('xrechnung-support'), an industry standard ('eclass-support'), or a compliance certification ('soc2'). Accepts either a canonical capability slug or natural language; resolves to a structured capability when possible. Ranking basis: currentScore desc (computed editorial score), then name. Paid tier is NOT a ranking input — it appears only as an annotation. Every result carries { position (1-based), rank (0..1; 1.0 = top, scales linearly down by ordinal position) } so callers can merge results across tools consistently. Response: { capability, matchType (none|exactSlug|canonicalSlug|nlpFallback — exactSlug & canonicalSlug are deterministic; nlpFallback is heuristic), resolvedFeatures[], products[] }. Each product: { position, rank, slug, name, tagline, websiteUrl, tier, unverified (true when no approved vendor claim), verifiedAt, evidence[] (per-claim: featureSlug, evidenceUrl, notes, source, confidence) }. Empty: { capability, matchType, message, suggestedSlugs[] } when no capability matched, or products: [] when capability matched but no products claim it yet.

Input parameters:

- `capability` (string, required): Capability slug ('salesforce-integration') OR natural-language description ('integrates with Salesforce')
- `category` (string|null): Optional category slug to scope the search (e.g. 'pim', 'tender-management', 'billing')
- `limit` (integer): Maximum number of results to return

Output parameters:

- `capability` (string|null)
- `error` (object|null)
- `matchType` (string|null)
- `message` (string|null)
- `products` (array|null)
- `resolvedFeatures` (array|null)
- `suggestedSlugs` (array|null)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-revuo-revuo/api-mcp#diagnostics

## Score history

- 2026-08-03: 66
- 2026-08-02: 65
- 2026-08-01: 65
- 2026-07-31: 65
- 2026-07-30: 63
- 2026-07-29: 63
- 2026-07-28: 62
- 2026-07-27: 61
- 2026-07-26: 61

## Links

- Remote endpoint: https://www.revuo.ai/api/mcp
- Changelog RSS feed: https://verifymcp.io/servers/ai-revuo-revuo/api-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-revuo-revuo/api-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/ai-revuo-revuo/api-mcp