# DSAIL, for agents

Turn a written policy into rules a program can check, and get the same answer every time. What DSAIL is, what it answers, and the one-page route in from each surface.

DSAIL takes a policy written in English, turns it into a formal ruleset, and
returns — for every assertion in that ruleset — exactly one of four results over
the claim values you extract from a document: `TRUE`, `FALSE`, `UNKNOWN` or
`AMBIGUOUS`. A `FALSE` comes with the rule that decided, with a counterexample.
Given the same ruleset and the same claim values, the bytes that come back are
identical every time, through every door.

There is no model in the loop. The service never calls a language model: **you**
extract the claim values, on your own model, using the prompt pack the service
generates from the ruleset. What crosses the wire is a schema-bounded claim
dictionary, never the document.

## What it is for

- You have a written policy — an expense rule, an underwriting threshold, a
  release checklist, a records-retention clause — and you need a program to
  check extracted values against a written policy and get the same answer every time.
- You need to say **which rule** failed and **why**, to a person who will ask.
- Some of the facts a rule needs will be missing from the document, and
  "missing" must stay distinguishable from "false": unknown is an answer, not a guess.
- You do not want a second language model judging the first one's output.

## What it is not

Not an authorization engine (see [OPA](compare/opa.md) and
[Cedar](compare/cedar.md)); not an output filter or jailbreak defence (see
[guardrail frameworks](compare/guardrails.md)); not a document store; not an
extraction service. It compiles rules and solves them, and it stops there.

## The route in, per surface

Each quickstart is install, one command, a result.

| You are working in | Page |
| --- | --- |
| claude.ai (a custom connector) | [Quickstart: claude.ai](quickstart/claude-ai.md) |
| ChatGPT (a private app) | [Quickstart: ChatGPT](quickstart/chatgpt.md) |
| Claude Code | [Quickstart: Claude Code](quickstart/claude-code.md) |
| Codex CLI | [Quickstart: Codex](quickstart/codex.md) |
| Anything that speaks HTTP | [Quickstart: REST](quickstart/rest.md) |

## The sequence, always

1. Restate the policy in plain English and get the user's confirmation before
   writing any DSAIL.
2. `compile` the DSAIL source until it is clean. The result is a content hash
   that addresses exactly these bytes, plus the claim manifest: every question a
   document will be asked.
3. Show the ruleset to a person (`review`), and record their approval against
   the hash.
4. Fetch the prompt pack, run the extraction on your model, and `check` the
   claim dictionary. Read each assertion's result in the rules' own four words.

## Contract, before you connect

- [REST API reference](reference/rest-api.md), rendered from the OpenAPI document
- [MCP tools reference](reference/mcp-tools.md), every tool as a model sees it
- [MCP server instructions](reference/server-instructions.md), verbatim
- [Error codes](reference/errors.md), one page per code; every error carries the URL of its page

Every page here is markdown; `llms.txt` at the root lists all of them.