Ontario law your agent can call.

The tools

23 operations of Ontario law and 11 tools for handoffs, bookings and checking the law. Each is an MCP tool, a REST endpoint and a line in /openapi.json, with the same price everywhere.

MCP

The server is at https://mithril.law/mcp (Streamable HTTP). It speaks protocol 2026-07-28 and, for older clients, 2025-11-25, 2025-06-18, 2025-03-26. Listing the tools never needs sign-in, and the free ones run without it.

https://mithril.law/mcp

https://mithril.law/mcp

claude mcp add --transport http mithril https://mithril.law/mcp

{
  "mcpServers": {
    "mithril": {
      "url": "https://mithril.law/mcp"
    }
  }
}

{
  "servers": {
    "mithril": {
      "type": "http",
      "url": "https://mithril.law/mcp"
    }
  }
}

import {
  Client,
  StreamableHTTPClientTransport,
} from "@modelcontextprotocol/client";

const client = new Client(
  { name: "my-agent", version: "1.0.0" },
  { versionNegotiation: { mode: "auto" } },
);
await client.connect(
  new StreamableHTTPClientTransport(
    new URL("https://mithril.law/mcp"),
  ),
);

const { tools } = await client.listTools();
const run = await client.callTool({
  name: "employment_severance_check",
  arguments: {
    "endedHow": "let_go_without_cause",
    "endDate": "2026-09-01",
    "yearsOfService": 10,
    "monthsOfService": 11,
    "age": 45,
    "role": "staff",
    "pay": { "kind": "salary", "annualSalary": 104000 },
    "payroll": "yes",
    "hasBenefits": true,
    "terminationClause": "no",
    "exemptions": [],
    "workingNoticeWeeks": 0,
    "massTermination": "no",
    "businessClosure": "no"
  },
});
console.log(run.structuredContent);

import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def main():
    async with streamablehttp_client(
        "https://mithril.law/mcp"
    ) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print([t.name for t in tools.tools])

asyncio.run(main())

Tools

One per operation, named after it with dots as underscores (employment_severance_check), plus handoff_create, handoff_status, slots_list, booking_hold, receipt_verify, rules_search, rule_get, catalog, retainer_quote, retainer_retain and mandate_status.

Resources

mithril://rules/{id}, mithril://sources/{id}, mithril://receipts/{id} and mithril://catalog.

Prompts

i_was_let_go, i_got_an_n4, someone_was_arrested and starting_a_company.

Missing facts

Declare form elicitation in your client’s capabilities and a call with facts missing comes back input_required (2026-07-28), with a form asking exactly what the law needs. Show it to the person, then call again with their answers in inputResponses and the requestState you were given. The playground shows the exchange: choose MCP and clear a fact. An older client gets an error naming each missing fact. Ask the person; never fill one in yourself.

One URL

An agent that can only fetch a URL gets the same answer. Add .md to a tool’s address and put the facts in the query string. The answer comes back as markdown: the summary, each step with its section, the boundary and the receipt.

https://mithril.law/employment/severance-check.md?endedHow=let_go_without_cause&endDate=2026-09-01&yearsOfService=10&monthsOfService=11&age=45&role=staff&pay.kind=salary&pay.annualSalary=104000&payroll=yes&hasBenefits=true&terminationClause=no&workingNoticeWeeks=0&massTermination=no&businessClosure=no

• Facts go in as dotted parameters (pay.annualSalary=104000), lists as repeated parameters, or all at once as facts=<url-encoded JSON>.
• If a fact is missing, nothing is run. The answer names each missing fact, with an example, and gives the URL to fetch next.
• Names and addresses never go in a URL. Tools that need them say how to go on: by POST, by MCP, or on their page.
• /llms.txt lists a working URL for every tool. Every page on the site has a markdown version: add .md, or ask for text/markdown.

REST

Every run returns the answer, a summary you can repeat, the steps with their citations, the boundary, the law it relied on and a signed receipt. Send an Idempotency-Key and say who you are with Mithril-Agent.

