[{"slug":"ZV-2026-0066","server_name":"agentery.com","severity":"breaking","title":"agentery.com: Tool niche_report was removed.","summary":"[breaking] Tool niche_report was removed. [breaking] Tool find_niche was renamed to find_market. [safe] Tool market_report was added. [safe] Description of compare_providers changed (4% word delta). [safe] Description of create_custom_benchmark changed (2% word delta). [safe] Description of demand_signals changed (4% word delta). [risky] Description of find_niche changed (66% word delta). [risky] Description of get_price_index changed (43% word delta). [breaking] Field niche was removed from get_price_index input; consumers still sending it may be rejected or silently ignored. [breaking] Field scope was removed from get_price_index input; consumers still sending it may be rejected or silently ignored. [risky] Description of get_price_index_history changed (38% word delta). [breaking] Field niche was removed from get_price_index_history input; consumers still sending it may be rejected or silently ignored. [breaking] Field scope was removed from get_price_index_history input; consumers still sending it may be rejected or silently ignored. [risky] Description of market_gaps changed (86% word delta). [risky] Description of price_benchmark changed (71% word delta). [risky] Description of research_capability changed (45% word delta). [safe] Description of suggest_alternatives changed (21% word delta).","changes":[{"kind":"tool_removed","tool":"niche_report","detail":"Tool `niche_report` was removed.","severity":"breaking"},{"kind":"tool_renamed","tool":"find_niche","after":"find_market","before":"find_niche","detail":"Tool `find_niche` was renamed to `find_market`.","severity":"breaking"},{"kind":"tool_added","tool":"market_report","detail":"Tool `market_report` was added.","severity":"safe"},{"kind":"description_changed","tool":"compare_providers","after":"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-market competitors — its nearest providers by text-embedding — (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 provider type. 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.","before":"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.","detail":"Description of `compare_providers` changed (4% word delta).","severity":"safe","descriptionDelta":0.043749999999999956},{"kind":"description_changed","tool":"create_custom_benchmark","after":"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 market_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.","before":"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.","detail":"Description of `create_custom_benchmark` changed (2% word delta).","severity":"safe","descriptionDelta":0.02298850574712641},{"kind":"description_changed","tool":"demand_signals","after":"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 market_report/market_gaps to size the gap. Empty args ({}) return the current ranked unmet-demand list.","before":"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.","detail":"Description of `demand_signals` changed (4% word delta).","severity":"safe","descriptionDelta":0.039215686274509776},{"kind":"description_changed","tool":"find_niche","after":"Map a natural-language task, capability or service to its live MARKET — the semantic neighbourhood of the closest-matching providers, found by text-embedding nearness (NO fixed niche or category). For buyers ('a provider that monitors competitor pricing'), sellers ('what should I charge for lead-generation automation') or sizing a space. Pricing-intent boilerplate is stripped before matching. Returns the market label, how many providers are in the neighbourhood and how many are priced, `nearest` (the closest providers with observed price and relevance/cosine), and `pricing_by_tier` — median, mean, stdev, p25/p75, min–max range and n per buyer tier (individual/pro/team_sme/enterprise), computed by the canonical pricing engine over the priced neighbourhood. match_certainty is 'confident' when real neighbours exist and 'uncertain' when nothing is close (pricing WITHHELD). Accepts `task` (aliases: query, q). For the full market read + shortlist in ONE call, use research_capability instead. Read-only.","before":"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: query, q). For the full market read + pricing + provider shortlist in ONE call, use research_capability instead. Read-only.","detail":"Description of `find_niche` changed (66% word delta).","severity":"risky","descriptionDelta":0.6590909090909092},{"kind":"description_changed","tool":"get_price_index","after":"Call this for the CURRENT level of the Agent Economy Price Index (AEPI) — 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. Returns the whole-economy 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). `provider_type` returns the standalone index for one delivery type (provider or mcp, own base 100) — agents and MCPs price and move differently. `tier` filters to one buyer tier; response_mode 'full' adds exact sub-0.01% moves and repricing counts. Reads the SAME canonical series as the /aepi page, so the MCP and website agree for a given timestamp. (Also accepts a `benchmark_id` to read a private custom benchmark's current index.) The economy index is whole-market by design — for pricing on a specific capability use market_report or price_benchmark.","before":"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.","detail":"Description of `get_price_index` changed (43% word delta).","severity":"risky","descriptionDelta":0.43356643356643354},{"kind":"input_property_removed","path":"inputSchema.properties.niche","tool":"get_price_index","before":{"type":"string","description":"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."},"detail":"Field `niche` was removed from `get_price_index` input; consumers still sending it may be rejected or silently ignored.","severity":"breaking"},{"kind":"input_property_removed","path":"inputSchema.properties.scope","tool":"get_price_index","before":{"enum":["aepi","niche"],"type":"string","description":"'aepi' (default) = whole-economy headline + the four buyer tiers; 'niche' = one niche's index."},"detail":"Field `scope` was removed from `get_price_index` input; consumers still sending it may be rejected or silently ignored.","severity":"breaking"},{"kind":"description_changed","tool":"get_price_index_history","after":"Call this for the canonical DATED index SERIES (to chart or analyse movement) of the AEPI — the same chained like-for-like series the /aepi page plots. Every point is an index level (base 100), never a price. Returns the whole-economy headline series, or a single buyer tier's series when `tier` is set. `provider_type` returns the standalone 'agent' / 'mcp' series (own base 100). `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) rather than a fabricated series when data is too thin. (Also accepts a `benchmark_id` to read a private custom benchmark's history.) The economy index is whole-market by design — for pricing on a specific capability use market_report or price_benchmark.","before":"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.","detail":"Description of `get_price_index_history` changed (38% word delta).","severity":"risky","descriptionDelta":0.38235294117647056},{"kind":"input_property_removed","path":"inputSchema.properties.niche","tool":"get_price_index_history","before":{"type":"string","description":"For scope 'niche': a canonical niche slug or natural-language query."},"detail":"Field `niche` was removed from `get_price_index_history` input; consumers still sending it may be rejected or silently ignored.","severity":"breaking"},{"kind":"input_property_removed","path":"inputSchema.properties.scope","tool":"get_price_index_history","before":{"enum":["aepi","niche"],"type":"string","description":"'aepi' (default) or 'niche'."},"detail":"Field `scope` was removed from `get_price_index_history` input; consumers still sending it may be rejected or silently ignored.","severity":"breaking"},{"kind":"description_changed","tool":"market_gaps","after":"Find where real demand is going unmet — computed demand-first in the raw text-embedding space (NO niches). A gap = a cluster of real user requests (mined from live MCP search telemetry) that sits FAR from any PAID provider. For each gap it returns: the demand phrasing, demand_mass (how many similar requests cluster with it), nearest_paid_similarity (cosine to the closest paid provider — low = under-served) and that closest paid provider. Also returns demand_queries and paid_supply counts. Honestly returns few or no gaps while query volume is still low — it sharpens as usage grows. No arguments needed ({}); `limit` caps the list.","before":"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.","detail":"Description of `market_gaps` changed (86% word delta).","severity":"risky","descriptionDelta":0.8582089552238806},{"kind":"description_changed","tool":"price_benchmark","after":"Fair-price benchmarks for a capability described in natural language. The MARKET is the semantic neighbourhood of your query — the nearest providers by text embedding, with NO fixed niche or category — SEPARATED BY provider type (provider / mcp) and buyer tier (individual / pro / team_sme / enterprise). Each cohort reports median, mean, stdev, p25/p75, min–max range and n; 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 populated per-type/per-tier cohort matrix. Prices come from the canonical pricing engine run over the priced members of the neighbourhood, so the figures match the rest of the site to the digit. Pass `query` (the natural-language capability); `niche` and `task` are accepted as aliases for the query text. When nothing priced is semantically close it returns resolved:false with a note, never a fabricated figure.","before":"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.","detail":"Description of `price_benchmark` changed (71% word delta).","severity":"risky","descriptionDelta":0.7073170731707317},{"kind":"description_changed","tool":"research_capability","after":"START HERE for provider procurement. ONE call turns a task into: (1) its live MARKET — the semantic neighbourhood of the closest-matching providers, found purely by text-embedding nearness (NO fixed niche or category), with the relevance floor and how many providers cleared it; (2) current pricing context — comparable price range and median with mean, stdev and n, plus provider/priced 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`. Retrieval is 100% nearest-neighbour by text embedding: providers are matched on what they actually DO, never on an assigned label. REUSES the canonical pricing/search engines (no new pricing logic). Also returns `suggested_alternatives` (cheaper or stronger options) 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_market, market_report, price_benchmark, search_providers) for finer control. Aliases: `task` also accepts `query` / `q`.","before":"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`.","detail":"Description of `research_capability` changed (45% word delta).","severity":"risky","descriptionDelta":0.4545454545454546},{"kind":"description_changed","tool":"suggest_alternatives","after":"Call this when a shortlisted provider is too expensive, unreachable or a poor fit: substitutes for one known provider, ranked by text-embedding nearness to that provider's OWN profile — the closest-matching providers first (NO niche lookup) — 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.","before":"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.","detail":"Description of `suggest_alternatives` changed (21% word delta).","severity":"safe","descriptionDelta":0.21250000000000002}],"published_at":"2026-08-16T21:38:35.549Z"}]