MCP.Market

FIDE Laws of Chess MCP server

online · 100% uptime
by arxo.io·io.arxo/fide-chess·v0.1.1
No reviews yet

FIDE Laws of Chess (2023) as an executable model: arbiter cases, answers with rules and judgments

B84/100grade B
Write a reviewRun it
What users say
No reviews yet
Be the first
Safety scan
B84/100

full report

Adoption
Growing

0 stars

Reviews

Write one

Nobody has reviewed FIDE Laws of Chess yet.

If you have run it, two minutes of your experience saves the next person an afternoon.

FIDE Laws of Chess tools (16, 3 write)

write = sends, deletes, buys or posts
  • law_answer_capabilitiesFree

    A machine-readable matrix of the Lens producers that are actually installed, of replay/projection checks, profiles, limits and the contract tests that confirm them. declared_only means a schema with no executable witness.

  • law_askwrite actionFree

    Put a question to formalised law. When the answer is "not established" it carries whyNot — the engine's why_not report: the candidate rules and the state of every conjunct (satisfied / not satisfied / undetermined); the missing facts are visible there and need not be guessed. BEFORE THE FIRST call obtain the predicate names through law_search (a question in your own words → addresses) or law_packages (the signatures of a known instrument) — an invented name will be rejected. If the tool returned an error or "not established", THAT IS THE ANSWER: pass it to the user and do not substitute general knowledge about the law of some other country. But "I found no suitable instrument" is NOT an answer until law_search has been asked: silence of the catalogue is a property of searching by title, not a conclusion about the corpus. kind='truth' — whether a fact is established; kind='collect' — enumerate the records; kind='deadline' — compute a time limit on the official calendar; kind='positions' — which DUTIES arose from the facts and what their statuses are; kind='why_not' — the why_not report on the same goal, whatever the status of the answer. The answer carries the rules applied, the warnings and the provenance with hashes; truth/collect also carry a signature block for presentation. The server does not guess: where a norm is not formalised, the answer is "not established" or an error.

  • law_capture_answerwrite actionFree

    Run a registered producer and obtain producerControl/0.2 for a later verifiable preparation of a Lens. The producer is chosen only from the shipped registry.

  • law_case_askFree

    The ask operation: run a registered case of a case package over its pinned dependencies and return the answer: by default a projection of the evaluation document without the proof graph, on responseMode full or proof: true the canonical document with a proof and a manifest. The question is JSON per query.schema.json (query), an evaluate string (evaluate + queryId), a saved queryId without query, or card + args. A refusal to prepare is an error with an LDC-* code, never an empty answer.

  • law_explainFree

    Unfold the proof of a law_ask answer into a chain "rule ← premises → conclusion". The compact input: question (the original law_ask arguments, truth/collect), resultHash and codeHash from the provenance of the answer. The server repeats the computation and compares the hashes; if anything changed it refuses explicitly. Alternatively pass the evaluation from law_ask(proof=true). answerResource=fullAnswer.uri explains a stored compact snapshot without recomputing and without the client loading pages; by default only the proofRef chain. nodeId selects one node and all of its premises (up to 24 KB, otherwise an explicit refusal). proofHash refers to the whole graph; scope marks the part selected.

  • law_inspectFree

    Evaluation inspector over a SAVED evaluation document: summary — the origin card, resultHash and snapshot verification, listings of results, positions and issues; slice — the closure of proof nodes for a query, rule, position or node with addresses, both sides of BOTH, defeats, values, names resolved against the snapshot; diff — what changed between two documents on the context, result and justification levels; locate — the declaration by StableId. Nothing is evaluated or recomputed: the source is evaluation from law_ask(proof=true) or an answerResource. Missing data is a limit state (limits), never a negation.

  • law_packagesFree

    The catalogue of formalised law: instruments, predicates with signatures, the boundaries of coverage. This is where the NAMES of predicates come from — they must never be guessed. But do NOT start from the catalogue when looking for the right instrument: the overview is large, and the title of an instrument rarely matches the words of a question ("Newton's laws of motion" contains no word "physics"). A question in your own words goes to law_search first, which returns addresses; the catalogue is for the exact signature of what you found. With no arguments — the overview: one line per instrument (key, title, legal order, counters of rules, facts, signatures, norms, constants); a whole instrument — package="kz-gpk"; a search over the signatures, labels and constants of every instrument — query="substring". All three modes are PAGED: limit and offset, with the remainder named in the text (`showing a–b of N; k more`) and in structuredContent (total, truncated, next — a ready-made continuation call). The unit of a page is named by pageUnit: the overview and query page over INSTRUMENTS (20 and 20 by default), package=… pages over the SIGNATURES of one instrument (20 by default, 300 at most) — large codes carry thousands. package=… together with catalog=… pages a separate list of the instrument: "questions" — the CATALOGUE OF QUESTIONS: which enquiries are provided for (a question in words, a form, a predicate or norms) and what the instrument does NOT answer, with the type of reason; a card is a template of an enquiry, not an answer, and not every instrument has one; "norms" — the NORMS of the instrument, "constants" — the CONSTANTS (names of declarations). "task-guides" — TASK GUIDES: the order of applying a canon to a document — what to gather, which cards to ask and how to read the answers; a guide answers nothing. catalog="task-guides" is allowed without package too — every guide of the profile; guide=… — the detail of one guide; the walkthrough — MCP Prompts under the same name. The detail of an instrument prints a preview of these lists and names the count and the ready-made call for the mode.

  • law_passportFree

    Passport of an exact release: purpose, interface, boundaries, checks and performance. The reports section holds the history of measurements, failures included. Entries are paged by JSON Pointer; next continues the answer.

  • law_prepare_answerFree

    At the explicit request of the user, repeat between 1 and 12 earlier law_ask or law_process_run calls, compare their replayControl strictly, and prepare a non-public frozen document for 24 hours. The client never supplies the machine answer: the server obtains it only by executing afresh. A divergence in any input, in the law, in a resource, in the server code, in the engine library or in the result rejects the document as a whole.

  • law_publish_answerwrite actionFree

    Publish a prepared document. Repeating it with the same preparationId idempotently returns the same URL and the same separate revocation secret.

  • law_queryFree

    A deterministic LawQL query over the CLIR of a formalization: a question about the model of the act itself, not about a case. Relations (14): anchors, edges, fields, imports, interpretations, labels, links, literals, nodes, norms, positions, rules, variables, windows. Full field lists: `law query --schema`. Functions (9): anchor/1, labels/1..2, short/1, contains/2, overlaps/2, starts_with/2, ends_with/2, position/2, derivation/2. exists/not exists over a bound variable; equality and membership only, no arithmetic and no ordering comparisons. Scope: corpus by package.name (for example kz.corpus.labour_code, not a file name) or a glob; without corpus, the whole profile slice; a scope outside the profile is empty (CORPUS_EMPTY). Examples: `from r in rules where r.head_predicate == "urn:…#eligible" select r.id as producer, r.strength as strength, anchor(r.id) as anchors` — who produces; `from l in literals where l.predicate == "urn:…#eligible" select l.node as reader, l.context as context` — who reads; `query eligible over "pkg" { for x: Person; where applicant(x); select eligible(x); }` — inference by the core. This is orchestration over the CLIR and the core; no new legal semantics is implemented here. Instead of text, a question from the catalog with arguments: anchors-of, imports-of, links-of, producers, readers, type-step (see `law query --list` for the set) (predicate/node/type parameters are URNs, pkg is a package.name or a glob). A structural answer is a queryPage: resultHash of the full queryResult, snapshot (hash of the scope package list), rowCount, rows by rowLimit (20, at most 5000) and rowOffset, next with the snapshot for continuation; full: true returns the full queryResult when the scope is one package. Every row carries provenance (CLIR nodes); an empty answer carries the explain funnel (emptyAt names the clause); errors carry LDC-Qxxxx codes with hints; a source product too wide is refused before execution (QUERY_TOO_BROAD), a continuation on another snapshot as SNAPSHOT_CHANGED.

  • law_revoke_answerFree

    Revoke a published document using its separate secret. The public id alone grants no control; revocation closes the HTML page, the API and the download.

  • law_rulesFree

    The rules of formalised law put into words: exactly how a predicate is derived (premises, source articles). Call this BEFORE supplying facts to law_ask — the rules say which facts are needed instead of leaving them to be guessed. For large instruments package=… returns a table of contents; the full text comes from predicate=…. The listing by package is paged: limit (20 by default, 500 at most) and offset; the remainder is named in the text (`showing a–b of N; k more`) and in structuredContent (total, truncated, next — a ready-made continuation call).

  • law_screenFree

    Build a necessary condition — a superset — for the preliminary selection of rows from an external source. This is NOT a legal answer and NOT SQL: the result is a typed tree and a manifest of the extensions up to TRUE. Every row that passes must then be computed in full by the engine, with a proof graph, on the same snapshot of the data. The binding is passed as a pinnable object; sourceSchemaContentHash is the actual hash of the source schema and is compared loudly with the pin. Case facts that carry provenance (origin, document, quote, extractor) are supplied to law_ask, not here. The confidence figure is read by the package EvidencePolicy, not by this tool and not by the engine.

  • law_searchFree

    A semantic SEARCH over formalised law: a question or a notion in your own words → candidates with addresses — predicates with signatures, rules, article fragments. This is the layer of DISCOVERY, not of the answer: the result says WHAT to ask next (law_ask by signature, law_rules, law_sources) and establishes neither a fact nor a norm. The ranking is a deterministic lexical embedder, and similarity of text is not applicability of a norm. If you know the exact name, go straight to law_packages/law_ask; an empty result does NOT mean the norm does not exist.

  • law_sourcesFree

    Sources: by default short excerpts (view=summary), 5 texts per page, with the address of the full text in fragments[].full. Either package or fragment is required (a StableId from law_search/law_rules). view=full returns exact parts of the text: textRange sets a range of Unicode characters, fragments[].next is the continuation with a contentHash. The hash refers to the WHOLE source, not to the excerpt or the part. textOffset/textLimit require fragment; a continuation requires contentHash. Lists are paged with offset/limit; the answer budget may shrink a page.

