# com.agentery/agentery (remote · agentery.com)

Search agents & MCP servers by capability, with daily-observed pricing, liveness and market data.

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

## Components

- remote · `agentery.com`: 59/100 (this document), [markdown](https://verifymcp.io/servers/com-agentery-agentery/api-mcp.md), [page](https://verifymcp.io/servers/com-agentery-agentery/api-mcp)

## Channel facts

- Endpoint: `https://agentery.com/api/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.3.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 19 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**: 58/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6135 tokens (~322/item across 19 items; 19 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: schema churn in the 8 days we've observed: 5 tool removals, 0 breaking changes, 0 auth/transport breaks, 12 additions.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 96% of tool parameters carry a description.
- **Capabilities**: 40/100
  - Spec-recency check failed: implements MCP spec 2025-03-26; the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http com-agentery-agentery https://agentery.com/api/mcp
```

### Codex

```toml
[mcp_servers.com-agentery-agentery]
url = "https://agentery.com/api/mcp"
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add com-agentery-agentery --url https://agentery.com/api/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-agentery-agentery:
    url: "https://agentery.com/api/mcp"
```

### Other

```json
{
  "mcpServers": {
    "com-agentery-agentery": {
      "type": "http",
      "url": "https://agentery.com/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 59, 0)

- [security] Tool “price_benchmark” rewrote its description, which is the text the model reads
- [cosmetic] “price_benchmark” added an optional parameter “response_mode”
- [cosmetic] “price_benchmark” added an optional parameter “provider_type”
- [cosmetic] “price_benchmark” added an optional parameter “pricing_unit”
- [cosmetic] “price_benchmark” added an optional parameter “buyer_tier”

### 2026-08-02 (score 59, −3)

- [security regression] Stability: 0.20 → fail
- [security regression] Tool “compare_agents” was removed
- [security regression] Tool “get_agent” was removed
- [security regression] Tool “get_agent_profile” was removed
- [security regression] Tool “rank_agents_for_workflow” was removed
- [security regression] Tool “search_agents” was removed
- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “demand_signals” rewrote its description, which is the text the model reads
- [security] Tool “find_niche” rewrote its description, which is the text the model reads
- [security] Tool “get_price_index” rewrote its description, which is the text the model reads
- [security] Tool “niche_report” rewrote its description, which is the text the model reads
- [security] Tool “report_outcome” rewrote its description, which is the text the model reads
- [security] Tool “research_capability” rewrote its description, which is the text the model reads
- [security] Tool “suggest_alternatives” rewrote its description, which is the text the model reads
- [functional] Schema quality: good → excellent
- [functional] Server version: 1.7.1 → 1.8.0
- [functional] New tool “compare_providers”
- [functional] New tool “get_provider”
- [functional] New tool “get_provider_profile”
- [functional] New tool “rank_providers_for_workflow”
- [functional] New tool “search_providers”
- [cosmetic] “suggest_alternatives” reworded the description of “agent_id”
- [cosmetic] “suggest_alternatives” reworded the description of “cheaper_only”
- [cosmetic] “get_price_index” reworded the description of “niche”
- [cosmetic] “report_outcome” reworded the description of “agent_id”
- [cosmetic] “report_outcome” reworded the description of “latency_ms”
- [cosmetic] “report_outcome” reworded the description of “outcome”
- [cosmetic] “research_capability” reworded the description of “task”

### 2026-08-01 (score 62, +3)

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

### 2026-07-30 (score 59, −1)

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

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

- [security] Tool “compare_agents” rewrote its description, which is the text the model reads
- [functional] Server version: 1.6.1 → 1.6.2

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

- [functional] Schema quality: good → excellent

### 2026-07-27 (score 58, 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 58)

First indexed and scored.

## MCP tools (19)

### `research_capability` (~597 tokens)

START HERE for provider procurement. ONE call turns a task into: (1) its resolved market — niche name + slug, resolver mode/confidence, alternative niches, a concise definition; (2) current pricing context — comparable price range, the niche's AEPI index level and 1d/7d/30d movement, provider/comparable counts; and (3) a ready-to-compare provider shortlist — each with observed price, market_position (below/in-line/above market), integration status, match score, and handles collected in `compare_ready`. This collapses the usual find_niche → niche_report → price_benchmark → search_providers handshake into a single call and REUSES those exact engines (no new pricing/index/search logic). It also returns `suggested_alternatives` (cheaper or stronger in-market options — e.g. when a provider is over budget or an integration is unconfirmed) and a `result_fingerprint` (+ `cached`) so repeat calls are cheap. It does NOT run the comparison — pass `compare_ready` to compare_providers once you have finalists. Use the lower-level tools (find_niche, niche_report, price_benchmark, search_providers) when you need finer control. Aliases: `task` also accepts `query` / `q`.

Input parameters:

- `buyer_tier` (string): Optional buyer tier to price against ('team' = Team/SME).
- `integrations` (array): Optional required integrations, e.g. ["zendesk","slack"] — soft preference; integration status is reported per provider.
- `limit` (number): Shortlist size (1-12, default 5).
- `max_monthly_usd` (number): Optional budget ceiling in USD/month — filters the shortlist and drives suggested_alternatives.
- `provider_type` (string): Preferred delivery type. 'auto' (default) infers from the task; note 'AI agent' phrasing is treated as generic (neutral), not an agent-only filter. When a type is explicit (mcp/api/agent) matching pr…
- `response_mode` (string): 'summary' (default) or 'full' (adds tier cohorts, coverage and raw results).
- `sort` (string): Shortlist ordering. Default 'match'.
- `task` (string, required): Required — the natural-language capability/task, e.g. 'reconcile supplier invoices' or 'litigation-analysis provider'. Aliases: query, q.

### `search_providers` (~413 tokens)

Targeted provider search when you already know roughly what you want; for a NEW task where the market isn't known yet, call research_capability first. Filtered free-text search over the directory, ranked with match_score and match_reasons. Each result includes an observed-price object; filter by max_monthly_usd/billing and sort by price_asc to shop on value-for-money. Results include how_to_connect (website, docs, mcp.endpoint when the vendor publishes one) — the link/endpoint needed to actually use the listing; get_provider_profile has the full version with a copy-paste MCP config snippet. If you end up using one of the results, call report_outcome afterwards — it sharpens future rankings and raises your rate limit. Accepts `query` (aliases: q, text) — an unknown query key is never silently ignored. For a market + pricing + shortlist in ONE call, use research_capability first.

Input parameters:

- `billing` (array): Only providers with one of these observed billing models, e.g. ["free","freemium","subscription","usage"]
- `filters` (object): Optional: industry_fit[], integrations_available[], entity_type[] (agent|tool|infrastructure|service|marketplace|content-community), autonomy_level[] (assistant|workflow automation|agentic|infrastruc…
- `limit` (number): Max results (1-50, default 20)
- `max_monthly_usd` (number): Drop providers whose observed lowest paid tier exceeds this (USD/month). Providers with no observed public price still pass unless require_public_price is true.
- `query` (string): Free-text capability query, e.g. 'customer support provider with Zendesk integration'
- `require_public_price` (boolean): Only return providers with an observed public price (default false)
- `sort` (string): match (default) or price_asc (cheapest observed price first; unpriced providers last)

### `find_niche` (~508 tokens)

Map a natural-language task, capability or service to the correct canonical Agentery niche in ONE call — for buyers ('a provider that monitors competitor pricing'), sellers ('what should I charge for a lead-generation provider') or classification ('which niche does my customer-support provider belong to?'). Pricing-intent boilerplate is stripped before matching. Returns match_certainty ('confident'|'ambiguous'|'uncertain' — 'confident' requires a strong score AND a clear lead over the runner-up AND a specific niche, so a borderline top score is never oversold as confident), the best-matching niche (name + slug) with a confidence score and reason, up to two alternatives, and pricing on an EVIDENCE LADDER via pricing_status: 'ok' = a strict comparable benchmark — pricing_by_tier: FX-normalized monthly-USD cohorts separated by buyer tier (individual/pro/team_sme/enterprise) AND billing unit (flat/per_seat/per_user/per_agent), provider-deduped (one vendor's ladder counts once), with provider_count, plan_observation_count, data_confidence, reliability; p25/p75 only at >=5 providers. When no strict cohort forms: 'single_observation' (exactly one comparable provider — returned in single_observations, never called a benchmark/median), or 'observed_offers_only' (real provider offers in observed_offers, grouped and labelled by billing type/unit, each a single observed price NEVER aggregated across mixed units/periods/tiers). Also returns pricing_coverage (listings, priced listings, normalized observations, comparable providers, exclusion reasons) and, when there is no strict benchmark, adjacent_pricing (related niches WITH a benchmark, clearly not equivalent). Usage-metered, promotional, range, one-time and ambiguous-cadence plans are excluded from cohorts. When the match is 'uncertain', pricing is WITHHELD; when 'ambiguous', pricing is returned but flagged to confirm the niche. Follow suggested_next_call to niche_report for the full market read. Accepts `task` (aliases: que…

Input parameters:

- `query` (string): Alias for task (back-compat) — a natural-language task, capability or service
- `task` (string): A natural-language task, capability or service, e.g. 'reconcile supplier invoices'

### `compare_providers` (~382 tokens)

Call this to decide between shortlisted providers. Inputs are resolved to REAL providers — exact handle, then exact display name — and are NEVER silently swapped for a fuzzy match: unknown inputs come back in `unresolved_inputs` with `suggested_matches` and a ready-to-retry `corrected_call`, and if EXACTLY ONE input is real (the other was invented/mistyped) it does NOT dead-end — it returns `comparison_status: compared_with_market_peers`, comparing the real provider against its actual in-niche competitors (listed in `compared_against_peers`, with a `recovery_note`); only when ZERO inputs resolve does it return `comparison_status: insufficient_valid_providers`. When the compared providers are different delivery types it sets `mixed_provider_types` + a `comparability_warning` (a hosted agent and an MCP server are not directly equivalent). Full evidence-scored cards for 2-6 handles side by side, each with observed price, all-time community upvotes and niche/sector. Each card carries the full how_to_connect object (website, docs, MCP endpoint + config_snippet, A2A card, API) so you can act on the winner directly. Each card also carries `reported_success` — the machine-reported outcome rate from report_outcome (null until 5+ distinct correlated reporters in 90 days). Report your own outcome after using the winner. Accepts `provider_ids` (aliases: handles, ids; a comma-separated string is also accepted). Use after search_providers or research_capability; when a compared provider is over budget or weakly matched, inline `suggested_alternatives` are returned.

Input parameters:

- `provider_ids` (array, required): 2-6 provider handles from search_providers/market_gaps, e.g. ["openhands","lexaclaw"]

### `get_price_index` (~536 tokens)

Call this for the CURRENT level of the Agent Economy Price Index (AEPI) or one niche's price index — a chained like-for-like index over observed provider/MCP pricing (base 100 = 29 Jun 2026). It is an INDEX LEVEL, not a market price or tradeable asset. scope 'aepi' (default) returns the headline index level with change_1d/change_7d/change_30d, as_of, like_for_like_pair_count, status and the methodology version, PLUS the same fields for the four buyer tiers (Individual, Pro, Team/SME, Enterprise). scope 'niche' resolves a slug OR a natural-language task via the niche resolver (returning resolver mode/certainty/confidence and candidate niches) and returns that niche's index level and change_1d/7d/30d with comparable-provider counts; when history or comparable data is thin it returns an honest status (insufficient_comparables / insufficient_history / temporarily_unavailable) instead of a fabricated percentage — it never substitutes another cohort. `tier` filters to one buyer tier; response_mode 'full' adds exact sub-0.01% moves, per-tier niche indices and repricing counts. Reads the SAME canonical series as the /aepi page, so the MCP and website agree for a given timestamp.

Input parameters:

- `niche` (string): For scope 'niche': a canonical niche slug (e.g. 'customer-support-tier1') or a natural-language task/query (e.g. 'customer support providers'), resolved by the niche resolver.
- `provider_type` (string): Delivery-type scope for scope 'aepi': 'all' (default) = the combined index; 'agent' or 'mcp' = the standalone index over just that provider type (own base 100). Agents and MCPs price and move differe…
- `response_mode` (string): 'summary' (default) or 'full' (adds exact sub-0.01% moves, per-tier niche detail and repricing counts).
- `scope` (string): 'aepi' (default) = whole-economy headline + the four buyer tiers; 'niche' = one niche's index.
- `tier` (string): Filter to one buyer tier ('team' = Team/SME). Default 'all'.

### `price_benchmark` (~647 tokens)

Returns fair-price benchmarks for a functional niche, SEPARATED BY provider type (provider / mcp / api), buyer tier (individual / pro / team_sme / enterprise) and compatible pricing unit. A fair-price benchmark = NICHE x PROVIDER_TYPE x BUYER_TIER x PRICING_UNIT — a single blended provider+MCP median is NEVER the default. Supply provider_type and buyer_tier whenever the user makes them known (e.g. 'an individual MCP', 'a professional provider', 'enterprise'); when neither is known the tool returns the available per-type/per-tier cohort matrix (populated cohorts only), not a blended headline. Never treat MCP as the functional niche unless the product itself is MCP infrastructure. The blended distribution + AEPI index remain available only in response_mode='full'. Also returns `index` — the Agent Economy Price Index for the scope: a chained like-for-like daily price index (base 100 = 29 Jun 2026) that composition changes can't move; null when the series is too short. At whole-economy scope (no niche/sector filter) it also returns `index_by_tier`: the same index tracked separately per pricing tier (individual/pro/team_sme/enterprise) — null when a niche or sector filter is given, because per-tier-per-niche samples are too thin to be honest. The authoritative block is pricing_by_tier (pricing_version 'cohorts-1') on the same EVIDENCE LADDER as find_niche: 'ok' (strict per-tier/unit cohorts) else single_observations / observed_offers (real offers, labelled by billing type, never aggregated across mixed units) plus pricing_coverage; the legacy byPersona medians are kept only for back-compat. An approximate or natural-language niche is resolved to the canonical slug (returned in niche_resolution); an unresolvable niche returns resolved:false with did_you_mean instead of an empty result.

Input parameters:

- `buyer_tier` (string): Buyer tier being priced. Set when the user describes who is buying (an individual, a professional, a team/SME, or an enterprise). An individual licence must never be represented by the SME or enterpr…
- `niche` (string): Niche slug (or an approximate slug / natural-language name — it is resolved to the canonical niche), e.g. 'contract-review-automation'
- `pricing_unit` (string): Optional pricing unit to hold constant (e.g. 'flat', 'per_seat', 'per_agent'). Incompatible units are never combined.
- `provider_type` (string): Delivery type being priced. Set when the user says provider, MCP or API. Omit (or 'all') to get the per-type matrix instead of a blended figure. 'api' is recognised but not yet a separate commercial…
- `response_mode` (string): 'summary' (default): compact per-type/per-tier benchmark matrix. 'full': also returns the deprecated blended legacy block + AEPI index.
- `sector` (string): Sector name, e.g. 'legal' (ignored if niche is given)

### `get_price_index_history` (~356 tokens)

Call this for the canonical DATED index SERIES (to chart or analyse movement) of the AEPI or a niche price index — the same chained like-for-like series the /aepi and niche pages plot. Every point is an index level (base 100), never a price. scope 'aepi' (default) returns the headline series, or a single buyer tier's series when `tier` is set; scope 'niche' resolves a slug or natural-language query and returns that niche's dated series. `period` selects '30d' (default), '90d' or 'all'. response_mode 'summary' (default) returns date + index_level points plus the window change; 'full' adds gap flags. Returns an honest status (insufficient_history / insufficient_comparables) rather than a fabricated series when data is too thin.

Input parameters:

- `niche` (string): For scope 'niche': a canonical niche slug or natural-language query.
- `period` (string): History window. Default '30d'.
- `provider_type` (string): Delivery-type scope for scope 'aepi': 'all' (default), or the standalone 'agent' / 'mcp' series (own base 100). Per-type niche history is a Phase-2 follow-up; acknowledged, not silently applied, on s…
- `response_mode` (string): 'summary' (default, compact) or 'full'.
- `scope` (string): 'aepi' (default) or 'niche'.
- `tier` (string): For scope 'aepi', return one buyer tier's series ('team' = Team/SME). Default 'all' = the headline series.

### `market_gaps` (~209 tokens)

Find under-served markets to build in. DEFAULT (rank='gaps'): true whitespace — niches with money already present (enterprise / contact-sales pricing) or recent builder entry, but FEW competitors; crowded niches are excluded, so a 'gap' is never crowded. Each result carries gap_score, a plain-English `why`, crowding, listing count, the market_pulse object and an observed-pricing rollup. Pass rank='hot' instead to rank by momentum (market pulse) regardless of crowding — for tracking where the action is. Drill into one slug with niche_report. Empty args ({}) return the ranked overview — a lightweight orient scan.

Input parameters:

- `limit` (number): Max niches (1-50, default 15)
- `rank` (string): gaps (default): whitespace with money, crowded excluded. hot: most active by market pulse, crowding ignored.
- `sector` (string): Optional sector filter, e.g. 'legal', 'healthcare'

### `suggest_alternatives` (~201 tokens)

Call this when a shortlisted provider is too expensive, unreachable or a poor fit: substitutes for one known provider — same niche first, topped up by similar capability — each with observed price, endpoint liveness, community upvotes and how_to_connect (website, docs, mcp endpoint) so a substitute is immediately usable. Set cheaper_only to shop down from the subject's price. Accepts `agent_id` (aliases: handle, id). These substitutes are also surfaced automatically inside research_capability and compare_providers, so you rarely need to call this separately.

Input parameters:

- `agent_id` (string, required): Handle of the provider to find substitutes for, e.g. 'openhands'
- `cheaper_only` (boolean): Only keep alternatives priced below the subject's lowest monthly price. Free/freemium providers always qualify; providers with no observed price are excluded. Default false.
- `limit` (number): Max alternatives (1-10, default 5)

### `niche_report` (~320 tokens)

Call this to deep-dive ONE market niche before building or investing — every field is MEASURED: market_pulse (composite of 30d like-for-like price movement, money present, builder entry, endpoint liveness — with plain-English drivers), the observed-pricing snapshot, crowding level, adjacent niches, and the top providers already competing there. Also returns `movement` (7-day decomposition: which providers repriced vs entered/left the priced set) and `index_series` (the niche's like-for-like price index) — each null when data is thin. Pricing follows the same EVIDENCE LADDER as find_niche (pricing_status ok / single_observation / observed_offers_only / insufficient, with pricing_coverage). An approximate or natural-language niche is resolved to the canonical slug (returned in niche_resolution). Accepts `niche` (aliases: slug, niche_slug). Get valid slugs from market_gaps. Use when you already know the niche; for market + pricing + shortlist in one call use research_capability.

Input parameters:

- `niche` (string, required): Niche slug (or an approximate slug / natural-language name — it is resolved to the canonical niche), e.g. 'ai-phishing-detection'
- `response_mode` (string): 'summary' (DEFAULT) returns a compact ~5KB block: clearly-named counts, canonical published movement, monthly-comparable tier ranges, billing mix, top providers and suggested next calls. 'full' retur…

### `demand_signals` (~98 tokens)

Call this to see what providers are being SEARCHED FOR but don't exist yet: capability queries that returned ZERO results on this MCP server, aggregated and ranked by miss count. A live unmet-demand signal for founders and investors — pair a hot signal with niche_report/market_gaps to size the gap. Empty args ({}) return the current ranked unmet-demand list.

Input parameters:

- `limit` (number): Max signals (1-50, default 20)

### `report_outcome` (~292 tokens)

After you use a listed provider, report whether it worked — reports are correlated with your recent retrievals, improve ranking accuracy, and unlock higher rate limits for contributors. Only reports we can match to one of YOUR retrievals (search_providers / get_provider_profile / compare_providers / suggest_alternatives naming that provider, last 48h) carry weight; unmatched reports are stored but unweighted. Aggregates surface as `reported_success` on profile/comparison cards once 5+ distinct reporters exist (90-day window). Callers with 5+ correlated reports in 30 days get a doubled per-minute rate limit. Send an x-agentery-key header to keep one reporter identity across IPs (it is stored only as a hash).

Input parameters:

- `agent_id` (string, required): Handle of the provider you used, as returned by search_providers/get_provider_profile/compare_providers
- `error_class` (string): Optional failure class, e.g. 'timeout', 'auth', 'wrong-output', 'endpoint-down'
- `latency_ms` (number): Optional end-to-end latency of the provider in milliseconds
- `note` (string): Optional free-text detail (capped at 300 chars)
- `outcome` (string, required): Did the provider accomplish the task you hired it for?
- `task_type` (string): Optional short task label, e.g. 'code-review', 'lead-enrichment'

### `rank_providers_for_workflow` (~207 tokens)

PARTNER-ONLY (Bearer key required). Given a business context and its workflow steps, return ranked provider candidates for EACH step — structured, scored (match_score 0-100) matches with match_reasons and cautions. Built for app builders (e.g. Builtery) assembling automations. Reads each provider's analysed site profile; never invents capabilities; returns 'unclear' where evidence is missing.

Input parameters:

- `business_context` (object): company_description, industry, region, existing_tools[], automation_posture (cautious|balanced|agent_native), regulated_data (none|personal|health|financial|legal|children|unknown)
- `limit_per_step` (number): Max candidates per step (1-25, default 8)
- `workflow_steps` (array, required): Each: step_id, step_name, step_description, inputs[], desired_outputs[], required_integrations[], human_approval_preference (always|sometimes|not_needed|unknown)

### `get_provider_profile` (~202 tokens)

Call this to drill into ONE provider after search_providers or compare_providers: full evidence-scored profile — task_performed, inputs/outputs, integrations, protocols, industry_fit, autonomy_level, human_approval_needed, observed price, trust signals, evidence_quality, entity_type, regulated_data_suitability, evidence_urls, last_checked. Includes the full how_to_connect object — website, docs, any vendor-published MCP endpoint (with a copy-paste client config_snippet), A2A agent card and API surface — the info needed to actually use the listing; fields are null when the vendor publishes no endpoint (never guessed). Also carries `reported_success` — machine-reported outcome rate from report_outcome (null until 5+ distinct correlated reporters in 90 days). If you use the listing, call report_outcome afterwards.

Input parameters:

- `provider_id` (string, required): The provider_id/handle returned by search_providers or compare_providers

### `get_provider` (~78 tokens)

Call this for the public directory card of one provider by handle or registration number: bio, source URLs, X-verification status, entity type, community rating and structured profile when available.

Input parameters:

- `handle` (string): Provider handle, e.g. 'openhands'
- `regNum` (number): Registration number, e.g. 2432

### `create_custom_benchmark` (~263 tokens)

Create a PRIVATE custom benchmark (a saved, calculated peer cohort) over Agentery's data — no account needed. Two modes: (A) explicit members: pass `members` (a list of exact handles; product names/domains resolve where unambiguous). (B) fork a niche: pass `base_niche` plus optional `remove`/`add`. Returns a one-time secret `benchmark_id` (cb_… token) — store it; it's your only key. Use it later in get/update/delete and in niche_report/get_price_index/get_price_index_history. Ambiguous names are returned as candidates, never silently resolved; unresolved inputs block creation unless allow_partial:true. All prices/history are computed from Agentery's immutable observations; canonical niches are never changed.

Input parameters:

- `add` (array): members to add
- `allow_partial` (boolean): Create with only the resolved members when some inputs don't resolve (default false)
- `base_niche` (string): Mode B: canonical niche slug to fork
- `members` (array): Mode A: exact handles (preferred), product names or domains
- `name` (string): Optional private label
- `remove` (array): Mode B: members to drop from the forked niche

### `get_custom_benchmark` (~165 tokens)

Get a private custom benchmark's current report: members, current stats (headline median/quartiles only when ≥3 comparable priced members — monthly, per-seat and per-call prices are never blended), buyer-tier / provider-type / pricing-unit cohorts, historical index, and data coverage. Pass `benchmark_id` (your cb_ token) as an ARGUMENT.

Input parameters:

- `as_of` (string): Optional YYYY-MM-DD — reproduce the exact stats + index as they were on that date, using this version's fixed membership
- `benchmark_id` (string, required): Your cb_ token (bearer secret; passed as an argument, never a URL)
- `response_mode` (string): full includes the index series
- `version` (number): Optional benchmark version (default latest)

### `update_custom_benchmark` (~85 tokens)

Add/remove members or rename a custom benchmark. Creates a NEW immutable version (the previous version stays fully reproducible) and returns the exact change-impact on the median/quartiles/index. Pass `benchmark_id`.

Input parameters:

- `add` (array)
- `benchmark_id` (string, required): Your cb_ token
- `remove` (array)
- `rename` (string)

### `delete_custom_benchmark` (~49 tokens)

Disable access to a custom benchmark. Keeps only a minimal audit record; no underlying Agentery data is touched. Pass `benchmark_id`.

Input parameters:

- `benchmark_id` (string, required): Your cb_ token

## Diagnostics

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

## Score history

- 2026-08-03: 59
- 2026-08-02: 59
- 2026-08-01: 62
- 2026-07-30: 59
- 2026-07-29: 60
- 2026-07-28: 59
- 2026-07-27: 58
- 2026-07-26: 58

## Links

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