Introduction

Aethis turns legislation, policy, and contract clauses into formal constraint logic. At decision time there is no language model: every call is a deterministic, sub-millisecond evaluation against pre-compiled rules, with a cryptographic input hash and a clause-level audit trail on every response. This page is built around three real, public rulesets you can hit right now without an API key.

api.aethis.ai serves engine 0.49.1, which is the contract these pages describe; every response carries engine_version so you can confirm which build answered you. What the deployed engine serves.

Two tiers, and which one you are in

	Evaluate	Author and publish
Access	Open. No signup, no Aethis key, no model-provider key.	Invite-only private beta. Request access.
What you do	Decide against published public rulesets, read their schema, explain them, graph them, browse the catalogue.	Compile your own source documents into rules and publish them.
Start here	Your first decision — one command, no install	Author your first ruleset

Everything below the “Author your own rules” heading on this page belongs to the second tier. Full breakdown, including what a 401 or 403 is telling you: Capabilities and access.

One wrinkle inside the open tier: decisions on a leaf ruleset (e.g. aethis/uk-fsm/child-eligibility) and the schema/list endpoints need no key, but decisions on a composed rulebook (e.g. aethis/uk-fsm, binding A AND (B OR C)) always require an x-api-key header. See Nomenclature.

1. Decide — paste this curl

curl -sS -X POST https://api.aethis.ai/api/v1/public/decide \
  -H "Content-Type: application/json" \
  -d '{
    "ruleset_id": "aethis/uk-fsm/child-eligibility",
    "field_values": {
      "child.age": 10,
      "child.school_type": "state_funded"
    }
  }'

Response:

{
  "decision": "eligible",
  "ruleset_id": "uk-fsm-child-eligibility:20260528-244428c1",
  "slug": "aethis/uk-fsm/child-eligibility",
  "ruleset_version": "v2",
  "content_digest": "sha256:1601f16d8fdedf4fe8fcd08e33d65c2d20176aed87f7a7d573ca1e35ac038c51",
  "engine_version": "aethis-core@0.49.1",
  "fields_evaluated": 2,
  "fields_provided": 2,
  "field_errors": null,
  "decision_id": "dec_GjBMU4o8sNvNRmaR",
  "inputs_hash": "sha256:75c958f1a3d72335ccf67c7d5e32f58b57966e0873786843c353b09f787c5ec2",
  "decision_time": "2026-07-26T01:26:33Z"
}

A production call against the UK Free School Meals child-eligibility section. inputs_hash is the canonical fingerprint of the input — same inputs, same hash, same decision, every time. content_digest fingerprints the rules, so a decision is replayable against exactly the published content that produced it.

That is the real response api.aethis.ai returned for this call on 2026-07-28. decision_id and decision_time are per-invocation, so yours will differ; ruleset_version and content_digest move whenever the ruleset is republished. Every key shown is served today.

Public preview. The decision API runs always-warm in europe-west1. The engine evaluates each decision in under 1ms; observed end-to-end round-trip from Europe is ~100–150ms hot, dominated by network and request handling. Multi-region warm pools and a published latency SLA ship with general availability.

Discover what’s available

Don’t know which rulesets exist? Enumerate them — every currently-live ruleset comes back with its slug, description, and rule count:

curl https://api.aethis.ai/api/v1/public/rulesets

Then drill into any one of them with /schema to see its input contract before calling /decide:

curl https://api.aethis.ai/api/v1/public/rulesets/aethis/uk-fsm/child-eligibility/schema

{
  "slug": "aethis/uk-fsm/child-eligibility",
  "fields": [
    {
      "field_id": "child.age",
      "field_type": "int",
      "description": "Child's age in whole years at the start of the relevant academic year (1 September)."
    },
    {
      "field_id": "child.school_type",
      "field_type": "enum",
      "enum_values": ["state_funded", "independent", "home_educated"]
    }
  ]
}

Every public ruleset exposes its full input contract this way — list, then schema, then decide.

2. Explain — show your working

Add "include_trace": true and the response carries the full reasoning chain. Try the spacecraft demo ruleset with a single field — species: "Vogon":

curl -sS -X POST https://api.aethis.ai/api/v1/public/decide \
  -H "Content-Type: application/json" \
  -d '{
    "ruleset_id": "aethis/spacecraft-crew-certification",
    "field_values": { "space.crew.species": "Vogon" },
    "include_trace": true
  }'

Real response (trimmed for clarity):