curl -X POST \
  https://mithril.law/api/v1/operations/employment.severance_check/runs \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Mithril-Agent: my-agent/1.0" \
  -d '{
  "input": {
    "endedHow": "let_go_without_cause",
    "endDate": "2026-09-01",
    "yearsOfService": 10,
    "monthsOfService": 11,
    "age": 45,
    "role": "staff",
    "pay": { "kind": "salary", "annualSalary": 104000 },
    "payroll": "yes",
    "hasBenefits": true,
    "terminationClause": "no",
    "exemptions": [],
    "workingNoticeWeeks": 0,
    "massTermination": "no",
    "businessClosure": "no"
  }
}'

{
  "error": {
    "code": "invalid_input",
    "message": "Some facts are missing or not in the right form.",
    "hint": "…",
    "details": [
      { "path": "endDate", "message": "…" }
    ]
  },
  "requestId": "req_…"
}

Every operation, with its schema, price and verification status ↗
OpenAPI 3.1, with a real example response for each ↗

Typed clients

One file for TypeScript and one for Python, generated from /openapi.json: a method for each of the 23 operations, with its facts and its answer typed and its price in the doc comment. Neither needs a package: TypeScript uses fetch, Python the standard library.

curl -O https://mithril.law/agents/sdk/mithril.ts

import { Mithril } from "./mithril";

const mithril = new Mithril();
const run = await mithril.employmentSeveranceCheck({
  "endedHow": "let_go_without_cause",
  "endDate": "2026-09-01",
  "yearsOfService": 10,
  "monthsOfService": 11,
  "age": 45,
  "role": "staff",
  "pay": { "kind": "salary", "annualSalary": 104000 },
  "payroll": "yes",
  "hasBenefits": true,
  "terminationClause": "no",
  "exemptions": [],
  "workingNoticeWeeks": 0,
  "massTermination": "no",
  "businessClosure": "no"
});
console.log(run.result.summary, run.receipt.url);

curl -O https://mithril.law/agents/sdk/mithril.py

from mithril import Mithril

mithril = Mithril()
run = mithril.employment_severance_check({
  "endedHow": "let_go_without_cause",
  "endDate": "2026-09-01",
  "yearsOfService": 10,
  "monthsOfService": 11,
  "age": 45,
  "role": "staff",
  "pay": { "kind": "salary", "annualSalary": 104000 },
  "payroll": "yes",
  "hasBenefits": True,
  "terminationClause": "no",
  "exemptions": [],
  "workingNoticeWeeks": 0,
  "massTermination": "no",
  "businessClosure": "no"
})
print(run["result"]["summary"], run["receipt"]["url"])

A missing fact comes back as MithrilError with code invalid_input and the facts to ask for in missing. Each file names the surface version it was built from; download it again when a tool’s version changes.

The boundary

Every answer says where the software stopped, and lists the next steps as actions you can call.

1. automated

   Done by the software. Nothing waits on the person or a lawyer.

2. needs_person

   The person has to act: sign, serve, or file from their own account. Pass the steps to them.

3. needs_lawyer

   Stop. Don’t answer the legal question yourself. Offer to hand the matter to me.

An agent at the boundary, step by step ↑

The handoff

POST /api/v1/handoffs (MCP handoff_create) with the area, a summary in the person’s words, the person, everyone on the other side and the run. You get a consent link for the person. I check the names against my practice records and this site’s records. If there is a conflict, the person is referred elsewhere and you never learn why.

{
  "area": "employment",
  "kind": "consultation",
  "summary": "Let go after 10 years, offered 8 weeks.",
  "person": {
    "name": "…",
    "email": "…"
  },
  "parties": [
    { "name": "…", "role": "employer" }
  ],
  "runId": "run_…"
}

{
  "object": "handoff",
  "id": "hof_…",
  "status": "awaiting_person",
  "consentUrl": "https://mithril.law/continue/…",
  "agentInstructions": "Give this link to the person …"
}

Send one in the sandbox ↑

Receipts

Every run is signed with the site’s Ed25519 key (JWS, EdDSA). The receipt holds hashes of the facts and the answer, not the facts. Anyone can check it against /.well-known/jwks.json, and the verification register shows each rule it names.

import {
  compactVerify,
  createRemoteJWKSet,
} from "jose";