Public scan report

scanner v0.1.10 · 2026-10-14 · same rubric, same numbers if you re-run it

1 high1 low
  • Code scan11 source files scanned25/25
  • Live reliabilityremote reachable in 1075ms20/20
  • Tool poisoning16 tool descriptions checked13/15
  • Auth qualityopen endpoint exposes 3 write-action tools with no auth3/15
  • Maintenancelast push 0 days ago15/15
  • Maintainer identityendpoint served from the registry-verified namespace domain8/10

Findings (2)

  • highWrite-action tools reachable without authenticationauth.open-write
  • lowUnusually long tool description (over 2,000 characters)poison.long-description
    tool law_packages: …The catalogue of formalised law: instruments, predicates with signatures, the boundaries of coverage. This is where the NAMES of predicates come from — they must never be guessed. But do NOT start from the catalogue when looking for the right instrument: the overview is large, and the title of an instrument rarely matches the words of a question ("Newton's laws of motion" contains no word "physics"). A question in your own words goes to law_search first, which returns addresses; the catalogue is for the exact signature of what you found. With no arguments — the overview: one line per instrument (key, title, legal order, counters of rules, facts, signatures, norms, constants); a whole instrument — package="kz-gpk"; a search over the signatures, labels and constants of every instrument — query="substring". All three modes are PAGED: limit and offset, with the remainder named in the text (`showing a–b of N; k more`) and in structuredContent (total, truncated, next — a ready-made continuation call). The unit of a page is named by pageUnit: the overview and query page over INSTRUMENTS (20 and 20 by default), package=… pages over the SIGNATURES of one instrument (20 by default, 300 at most) — large codes carry thousands. package=… together with catalog=… pages a separate list of the instrument: "questions" — the CATALOGUE OF QUESTIONS: which enquiries are provided for (a question in words, a form, a predicate or norms) and what the instrument does NOT answer, with the type of reason; a card is a template of an enquiry, not an answer, and not every instrument has one; "norms" — the NORMS of the instrument, "constants" — the CONSTANTS (names of declarations). "task-guides" — TASK GUIDES: the order of applying a canon to a document — what to gather, which cards to ask and how to read the answers; a guide answers nothing. catalog="task-guides" is allowed without package too — every guide of the profile; guide=… — the detail of one guide; the walkthrough — MCP Prompts under the same name. The detail of an instrument prints a preview of these lists and names the count and the ready-made call for the mode.…