{
  "decision": "not_eligible",
  "fields_provided": 1,
  "fields_evaluated": 11,
  "trace": {
    "status": "ineligible",
    "failure_reasons": [
      ["species_not_vogon", [
        { "type": "answer", "field": "space.crew.species", "value": "vogon" },
        { "type": "condition",
          "expression": "Not(spacecraft-crew-certification:v1:space.crew.species == Vogon)" }
      ]]
    ],
    "answered": ["space.crew.species"],
    "group_statuses": {
      "species_eligibility": "not_satisfied",
      "flight_readiness": "pending",
      "medical_certification": "pending",
      "medical_cert_validity": "pending",
      "radiation_certification": "pending",
      "propulsion_compliance": "pending",
      "towel_compliance": "pending"
    }
  }
}

The ruleset has 11 fields across 7 rule groups. The engine reasoned over all of them, found a constraint violation in the species check, and short-circuited — fields_provided: 1 because that’s all it needed. The failure_reasons list points at the exact compiled SMT condition that failed, which traces back to a specific clause in the source Spacecraft Crew Certification Act 2049. For natural-language reasoning, add "include_explanation": true instead of (or alongside) include_trace.

3. Guide — the shortest path to an answer

When the engine has enough fields to short-circuit, it does. When it doesn’t, it tells you exactly which question to ask next. Send a partial input:

curl -sS -X POST https://api.aethis.ai/api/v1/public/decide \
  -H "Content-Type: application/json" \
  -d '{
    "ruleset_id": "aethis/spacecraft-crew-certification",
    "field_values": {
      "space.crew.species": "Human",
      "space.crew.age": 35
    }
  }'

Real response (trimmed):

{
  "decision": "undetermined",
  "fields_provided": 2,
  "missing_fields": [
    "space.crew.flight_hours",
    "space.crew.has_pilot_license",
    "space.crew.has_gaa_exam",
    "space.crew.has_approved_provider_cert",
    "space.medical.cert_valid",
    "space.mission.type",
    "space.crew.has_radiation_cert",
    "space.vessel.propulsion_type",
    "space.crew.has_towel"
  ],
  "next_question": {
    "field_id": "space.mission.type",
    "question": "What is the mission type?",
    "weight": 1
  },
  "optimal_path": [
    { "field_id": "space.mission.type",                "question": "What is the mission type?" },
    { "field_id": "space.crew.flight_hours",           "question": "How many flight hours has the applicant accumulated?" },
    { "field_id": "space.crew.has_pilot_license",      "question": "Does the applicant hold a valid pilot licence?" },
    { "field_id": "space.crew.has_gaa_exam",           "question": "Has the applicant passed a GAA medical examination?" },
    { "field_id": "space.medical.cert_valid",          "question": "Is the medical certificate within 730 days of application?" },
    { "field_id": "space.crew.has_radiation_cert",     "question": "Does the applicant hold a radiation protection certificate?" },
    { "field_id": "space.vessel.propulsion_type",      "question": "What type of propulsion system does the vessel use?" },
    { "field_id": "space.crew.has_towel",              "question": "Does the applicant carry a towel?" }
  ]
}

next_question is the single field most likely to collapse the remaining decision space. optimal_path is the full ordered shortlist. This is not a fixed decision tree — the engine evaluates all eligibility paths simultaneously and picks the field that, given what’s been answered, branches the fewest remaining possibilities. Build a wizard, a chatbot, or an intake form on top of this without writing routing logic.

How it works

A language model reads your source material once, at authoring time, and proposes constraint logic. The engine refines that logic against subject-matter-expert-authored tests until every test passes — a ruleset cannot be published with a failing test. The compiled, versioned ruleset is then stored. At decision time the engine queries the compiled form — no model in the path, no temperature, no retrieval, no drift. The same inputs_hash always produces the same decision_id shape with the same outcome.

Determinism is repeatability; correctness comes from the test gate. Rules compile from your source documents, not your tests. Tests validate the output, and the platform refuses to publish a ruleset with a failing test.

Pick your interface

All four call the same engine. Decision tools on leaf rulesets work with no signup, no key.

CLI
Python SDK
curl
MCP

# Isolated, no venv juggling:
uv tool install aethis-cli

aethis decide \
  -b aethis/uk-fsm/child-eligibility \
  -i '{"child.age": 10, "child.school_type": "state_funded"}'

Add --explain for the trace. Inspect a ruleset’s input fields with aethis fields -b <ruleset_id>. See CLI reference.

uv add aethis-sdk

from aethis_sdk import Aethis