const jwks = createRemoteJWKSet(
  new URL("https://mithril.law/.well-known/jwks.json"),
);
const { payload } = await compactVerify(
  receipt.jws,
  jwks,
);
const { mithril } = JSON.parse(
  new TextDecoder().decode(payload),
);

When a rule changes, earlier runs that used it are marked superseded and you get run.superseded. Don’t repeat a superseded answer: run the operation again. POST /api/v1/receipts/verify answers all of this in one call.

Webhooks

POST /api/v1/webhooks with an API key, a public https URL and the events you want. The secret is shown once. Each delivery is signed Mithril-Signature: t=<unix>,v1=<hex>, an HMAC-SHA256 of t.rawBody. Reject anything older than five minutes.

import { createHmac, timingSafeEqual } from "node:crypto";

// secret: the whsec_… value shown once when you created the endpoint.
// header: the Mithril-Signature request header. body: the raw request body, as a string.
export function verifyMithrilSignature(secret, header, body, toleranceSeconds = 300) {
  const parts = Object.fromEntries(header.split(",").map((p) => p.trim().split("=", 2)));
  const t = Number(parts.t);
  if (!Number.isInteger(t) || Math.abs(Date.now() / 1000 - t) > toleranceSeconds) return false;
  const expected = createHmac("sha256", secret).update(`${t}.${body}`).digest("hex");
  return header.split(",").map((p) => p.trim()).filter((p) => p.startsWith("v1=")).some((p) => {
    const given = Buffer.from(p.slice(3));
    return given.length === expected.length && timingSafeEqual(given, Buffer.from(expected));
  });
}

import hmac, hashlib, time

def verify_mithril_signature(secret: str, header: str, body: bytes, tolerance: int = 300) -> bool:
    parts = dict(p.strip().split("=", 1) for p in header.split(","))
    t = int(parts.get("t", "0"))
    if abs(time.time() - t) > tolerance:
        return False
    expected = hmac.new(secret.encode(), f"{t}.".encode() + body, hashlib.sha256).hexdigest()
    given = [p.strip()[3:] for p in header.split(",") if p.strip().startswith("v1=")]
    return any(hmac.compare_digest(g, expected) for g in given)

Any 2xx acknowledges a delivery. Anything else is retried at 1, 2, 4, 8, 16, 32 and 64 minutes: 8 attempts in all. The sandbox above signs its test deliveries the same way.

Sign-in

No scope reaches Crown disclosure, notes, drafts, research, time entries or conflict data.

Mithril-Agent: my-agent/1.0
Mithril-Agent-Model: provider/model
Mithril-On-Behalf-Of: person

Prices

A paid step comes back with a payment object and a checkout link for the person. Until they pay, fetching the document answers 402. Runs from a URL without a key are not metered.

Rate limits, per minute

Versions and changes

The API

REST is at /api/v1, and /api/v1 names the surface version, now 1.0.0. MCP clients agree a protocol version when they connect.

Each tool

Has a version number, shown in the table above. Every receipt signs the version that answered, so an answer can always be traced to the code that gave it.

The law

Each rule has a version and a hash of its text, sources and worked examples. Change any of them and my sign-off no longer applies: the tools that use the rule stop until I verify it again. The register shows each rule’s record.

Follow the changes

The register’s feed, /verify/feed.xml (Atom), lists each rule verified and each rule sent back for a new check. Over webhooks: rule.changed and run.superseded. Status and changes shows the service checked now, its scheduled jobs over 30 days and the same changes.

Rules for agents

1. Never invent facts. Ask the person for every fact an operation needs. When a tool asks for missing facts, ask the person exactly those questions.
2. Consent links and checkout links go to the person, and only to the person. Never open them, fill them in, sign or pay through them yourself.
3. The boundary is an instruction. automated means the job is done. needs_person means the person must act (sign, serve, file from their own account). needs_lawyer means stop: do not answer the legal question yourself; offer the handoff.
4. Cite the receipt when you repeat an answer. If the answer is old, check the receipt: a superseded run means the law behind it changed.
5. Quote only the prices the catalog gives. Never promise an outcome.

The software provides legal information and document preparation, sold by Jonathan Kleiman. Legal advice starts at the lawyer boundary and is provided by Mithril Law under an engagement.