DSAIL

Check claim values against a ruleset

dsail_check

Check extracted values against a written policy and get the same answer every time, with the rule that decided.

Use when reviewers disagree about applying decided rules to the same facts, or repeated reviews give inconsistent answers. Takes the ruleset and claim values extracted by the caller's own model.

Validates a claim dictionary and solves it against a ruleset, in one call.

Takes ruleset_hash (a compiled ruleset's content hash) or source. claims maps every declared claim name to a value; a claim that could not be determined is the string "unknown", which the rules treat as a first-class answer rather than a guess.

Returns every rule with the assertions it states, each carrying the engine's own result — TRUE (it holds), FALSE (it is violated), UNKNOWN (a claim it needs was not determined) or AMBIGUOUS (its evidence was contradicted), with the assertion's name and source text, and which claims had no value. AMBIGUOUS is reserved: it needs several answers for one claim, and a claim dictionary holds one, so no check sent here returns it. A rejected dictionary names every failing field at once as {field, expected, received}.

There is no overall verdict, by design: the four per-assertion words are the whole answer, and what a FALSE costs is a decision for whoever reads it.

This is the one metered call. It counts against the account's allowance of Jaxon Verified Units: one rule checked against up to 1,000 characters is one JVU, so a call carrying more rules or more text counts as more than one. When the allowance is used it answers ENTITLEMENT_EXCEEDED, and everything except checking keeps working.

Input Schema

Name	Required	Description
`label`	No	Optional application-domain label: `{"topic": "<a few words on what the policy governs>"}`, or `{"declined": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal.
`claims`	Yes	The claim dictionary to evaluate: one entry per declared claim, keyed by claim name, values as the prompt pack specifies (`"120 USD"`, `true`, `"unknown"` for a value the extractor could not determine). A JSON object, or the same object as a JSON string.
`source`	No	DSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled.
`ruleset_hash`	No	The content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both.

Output Schema

Name	Required	Description	Default
No arguments

Schema Changelog

Changes observed during successful MCP inspections.

Changed2 schema fields changedSep 25, 2026

changedOutput schema / description

Previous value: -"Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — with a counterexample where an assertion is violated. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it."New value: +"Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — each naming the assertion that decided it. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it."

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
-    "properties": {
-      "claims": {
-        "properties": {
-          "bound": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "quantities": {
-            "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
-            "items": {
-              "properties": {
-                "bound": {
-                  "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
-                  "type": "string"
-                },
-                "claim": {
-                  "type": "string"
-                },
-                "conversion": {
-                  "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
-                  "properties": {
-                    "by": {
-                      "const": "engine",
-                      "type": "string"
-                    },
-                    "factor": {
-                      "type": "number"
-                    },
-                    "from": {
-                      "type": "string"
-                    },
-                    "status": {
-                      "type": "string"
-                    },
-                    "to": {
-                      "type": "string"
-                    }
-                  },
-                  "required": [
-                    "from",
-                    "to",
-                    "by",
-                    "status"
-                  ],
-                  "type": "object"
-                },
-                "measured_in": {
-                  "description": "The claim's declared @unit, if any.",
-                  "type": [
-                    "string",
-                    "null"
-                  ]
-                },
-                "submitted": {
-                  "description": "The value as the caller sent it.",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "claim",
-                "submitted",
-                "bound",
-                "measured_in"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "unbound": {
-            "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          }
-        },
-        "required": [
-          "bound",
-          "unbound"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "rules": {
-        "items": {
-          "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
-          "properties": {
-            "assertions": {
-              "items": {
-                "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
-                "properties": {
-                  "check": {
-                    "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
-                    "enum": [
-                      "TRUE",
-                      "FALSE",
-                      "UNKNOWN",
-                      "AMBIGUOUS"
-                    ],
-                    "type": "string"
-                  },
-                  "counterexample": {
-                    "description": "The assignment that violates this assertion, from the solver. Present only on FALSE: for an UNKNOWN the solver's witness is merely a model in which the assertion could fail, and publishing it would state a determination this service did not make.",
-                    "type": "string"
-                  },
-                  "name": {
-                    "type": "string"
-                  },
-                  "reason_unknown": {
-                    "type": "string"
-                  },
-                  "source": {
-                    "type": [
-                      "string",
-                      "null"
-                    ]
-                  },
-                  "unbridged_units": {
-                    "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
-                    "items": {
-                      "properties": {
-                        "from": {
-                          "type": "string"
-                        },
-                        "to": {
-                          "type": "string"
-                        }
-                      },
-                      "required": [
-                        "from",
-                        "to"
-                      ],
-                      "type": "object"
-                    },
-                    "type": "array"
-                  },
-                  "unknown_policy": {
-                    "type": "string"
-                  }
-                },
-                "required": [
-                  "name",
-                  "check"
-                ],
-                "type": "object"
-              },
-              "type": "array"
-            },
-            "rule": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "rule",
-            "assertions"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "ruleset_hash": {
-        "type": "string"
-      },
-      "unit_library_hash": {
-        "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "ruleset_hash",
-      "unit_library_hash",
-      "rules",
-      "claims",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
+    "properties": {
+      "claims": {
+        "properties": {
+          "bound": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "quantities": {
+            "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
+            "items": {
+              "properties": {
+                "bound": {
+                  "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
+                  "type": "string"
+                },
+                "claim": {
+                  "type": "string"
+                },
+                "conversion": {
+                  "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
+                  "properties": {
+                    "by": {
+                      "const": "engine",
+                      "type": "string"
+                    },
+                    "factor": {
+                      "type": "number"
+                    },
+                    "from": {
+                      "type": "string"
+                    },
+                    "status": {
+                      "type": "string"
+                    },
+                    "to": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "from",
+                    "to",
+                    "by",
+                    "status"
+                  ],
+                  "type": "object"
+                },
+                "measured_in": {
+                  "description": "The claim's declared @unit, if any.",
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "submitted": {
+                  "description": "The value as the caller sent it.",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "claim",
+                "submitted",
+                "bound",
+                "measured_in"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "unbound": {
+            "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "bound",
+          "unbound"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "rules": {
+        "items": {
+          "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
+          "properties": {
+            "assertions": {
+              "items": {
+                "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
+                "properties": {
+                  "check": {
+                    "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
+                    "enum": [
+                      "TRUE",
+                      "FALSE",
+                      "UNKNOWN",
+                      "AMBIGUOUS"
+                    ],
+                    "type": "string"
+                  },
+                  "name": {
+                    "type": "string"
+                  },
+                  "reason_unknown": {
+                    "type": "string"
+                  },
+                  "source": {
+                    "type": [
+                      "string",
+                      "null"
+                    ]
+                  },
+                  "unbridged_units": {
+                    "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
+                    "items": {
+                      "properties": {
+                        "from": {
+                          "type": "string"
+                        },
+                        "to": {
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "from",
+                        "to"
+                      ],
+                      "type": "object"
+                    },
+                    "type": "array"
+                  },
+                  "unknown_policy": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "name",
+                  "check"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "rule": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "rule",
+            "assertions"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "ruleset_hash": {
+        "type": "string"
+      },
+      "unit_library_hash": {
+        "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "ruleset_hash",
+      "unit_library_hash",
+      "rules",
+      "claims",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changed5 schema fields changedSep 21, 2026

addedInput schema / properties / claims / description

Added value: +"The claim dictionary to evaluate: one entry per declared claim, keyed by claim name, values as the prompt pack specifies (`\"120 USD\"`, `true`, `\"unknown\"` for a value the extractor could not determine). A JSON object, or the same object as a JSON string."

addedInput schema / properties / label / description

Added value: +"Optional application-domain label: `{\"topic\": \"<a few words on what the policy governs>\"}`, or `{\"declined\": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal."

addedInput schema / properties / ruleset_hash / description

Added value: +"The content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both."

addedInput schema / properties / source / description

Added value: +"DSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — with a counterexample where an assertion is violated. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
+      "properties": {
+        "claims": {
+          "properties": {
+            "bound": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "quantities": {
+              "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
+              "items": {
+                "properties": {
+                  "bound": {
+                    "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
+                    "type": "string"
+                  },
+                  "claim": {
+                    "type": "string"
+                  },
+                  "conversion": {
+                    "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
+                    "properties": {
+                      "by": {
+                        "const": "engine",
+                        "type": "string"
+                      },
+                      "factor": {
+                        "type": "number"
+                      },
+                      "from": {
+                        "type": "string"
+                      },
+                      "status": {
+                        "type": "string"
+                      },
+                      "to": {
+                        "type": "string"
+                      }
+                    },
+                    "required": [
+                      "from",
+                      "to",
+                      "by",
+                      "status"
+                    ],
+                    "type": "object"
+                  },
+                  "measured_in": {
+                    "description": "The claim's declared @unit, if any.",
+                    "type": [
+                      "string",
+                      "null"
+                    ]
+                  },
+                  "submitted": {
+                    "description": "The value as the caller sent it.",
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "claim",
+                  "submitted",
+                  "bound",
+                  "measured_in"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "unbound": {
+              "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "bound",
+            "unbound"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "rules": {
+          "items": {
+            "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
+            "properties": {
+              "assertions": {
+                "items": {
+                  "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
+                  "properties": {
+                    "check": {
+                      "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
+                      "enum": [
+                        "TRUE",
+                        "FALSE",
+                        "UNKNOWN",
+                        "AMBIGUOUS"
+                      ],
+                      "type": "string"
+                    },
+                    "counterexample": {
+                      "description": "The assignment that violates this assertion, from the solver. Present only on FALSE: for an UNKNOWN the solver's witness is merely a model in which the assertion could fail, and publishing it would state a determination this service did not make.",
+                      "type": "string"
+                    },
+                    "name": {
+                      "type": "string"
+                    },
+                    "reason_unknown": {
+                      "type": "string"
+                    },
+                    "source": {
+                      "type": [
+                        "string",
+                        "null"
+                      ]
+                    },
+                    "unbridged_units": {
+                      "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
+                      "items": {
+                        "properties": {
+                          "from": {
+                            "type": "string"
+                          },
+                          "to": {
+                            "type": "string"
+                          }
+                        },
+                        "required": [
+                          "from",
+                          "to"
+                        ],
+                        "type": "object"
+                      },
+                      "type": "array"
+                    },
+                    "unknown_policy": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "name",
+                    "check"
+                  ],
+                  "type": "object"
+                },
+                "type": "array"
+              },
+              "rule": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "rule",
+              "assertions"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "ruleset_hash": {
+          "type": "string"
+        },
+        "unit_library_hash": {
+          "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "ruleset_hash",
+        "unit_library_hash",
+        "rules",
+        "claims",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

First observedSep 20, 2026

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Adds substantial context beyond the annotations: it is 'the one metered call' billed in Jaxon Verified Units with a stated 1 rule/1,000 chars ratio, returns ENTITLEMENT_EXCEEDED when the allowance is exhausted, and explains the failure shape {field, expected, received}. It also discloses that AMBIGUOUS is unreachable here because a claim dictionary holds one value per claim. The readOnlyHint=false is consistent with a metered compute call that consumes allowance rather than contradicting the description.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the purpose and usage condition before the mechanics, and every paragraph carries information. It is on the long side, and since an output schema exists, the detailed enumeration of per-assertion return words partially duplicates structured data.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers the full picture an agent needs: mutual-exclusive input selection, unknown-value handling, per-assertion result semantics, rejection shape, metering and quota exhaustion behavior. Nothing material is missing for a 4-parameter metered validation call.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: `ruleset_hash` vs `source` is mutually exclusive with a stated preference ('prefer the hash for anything already compiled'), and `claims` values like "unknown" are described as first-class answers rather than errors. `label` semantics are left to the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource — 'Check extracted values against a written policy' / 'Validates a claim dictionary and solves it against a ruleset' — and positions itself relative to the compile/load siblings by referencing `dsail_compile`. An agent can tell this apart from dsail_review and dsail_compile without opening a schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives a concrete triggering condition: 'Use when reviewers disagree about applying decided rules to the same facts, or repeated reviews give inconsistent answers.' That is clear context for invocation, but it names no alternative tool and states no when-not condition (e.g., how it differs from dsail_review).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

All DSAIL tools Inspect

Try in Browser

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

Glama MCP Gateway

Add one secure layer between your agents and this server.