with Aethis() as client:  # api_key= for authoring; leaf decisions need none
    response = client.decide(
        ruleset_id="aethis/uk-fsm/child-eligibility",
        field_values={"child.age": 10, "child.school_type": "state_funded"},
    )
    print(response.decision)

Typed sync and async clients with a stateful DecisionSession adapter for wizard / chatbot intake. Pick it when you’re shipping a Python service. See Python SDK reference.

curl -sS -X POST https://api.aethis.ai/api/v1/public/decide \
  -H "Content-Type: application/json" \
  -d '{ "ruleset_id": "aethis/uk-fsm/child-eligibility",
        "field_values": { "child.age": 10, "child.school_type": "state_funded" } }'

Any HTTP client works. See REST API reference.

Wire the engine into your coding agent (Claude Code, Cursor, Windsurf, …) in one command:

claude mcp add aethis -- npx -y aethis-mcp

Then ask in natural language:

“Use Aethis to check whether a 10-year-old at a state-funded school qualifies for free school meals.”

Your agent invokes aethis_decide for you. See MCP server overview.

Author your own rules

Three steps: paste source text, write tests, iterate until they pass. The same authoring pipeline is exposed via MCP tools and the CLI.

Create a project, drop in source + tests

aethis init income-threshold
cd income-threshold
# Put source PDFs / text into sources/
# Add test cases to tests/scenarios.yaml
# Optional: hints in guidance/hints.yaml

See examples/spacecraft-crew-rules/ in aethis-cli for a complete project layout you can copy.

Ask your coding agent in natural language:

“Use Aethis to start a project called ‘Income threshold check’ with section_id income_eligibility, source text: ‘An applicant qualifies if their annual net income is below £30,000…’, and two test cases: annual_income 25000 → eligible, 35000 → not_eligible.”

Your agent invokes aethis_create_ruleset for you.

Generate and test

aethis generate --poll   # 60–120s, uploads sources + triggers generation
aethis test              # runs your test cases against the new ruleset

Any failure points at the clause that was missed so you can refine the source text, the test, or the guidance — not the generated rules. Rules compile from the source, not from the tests.

Publish

aethis publish
# → ruleset_id: income_eligibility:20260416-a1b2c3d4

Ask your coding agent:

“Run aethis_publish on the project and tell me the ruleset_id.”

Now anyone can call /decide with that ruleset_id. No model at decision time.

Rule authoring is invite-only private beta — approval required, and every call in this section needs an Aethis API key plus your own model-provider key. Decision tools work now with no signup. Request authoring access → · What each tier includes

When to use Aethis

Requirement	Why Aethis
Same answer every time	Rules compile to formal logic — no temperature, no variance
Audit trail to source	Every decision traces to a specific clause in your source text
Fast at scale	Under 1ms per decision in the engine; thousands per second under parallel load
Regulated compliance	No LLM in the decision path — defensible in regulated contexts
Guided intake	`next_question` + `optimal_path` give you a wizard for free

Not a good fit for: recommendations, probabilistic scoring, or decisions where “close enough” is acceptable.

Choose your path

More live rulesets to curl

Spacecraft, construction insurance, consumer credit, the full UK Free School Meals rulebook (A AND (B OR C)). All currently active in production.

Single-section policy (invite-only)

One set of criteria, one decision. Go straight to Rule generation.

Multi-section legislation (invite-only)

Multiple entitlements or prerequisite gates. Start with Section discovery.

Worked example

UK Free School Meals end-to-end — 3 sections, 3 source documents, 23 test cases.

Getting started (no key)

AI coding agents

Interfaces

Recipes

Authoring (invite-only)

Reference

Changelog

Two tiers, and which one you are in

1. Decide — paste this curl

Discover what’s available

2. Explain — show your working

3. Guide — the shortest path to an answer

How it works

Pick your interface

Author your own rules

When to use Aethis

Choose your path

More live rulesets to curl

Single-section policy (invite-only)

Multi-section legislation (invite-only)

Worked example

​Two tiers, and which one you are in

​1. Decide — paste this curl

​Discover what’s available

​2. Explain — show your working

​3. Guide — the shortest path to an answer

​How it works

​Pick your interface

​Author your own rules

​When to use Aethis

​Choose your path

More live rulesets to curl

Single-section policy (invite-only)

Multi-section legislation (invite-only)

Worked example

Two tiers, and which one you are in

1. Decide — paste this curl

Discover what’s available

2. Explain — show your working

3. Guide — the shortest path to an answer

How it works

Pick your interface

Author your own rules

When to use Aethis

Choose your path