Overall 84/100. Components that don't apply are left out of the denominator. Any critical finding is an F.RubricAppeal a findingJSON

How FIDE Laws of Chess compares

Against every graded AI and agents MCP server, from our own scans and uptime checks. Updated after each scan run.

Safety score
84/100
higher than 70% of 4,460 AI and agents servers
Tools
16
the typical AI and agents server has 6
Tools that change things
19%
typical: 0%. Fewer write tools means less an agent can break
Uptime
100%
of our recent checks; the typical remote AI and agents server answers 100%
Response time
44 ms
faster than 96% of 2,331 AI and agents servers

What its tools let an agent do: 13 read · 3 change

Install FIDE Laws of Chess in Claude Code, Cursor or VS Code

claude mcp add --transport http fide-chess https://mcp.arxo.io/mcp/fide-chess
Add to Cursor

What the publisher says

From the FIDE Laws of Chess repository's README, as published. We do not edit it. Read it on GitHub

FIDE Laws of Chess on Arxo

Explore a chess arbiter's decision through a pinned model, explicit facts and an inspectable answer. Ten retained fictional cases cover illegal moves, flag fall, rapid/blitz exceptions, recording and arbiter judgment.

Node.js 20+ · ESM · canon package 0.1.0 · model 0.1.1 · FIDE edition effective 1 January 2023

