disputes.online
Server Details
Read prediction disputes and the crowd's odds on real-world events from disputes.online.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- peccancy/mcp
- GitHub Stars
- 0
TDQS
Scored across 4 tools
Each tool has a mostly distinct purpose: get_dispute fetches a single dispute, list_categories supports category lookup, and the two search tools return open disputes. search_disputes and search_disputes_by_tags overlap in listing open disputes, but their filter vs. tag scopes are clearly described.
All tools use a consistent snake_case verb_noun pattern: get_dispute, list_categories, search_disputes, search_disputes_by_tags. The naming is predictable and readable throughout.
Four tools is well-scoped for a read-only dispute discovery surface. Each tool has a clear role, and there is no obvious redundant or missing tool at the count level.
The set covers single-dispute retrieval, category discovery, filtered search, and tag search. Minor gaps exist, such as no broad way to browse settled disputes or list available tags directly, but core discovery workflows are covered.
Available Tools
4 toolsget_disputeARead-onlyIdempotentInspect
Get one dispute from disputes.online by its id or page URL: the question, how it will be decided, the outcomes, how the stakes are split between them, and the deadlines. Also finds a dispute that has already been settled and returns which outcome won next to how the crowd had bet — use it to check a past prediction.
| Name | Required | Description | Default |
|---|---|---|---|
| dispute | Yes | the dispute's id (UUID) or the URL of its page on disputes.online |
Output Schema
| Name | Required | Description |
|---|---|---|
| id | Yes | dispute id (UUID) |
| url | Yes | the dispute's page on disputes.online; link this when citing |
| tags | Yes | lowercase tags |
| title | Yes | the question, taken from the first line of the description |
| status | Yes | new: no bets yet; in_process, hot, very_hot: accepting bets, by popularity; ready: betting closed, awaiting the result; done or dispute: decided but still being paid out or contested; settled: decided and archived, with the winning outcome marked |
| country | No | ISO 3166-1 alpha-2 country the dispute is about |
| category | No | category name |
| language | No | language code, or all; absent for a settled dispute |
| outcomes | Yes | the possible results and how the stakes are split between them — for a settled dispute, how they were split when it was decided |
| result_due | No | when the result is due, RFC 3339 UTC; absent for a settled dispute |
| settled_at | No | when the dispute was decided, RFC 3339 UTC; present only for a settled dispute |
| total_bets | Yes | number of bets placed |
| category_id | No | category id |
| description | Yes | the full text, including how the result will be decided |
| betting_closes | No | when betting closes, RFC 3339 UTC; absent for a settled dispute |
| dates_estimated | Yes | true when the event has no fixed date and the two dates are estimates |
| winning_outcome | No | name of the outcome that won; present only for a settled dispute that had a winner |
| total_staked_qot | Yes | pool size in QOT, the platform's internal currency — not dollars |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so the safety profile is covered. The description's field enumeration (question, outcomes, stakes, deadlines) largely restates what the output schema would carry; only the settled-dispute behavior (returns winning outcome alongside crowd bets) is genuinely additive. No auth or rate-limit context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two front-loaded sentences with the lookup key stated immediately and no filler. The middle field enumeration is somewhat list-heavy but each item is a distinct part of the dispute model.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained, and the description still covers input form, scope (single dispute), and a practical use case. Only the absence of guidance on what happens with an unknown or malformed id leaves a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the single parameter is already documented as 'the dispute's id (UUID) or the URL of its page'. The description repeats the same id-or-URL detail without adding format, validation, or resolution rules, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Get one dispute from disputes.online') and pins the retrieval key ('by its id or page URL'), which cleanly separates it from the sibling list/search tools that return collections.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a concrete usage scenario ('use it to check a past prediction') and notes it also resolves already-settled disputes, which is clear context for selection. It never names the alternative tools or states a when-not condition, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesARead-onlyIdempotentInspect
List the categories disputes on disputes.online are filed under, as a flat tree. Use it to find the category_id for a topic before calling search_disputes.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| categories | Yes | every category, as a flat list |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and openWorldHint=false, so safety is covered. The description adds useful behavioral context beyond that: the result is a flat tree structure, and the tool's role is to supply category_id values. It doesn't discuss ordering or size limits, but an output schema exists, so return detail is less critical.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero waste, with the purpose front-loaded and the practical usage instruction second. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no parameters, an output schema present, and annotations covering the safety profile, the description supplies exactly what is missing: what the tool lists, its flat-tree shape, and the workflow reason to call it. Nothing an agent needs before invoking it is absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. Full schema coverage (100%) and no required inputs mean no parameter risk remains.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and resource (categories) with scope ('disputes on disputes.online are filed under') and even the return shape ('flat tree'). An agent can distinguish this from search_disputes, search_disputes_by_tags, and get_dispute without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells the agent when to use it: to obtain the category_id for a topic before calling search_disputes, naming the downstream sibling. It lacks any when-not or alternative-selection guidance, but the usage context is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_disputesARead-onlyIdempotentInspect
List disputes on disputes.online that are open to bets, with each outcome's share of the stakes. Filter by language, category and country; sort by pool size, number of bets or closing time. Use it to find what people are currently predicting about a topic, or what the crowd thinks the odds are.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | language code of the disputes to return: en, ua, pl, de and so on. Defaults to en. Disputes marked all are always included. | |
| sort | No | amount (largest pool first; the default), bets (most bets first), closing_soon (betting closes soonest first), result_soon (result due soonest first) | |
| limit | No | page size, 1 to 20; defaults to 10 | |
| offset | No | number of disputes to skip, for paging | |
| country | No | ISO 3166-1 alpha-2 code of the country the dispute is about, for example US | |
| category_id | No | only disputes in this category or any category below it; ids come from list_categories |
Output Schema
| Name | Required | Description |
|---|---|---|
| total | Yes | number of disputes matching the request across all pages |
| offset | Yes | how many disputes were skipped before this page |
| disputes | Yes | this page of disputes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=false, so the safety and idempotency profile is covered. The description adds only the scoping fact that returned disputes are 'open to bets' — it says nothing about whether closed/resolved disputes are excluded wholesale, or how paging behaves across result sets.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight clauses: what is returned, what can be filtered/sorted, and why to use it. The capability statement is front-loaded and every sentence carries information — no boilerplate, no repetition of the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description needn't explain return values, and 100% parameter coverage handles the inputs; annotations carry the safety profile. What remains thin is paging/result-set behavior across limit/offset and whether non-open disputes are ever visible, but the definition is sufficient to call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents lang, sort, limit, offset, country and category_id in detail, including defaults and id ranges. The description's 'filter by language, category and country; sort by pool size, number of bets or closing time' merely paraphrases the schema without adding formats, ordering caveats or defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource — listing disputes that are 'open to bets' — and names the returned payload ('each outcome's share of the stakes'), which is a precise, non-tautological purpose. It implies its distinction from search_disputes_by_tags by enumerating its own filter axes, but never names a sibling, so an agent must infer the routing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit positive context: 'find what people are currently predicting about a topic, or what the crowd thinks the odds are.' That tells an agent when this tool is the right call. It stops short of exclusions or naming search_disputes_by_tags as the alternative for tag-driven queries, so no 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_disputes_by_tagsARead-onlyIdempotentInspect
Find open disputes on disputes.online by tag. Use it for a specific subject — a person, a team, an asset — when category and country are too coarse.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | language code of the disputes to return; defaults to en | |
| tags | Yes | one or more tags; a dispute carrying any of them matches. Tags are single lowercase words, for example election or bitcoin. | |
| limit | No | page size, 1 to 20; defaults to 10 | |
| offset | No | number of disputes to skip, for paging |
Output Schema
| Name | Required | Description |
|---|---|---|
| total | Yes | number of disputes matching the request across all pages |
| offset | Yes | how many disputes were skipped before this page |
| disputes | Yes | this page of disputes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and openWorldHint=false, so the safety profile is covered. The description adds a real behavioral trait not in the schema or annotations: that only *open* disputes are returned, which materially shapes results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, both earning their place: the first states scope, the second states when to reach for it over coarser filters. No repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described. The description covers scope, the open-status filter, and the selection context; only the explicit alternative tool name and paging context are absent, which is minor.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so tags, lang, limit, and offset are all documented in the schema itself (including the any-of matching rule). The description adds nothing beyond 'by tag', so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Find) and resource (open disputes by tag) with a named platform, and the second sentence positions it against the category/country-filtering sibling (search_disputes). An agent can tell this apart from search_disputes and list_categories without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear selection rule: use it for a specific subject (person, team, asset) when category and country are too coarse, which implicitly contrasts with the category/country-based sibling. It stops short of naming the alternative tool or stating when not to use this one.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
get_dispute - First observed
list_categories - First observed
search_disputes - First observed
search_disputes_by_tags
Related MCP Connectors
Prediction market data and crowd-sourced probability forecasts
Live prediction-market odds, volume and movers across 8 platforms. Read-only, no auth.
Sealed prediction-market verdicts, graded in public across Polymarket and Kalshi. No auth required.
Live Polymarket odds, order books, fee-inclusive quotes and non-custodial prediction trading.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceCalibrated probability forecasts for any resolvable question — with evidence, prediction-market edge (Polymarket/Kalshi), and a live resolved track record.MIT
- AlicenseNot gradedqualityBmaintenanceResolves prediction market events with confidence scores by aggregating news, price feeds, and web data, using pay-per-call x402 micropayments.MIT
- AlicenseAqualityBmaintenanceConnects real-world news to Polymarket prediction markets by matching headlines to relevant markets with live odds. Read-only by default with optional trading capabilities.5MIT
- AlicenseAqualityDmaintenanceAggregates prediction market data from 5 major platforms (Manifold, Polymarket, Metaculus, PredictIt, Kalshi), enabling users to search markets, compare odds across platforms, detect arbitrage opportunities, and track predictions through natural language.83MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.