Start in Node.js · Cases · Evidence · Depth · Submit a case · Source repository

This is an independent open-source teaching and research demonstration. For an actual chess ruling, use the authentic FIDE Laws and the competent arbiter. Source text and model scope are pinned; the package does not claim general chess-engine capability or complete formalization.

Start in Node.js

Requirements: Node.js 20+. The example uses ES modules; keep the .mjs extension. This recipe was checked on macOS arm64 with Node.js 20.20.2 on 14 October 2026. No global CLI, Git clone or MCP client is needed for this route.

Create a fresh directory, open a terminal there, then run:

npm init -y
npm install --ignore-scripts @arxo/canon-fide-chess@0.1.0 @arxo/law@0.4.3

Save this as example.mjs, then run node example.mjs:

import { open } from '@arxo/law';
import { loadModel } from '@arxo/canon-fide-chess/chess';
import { game, white, getCaseInput } from '@arxo/canon-fide-chess/examples/arbiter';

const model = await loadModel();
const chess = await open(model.spec, {
  offline: true,
  local: { packages: { [model.spec]: model.package } },
});

const input = getCaseInput('SecondIllegal');
const loss = await chess.truth('game_lost_by', [game, white], input);
const draw = await chess.truth('game_drawn', [game], input);
console.log(loss.evaluationStatus, loss.truthStatus); // COMPUTED, TRUE_ONLY
console.log(draw.evaluationStatus, draw.truthStatus); // COMPUTED, NEITHER

The two output lines are loss, then draw:

COMPUTED TRUE_ONLY
COMPUTED NEITHER

COMPUTED means the query was evaluated. TRUE_ONLY means it has positive support and no negative support. NEITHER means neither polarity is supported; it does not establish that the proposition is false.

Now replace only getCaseInput('SecondIllegal') with getCaseInput('SecondIllegalNoMate') and run node example.mjs again:

REQUIRES_JUDGMENT NEITHER
COMPUTED TRUE_ONLY

The second line now establishes a draw. This case supplies the fact that the opponent cannot checkmate by any legal series. The separate loss query still requests an arbiter's assessment because other reachable loss grounds remain unresolved. Read both status fields; REQUIRES_JUDGMENT identifies an assessment the model does not decide on its own.

To try another retained episode, choose a name from the case table. To propose your own episode, open an issue with the case facts, legal date, query, package/runtime versions, output and the FIDE clause or model rule you think should give a different answer. Use a fictional or anonymized case.

The SDK executes the rules through @arxo/law-engine@0.5.3. Installation alone does not register this distribution in the SDK's automatic canon resolver: keep the explicit local.packages handoff above. The loader implements no chess decisions or formulas.

Use as an MCP server

The separate native MCP wrapper runs the same pinned model over stdio:

npx -y @arxo/mcp-fide-chess@0.1.0

Shortened. The full README is on GitHub.

Nothing above is checked by us. What we check is on the safety report.

FIDE Laws of Chess: common questions

Is FIDE Laws of Chess MCP server safe?
Mostly: it is graded B (84/100). Read the FIDE Laws of Chess safety report
How do I install FIDE Laws of Chess?
It runs remotely at mcp.arxo.io. Add it to Claude Code, Cursor, VS Code or Claude Desktop with the snippets above, or call it through the mcp.market gateway without installing anything.
Does FIDE Laws of Chess need an API key?
No secret keys are declared. It reads 1 setting from the environment.
Is FIDE Laws of Chess maintained?
The last commit was 20 days ago (2026-10-14). The latest release is v0.1.1.
Is FIDE Laws of Chess up?
100% of our last 28 checks got an answer. We check remote servers about four times a day.
What can I use instead of FIDE Laws of Chess?
Servers from other publishers that do the same job: Roast My Design System MCP server, Roast My Design System MCP server and Tw Legal Rag MCP server.
How does FIDE Laws of Chess compare with other AI and agents MCP servers?
safety score 84/100 (higher than 70% of 4,460 AI and agents servers); tools 16 (the typical AI and agents server has 6); tools that change things 19% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.

Alternatives to FIDE Laws of Chess

Same job from other publishers: the closest match first, then the best rated.

  • Roast My Design System
    Audit your Design System and serve your Agent the rules that keep AI-written UI on-system.
    A
  • Roast My Design System
    Audit your Design System and serve your Agent the rules that keep AI-written UI on-system.
    A
  • Tw Legal Rag
    Citation-guarded retrieval over 22M Taiwan court judgments and administrative interpretations
    A

More from arxo.io →