Skip to main content
Glama
aethis-mcp

aethis-mcp

Official
by Aethis-ai

aethis-mcp

MCP server for the Aethis decision engine. Compile legislation, policy, contracts, and regulation into deterministic logic — same input, same answer, every time, with a full audit trail.

npm version Docs License: MIT

Install · Skills · Quick start · Tools · Setup · Authoring · DSL · Troubleshooting


Install

Authoring is in private beta. Decision tools (aethis_decide, aethis_schema, aethis_explain, aethis_next_question) are public — no key required. Authoring tools (rule generation, test refinement, publishing) require an invite. Request access at aethis.ai/developer-access.

Recommended — one command via aethis-cli:

uv tool install aethis-cli
aethis mcp install --target all

Wires the server into claude-code, cursor, claude-desktop, or windsurf. Idempotent. Restart your editor to pick up the change. Re-run after aethis account generate rotates a key. Full options: aethis mcp install --help.

Manual install:

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

For Cursor / Claude Desktop / Windsurf manual config, see Setup.

Onboarding an AI coding agent end-to-end? See docs.aethis.ai/agents/onboarding — install + verify + auth + workflow patterns in one page.


Related MCP server: OMNIA MCP

Skills

After the MCP server is installed, add reusable agent workflows with aethis-skills:

npx skills add Aethis-ai/aethis-skills

The skills package provides workflows for policy-to-ruleset authoring, test/refine/publish loops, decisions with trace, and regression comparison. It calls the MCP tools in this package; it does not replace the MCP server.


Quick start

aethis_decide({
  ruleset_id: "aethis/spacecraft-crew-certification",
  field_values: { "space.crew.species": "Vogon" },
  include_trace: true
})
{
  "decision": "not_eligible",
  "fields_provided": 1,
  "fields_evaluated": 11,
  "trace": {
    "species_check": "FAIL — species is 'Vogon' (disqualifying, Section 3)"
  }
}

Public rulesets work without a key. Browse: aethis_discover_rulesets({}) or docs.aethis.ai.

Engine determinism + accuracy benchmarks: Aethis-ai/confidently-wrong-benchmark.


Tools

36 tools across six groups.

Group

Access

Tools

Decision

public

aethis_decide, aethis_schema, aethis_next_question, aethis_explain, aethis_explain_failure, aethis_graph

Discovery — public catalogue

public

aethis_discover_rulesets

Discovery — your tenant

private beta

aethis_list_projects, aethis_list_rulesets, aethis_list_rulebooks, aethis_rulebook_schema

Authoring — rulebooks

private beta

aethis_create_rulebook, aethis_update_rulebook

Authoring — sections & fields

private beta

aethis_discover_sections, aethis_refine_sections, aethis_validate_sections, aethis_set_field_spec, aethis_set_bundle_contract, aethis_discover_fields, aethis_refine_fields, aethis_validate_fields

Authoring — generation

private beta

aethis_create_ruleset, aethis_set_tests, aethis_add_guidance, aethis_list_guidance, aethis_generate_and_test, aethis_generation_status, aethis_cancel_generation, aethis_refine, aethis_publish, aethis_add_domain_guidance, aethis_list_domain_guidance

Management

private beta

aethis_archive_project, aethis_archive_ruleset

aethis_graph is public for a public showcase ruleset (ruleset_id) and tenant-scoped for a rulebook (rulebook_id) — it returns the ruleset-map graph ({nodes, edges, sections, stats}, each node's display.sentence/display.routes/display.expr) plus a ready-to-render mermaid diagram string. Pass include_graph_overlay: true to aethis_decide to get that same graph back with a specific decision's per-criterion status (satisfied/not_satisfied/pending) stamped onto it (graph_overlay in the response) — a "you are here" map for those inputs.

aethis_create_rulebook / aethis_update_rulebook manage a Rulebook's identity (name/domain/slug/description) and robot_hints — beat-keyed natural-language guidance for the conversational agent. Active beats: general_context, preamble, session_start, postamble, session_end, stuck. Reserved (accepted, not yet acted on): persona, conversational_style, section_transition. Composition (bridging rulesets via outcome_logic) is a separate, larger surface not covered by these two tools yet.

Workflows

Evaluate eligibility (2 calls):

aethis_schema(ruleset_id)          → fields needed
aethis_decide(ruleset_id, fields)  → eligible / not_eligible / undetermined

Pass include_trace: true for the per-criterion evaluation trail. Pass include_explanation: true for human-readable rule descriptions.

aethis_decide accepts either ruleset_id (single ruleset, may be public) or rulebook_id (composed multi-ruleset rulebook) — the two are mutually exclusive. Rulebook decide always requires an API key (AETHIS_API_KEY); anonymous callers get HTTP 401. aethis_graph follows the same ruleset_id/rulebook_id split for the underlying map.

Conversational eligibility (next-question routing):

aethis_next_question(ruleset_id, field_values)

Returns the most informative remaining question and the optimal_path of remaining questions. Call again after each answer; the engine recomputes from the updated state. Stops when a decision is reachable.

Authoring (private beta): see Authoring.

Prompts

Prompt

Description

aethis-author

Step-by-step TDD authoring workflow

aethis-decide

Decision workflow guide; accepts optional ruleset_id


Setup

Decision tools work with no key. For invited authoring access, run aethis login, then install with aethis mcp install --target <client>. The installer references a saved profile so the host configuration does not contain the API key.

Claude Code

# Decision tools only
claude mcp add aethis -- npx -y aethis-mcp

# With authoring access
claude mcp add aethis -e AETHIS_PROFILE=default -e XDG_CONFIG_HOME=/absolute/path/to/config -- npx -y aethis-mcp

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "aethis": {
      "command": "npx",
      "args": ["-y", "aethis-mcp"]
    }
  }
}

For authoring, add "env": { "AETHIS_PROFILE": "default", "XDG_CONFIG_HOME": "/absolute/path/to/config" }. Use your saved profile name and the absolute directory containing aethis/credentials (normally your home directory’s .config).

Cursor / Windsurf

Add to ~/.cursor/mcp.json or ~/.codeium/windsurf/mcp_config.json (same JSON shape).

Keys

  • AETHIS_PROFILE — non-secret saved profile name. It pins the account and endpoint used by this registration, even if the CLI’s active_profile later changes.

  • XDG_CONFIG_HOME — absolute config directory containing aethis/credentials. Relative values and credentials symlinks escaping your home/config directory are refused; credential files must have no group/other permission bits (normally 0600).

  • AETHIS_API_KEY — optional deliberate process-environment override for the platform key. Prefer saved-profile references when installing; avoid putting raw keys in host config or command arguments. The host must securely supply the process environment; it may not inherit your shell environment.

  • AETHIS_ANTHROPIC_KEY_ENV — the name of the env var holding the Anthropic key Aethis authoring tools may use (e.g. AETHIS_ANTHROPIC_KEY). The server never reads a provider key from the environment unless you set this. See Passing your Anthropic key safely.

  • Rotate via aethis account generate + aethis account revoke <key_id>. Mint one key per machine for surgical revocation.

Credential precedence and restart behavior

MCP parses the CLI credentials file as YAML. AETHIS_PROFILE selects a named profile; otherwise the file’s active_profile (or default) selects it. The profile supplies both its API key and base_url, with https://api.aethis.ai as the default endpoint. With an explicit AETHIS_PROFILE, AETHIS_API_KEY and AETHIS_BASE_URL deliberately override their respective values. Without an explicit profile selector, AETHIS_API_KEY uses AETHIS_BASE_URL or the default endpoint, ignoring the implicitly active profile (including implicit anonymous). Missing or malformed explicitly selected profiles fail visibly, including when environment overrides are present. Explicit AETHIS_PROFILE=anonymous always stays unsigned. After anonymous setup, run aethis login and install again to reference the saved authoring profile, then restart the host.

A saved profile outranks old macOS Keychain entries. If no profile is configured and no explicit name is selected, MCP can use the legacy default keychain entry, then the older flat credentials.yaml file. Flat api_key/base_url files at aethis/credentials remain supported. A configured profile awaiting login stays unsigned instead of borrowing another stored key.

The server keeps its authenticated startup key and endpoint paired until restart. If it started without a key, an authenticated tool can pick up a later login for the same endpoint. A changed endpoint causes a visible refusal: restart the MCP host to load the new pair. Startup stderr reports only the credential source, never key values.

Passing your Anthropic key safely

Authoring tools (aethis_generate_and_test, aethis_refine, aethis_discover_fields, aethis_refine_fields, aethis_discover_sections, aethis_refine_sections) need an Anthropic API key per call. Three accepted forms — listed in preferred order:

The server sends a provider key to Aethis only when you configured one for Aethis. It never picks up ANTHROPIC_API_KEY (or any other variable) from your environment on its own, and an env-var name supplied in a tool call by the host model is refused unless it is the one you configured. Only Anthropic keys (sk-ant-…) are accepted; anything else is refused locally and not sent.

  1. AETHIS_ANTHROPIC_KEY_ENV (recommended). In the MCP server config, put the key in a dedicated env var and name that var in AETHIS_ANTHROPIC_KEY_ENV. Tools then use it automatically. The raw value never appears in the tool call payload, so it does not land in the MCP host's session transcript on disk.

    // claude_desktop_config.json
    {
      "mcpServers": {
        "aethis": {
          "command": "npx",
          "args": ["aethis-mcp"],
          "env": {
            "AETHIS_PROFILE": "default",
            "XDG_CONFIG_HOME": "/absolute/path/to/config",
            "AETHIS_ANTHROPIC_KEY_ENV": "AETHIS_ANTHROPIC_KEY",
            "AETHIS_ANTHROPIC_KEY": "sk-ant-..."   // never echoed back to the LLM
          }
        }
      }
    }
    aethis_generate_and_test({ project_id })   // uses the configured key
  2. anthropic_key_keychain (macOS). A keychain reference — either "account" (service defaults to aethis-anthropic-key) or "service:account". Store the key once with security add-generic-password -U -s aethis-anthropic-key -a my-anthropic -w 'sk-ant-...', then call:

    aethis_generate_and_test({ project_id, anthropic_key_keychain: "my-anthropic" })
  3. anthropic_key (deprecated). Pass the raw key as a tool argument. Accepted for backwards compatibility, but the raw value is written verbatim to the host's session transcript JSONL on disk. If a key was ever passed this way, rotate it before relying on the safer forms.


Authoring (private beta)

Authoring requires an invite. Request access. Decision tools (above) are public.

Three-phase workflow. Phases 1–2 are for multi-section domains; skip them for single-section rules and go straight to Phase 3.

Phase 1 — Section discovery

aethis_discover_sections({ domain, sources: [{ name, content }, ...] })
aethis_validate_sections({ domain, expected_sections, discovered_sections })
aethis_refine_sections({ domain, feedback, sources })

Phase 2 — Field vocabulary

aethis_set_field_spec({
  project_id,
  expected_fields: [{ key, sort, enum_values?, notes?: [{ note_text, source?, metadata? }] }, ...]
})
aethis_discover_fields({ project_id })           // auto-validates against the spec if set
aethis_refine_fields({ project_id, feedback })
aethis_validate_fields({ project_id, expected_fields })

Input invariants (bundle contract)

Declare rules that the inputs must satisfy together, for example that a renewal date must not be before the joined date. Set them before generating:

aethis_set_bundle_contract({
  project_id,
  input_invariants: [{
    id: "renewal_after_joined",
    expr: { operator: ">=", args: [
      { type: "field_ref", key: "member.renewal_date" },
      { type: "field_ref", key: "member.joined_date" },
    ] },
    error_fields: ["member.renewal_date"],
    message: "The renewal date must not be before the date the member joined."
  }]
})

Each invariant is one comparison (=, !=, <, <=, >, >=) over field references and typed constants. Every generation of the project copies them into the compiled ruleset. When a decision's inputs break one, it returns undetermined with undetermined_reason: "input_errors" and a field_errors message for each named field, and asks no further question; an invariant is skipped while any input it reads is missing. Calling the tool again replaces the stored contract; omit input_invariants or pass [] to clear it. The tool reports the stored digest. This needs an Aethis API version that supports bundle contracts; when the API does not, the tool says so clearly and changes nothing.

To assert the rejection in a test case, use expected_outcome: "undetermined" with expectations: { field_errors: { "member.renewal_date": "<exact message>" } } (needs contract_version: 1; at most 500 entries, messages up to 20000 characters).

Phase 3 — Generate, test, publish

aethis_create_ruleset({
  name, section_id, domain?, source_text,
  test_cases: [{ name, field_values, expected_outcome, expectations? }, ...],
  contract_version?: 1,
  expected_review_bindings?: { field_id: { token: true | false | null } },
  retained_passages?: [{ id, text }]   // source passages that must be retained in the rule notes
})
aethis_generate_and_test({ project_id })
aethis_refine({ project_id, feedback })          // iterate until tests pass
aethis_publish({ project_id })                   // refuses if tests fail; returns ruleset_id on success

When a test carries expectations, set contract_version: 1. The optional binding catalogue is generic authoring metadata: omit it when no binding assertion is needed, or pass {} to assert that no review bindings exist. The server must confirm the complete stored contract before generation begins. aethis_create_ruleset creates a project; it does not append or replace tests on an existing project. Use aethis_set_tests with the complete version-1 contract for a later replacement, then generate or refine that same project. Legacy updates cannot discard stored assertions. Object keys named __proto__ are rejected in field-value and binding maps rather than silently discarded.

If generation polling times out, call aethis_generation_status({ project_id }) before retrying: use its telemetry_availability, server-authoritative worker_lifecycle, and retry_readiness, and retry only when readiness is ready. An old heartbeat alone is not proof that the worker died. Call aethis_cancel_generation({ project_id, job_id, confirm_job_id }) only after showing the observed job_id and receiving explicit confirmation to abandon that active run. It releases the project's job ownership, but worker shutdown may be cooperative rather than immediate; inspect the returned detail. It is a destructive, API-key-protected mutation. The response distinguishes a new cancelled transition from the idempotent already_cancelled result.

Guidance

Targeted hints without regenerating, plus cross-section principles for a domain:

aethis_add_guidance({ project_id, guidance_text, process_type })
aethis_list_guidance({ project_id })

aethis_add_domain_guidance({ domain, guidance_text, process_type, notes? })
aethis_list_domain_guidance({ domain })

process_type is rule_generation (default) or field_extraction.

Diagnose a failing test

aethis_explain_failure({
  ruleset_id, field_values, expected_outcome, test_name
})
// Returns criterion statuses, the failing rule, and a targeted fix hint.
IMPORTANT

Tests are the publish gate. aethis_publish refuses to publish a ruleset with a failing test. SMEs write the tests; the LLM generates the rules from source text + guidance; the platform refuses to ship rules that don't satisfy the tests. Better tests = faster convergence.

IMPORTANT

Anthropic key required for authoring. ConfigureAETHIS_ANTHROPIC_KEY_ENV or use anthropic_key_keychain (macOS keychain ref) rather than the raw anthropic_key argument — see Passing your Anthropic key safely. Used per-request, never stored server-side; the raw form, however, lands in the MCP host's session transcript on disk.

IMPORTANT

DATE fields use integer ordinals (date.toordinal()), not ISO strings. 2025-04-13 = 739354. Quick conversion: python3 -c "from datetime import date; print(date(2025,4,13).toordinal())".


Field types

Type

Description

Bool

True / false

Int

Integer (counts, money as pence, percentages as integers)

Enum

Closed set of named values

Date

Integer ordinal — date.toordinal()

Duration

Integer days

String

Free text — prefer Enum for known sets

Operators

Category

Operators

Logic

AND, OR, NOT, IMPLIES

Comparison

=, ≠, <, ≤, >, ≥

Membership

IN [v1, v2, ...]

Arithmetic

+, − for Int/Date; * for Int

Aggregation

min(...), max(...)

Helpers

  • days_between(date_a, date_b) → Int

  • years_between(date_a, date_b) → Int — completed whole years between the two dates (leap-correct). Use this for age from a date-of-birth field; never derive age as days_between(...) / 365.

  • min(a, b, ...), max(a, b, ...) → Int

  • Constant arithmetic folded at authoring time (5 * 365 → 1825)

Not supported

  • Division between runtime field values

  • Weighted scoring or probabilistic outcomes

  • Lists as field values (use pre-aggregated Int / Bool)

  • More than 3 outcome tiers (eligible / not_eligible / undetermined)


Troubleshooting

Error

Cause

Fix

API key is required

AETHIS_API_KEY not set (authoring)

Configure in MCP client settings, not shell profile

X-Anthropic-Key header is required

Missing Anthropic key

Set AETHIS_ANTHROPIC_KEY_ENV in the MCP server config (preferred), or pass anthropic_key_keychain / anthropic_key on the tool call. See Passing your Anthropic key safely.

Ruleset not found (404)

Wrong ID or archived

aethis_list_projects → aethis_list_rulesets

Rate limit exceeded (429)

Daily limit

Client retries automatically. eng@aethis.ai for higher tier

Cannot publish: tests failing

Tests don't pass

aethis_refine until all tests pass

Generation timeout (504)

Server still generating (5–15 min normal)

Wait, then aethis_list_rulesets({ project_id }) to check. Don't re-trigger

Expected an integer for <field>, got str

DATE field passed as ISO string

Use date.toordinal() integer


Development

git clone https://github.com/Aethis-ai/aethis-mcp.git
cd aethis-mcp && npm install && npm test && npm run build

License

MIT

Available Tools

36 tools
aethis_add_domain_guidanceA

Add a guidance hint at domain level — applies to ALL projects in the domain, not just one project. Use for cross-section principles: solicitor navigation, discretion model, raw-facts principle. These hints are retrieved automatically during generation for any project in the domain. Use adherence='exact' with process_type='section_discovery' to specify exactly which sections the SME wants — the LLM will follow them precisely.

Inputs: domain (required), guidance_text (required), notes, adherence, +1 more.

aethis_add_guidanceA

Add a guidance hint to a project. Use for domain knowledge not in the source text. Then call aethis_generate_and_test to regenerate.

Inputs: project_id (required), guidance_text (required), adherence, process_type.

aethis_archive_projectA
DestructiveIdempotent

Archive a project. Archived projects are preserved but excluded from listing. This is permanent.

Inputs: project_id (required).

aethis_archive_rulesetA
DestructiveIdempotent

Archive a rule ruleset. Archived rulesets are preserved but excluded from /decide resolution. This is permanent.

Inputs: ruleset_id (required).

aethis_cancel_generationA
DestructiveIdempotent

Request cancellation of one observed generation job and release only its project ownership. First call aethis_generation_status and bind the exact job_id; confirm_job_id protects against accidental target mismatch but does not itself prove human approval. MCP hosts should require destructive-action approval, and agents must obtain a fresh explicit user reply before calling. The response outcome is cancelled or idempotent already_cancelled. Cancellation may be cooperative rather than immediate. It is a destructive mutation and requires an API key.

Inputs: job_id (required), project_id (required), confirm_job_id (required).

aethis_create_rulebookA

Create a new Rulebook — the composed-whole execution unit that bridges multiple rulesets (the parts) via outcome_logic. Created empty: no rulesets, no field vocabulary, no tests, status='draft'. Populate afterwards with aethis_create_ruleset for each section, then wire up the field vocabulary and composition logic before publishing. Requires an API key.

Inputs: name (required), slug, domain, description, +1 more.

aethis_create_rulesetA

Create a new rule ruleset with source text and test cases (TDD). Test cases are required. After creation, call aethis_generate_and_test.

Inputs: name (required), section_id (required), test_cases (required), source_text (required), +4 more.

aethis_decideA
Read-only

Evaluate eligibility against either a single published ruleset (ruleset_id) or a composed rulebook (rulebook_id). Provide exactly one. A rulebook composes multiple rulesets via outcome_logic — use it for the whole-form decision (e.g. aethis/uk-fsm). A ruleset is one section in isolation (e.g. aethis/uk-fsm/child-eligibility). Returns eligible/not_eligible/undetermined with optional trace and explanation. When undetermined, includes next_question and optimal_path. Rulebook evaluation always requires an API key; ruleset evaluation can be anonymous against public rulesets.

Inputs: field_values (required), ruleset_id, rulebook_id, include_trace, +2 more.

aethis_discover_fieldsA
Read-only

Discover input fields from the project's source text. Returns field names, types, descriptions, and completeness assessment. Run this BEFORE writing test cases to ensure field names are consistent. Call repeatedly with aethis_refine_fields to improve completeness.

Inputs: project_id (required), openai_key, anthropic_key, anthropic_key_env, +1 more.

aethis_discover_rulesetsA
Read-only

List public showcase rulesets across all tenants. No authentication required. Use this for first-time discovery, demos, or whenever the user asks 'what rulesets are available?' without referencing a specific project. Returns slug, ruleset_id, name (the human-readable section title), description, field_count, rule_count for each — pass the slug or ruleset_id to aethis_decide / aethis_schema / aethis_explain to interact with one. Distinct from aethis_list_rulesets, which is tenant-scoped.

Inputs: limit, offset.

aethis_discover_sectionsA
Read-only

Discover the logical sections of source legislation for a domain. Provide the raw text of your source documents (legislation, guidance notes, form instructions). The service analyses the content and identifies which sections should be authored as separate rule rulesets. Run BEFORE creating projects — you need to know the sections before you can create one. Call aethis_refine_sections if sections are missing or incorrectly split.

Inputs: domain (required), sources (required), openai_key, anthropic_key, +2 more.

aethis_explainA
Read-only

Get human-readable descriptions of the rules in a ruleset, including criteria groups, requirements, and exception paths.

Inputs: ruleset_id (required).

aethis_explain_failureA
Read-only

Diagnose why a ruleset produced an unexpected outcome for specific test inputs. Use during rule authoring when a test fails — returns the diagnosis, criteria with DSL metadata (waivable, review_required), and a targeted hint for fixing the rule.

Inputs: ruleset_id (required), field_values (required), expected_outcome (required), test_name.

aethis_generate_and_testA

Generate rules from source text and run all test cases. Triggers generation, polls until complete, then runs tests. Returns pass/fail with regression detection. Usually takes 60-120 seconds; if polling times out, use aethis_generation_status before retrying, and aethis_cancel_generation only when the caller wants to stop the run.

Inputs: project_id (required), model, thinking, openai_key, +4 more.

aethis_generation_statusA
Read-only

Check the current generation job for a project without changing it. Returns generation_contract_version, telemetry_availability, server-authoritative worker_lifecycle, retry_readiness, and the active or most recent job's progress and safe failure diagnostics. Retry only when retry_readiness is ready; an old heartbeat alone does not prove worker death. Tenant-scoped — requires an API key.

Inputs: project_id (required).

aethis_graphA
Read-only

Get the ruleset-map graph for a single published ruleset (ruleset_id) or a composed rulebook (rulebook_id) — provide exactly one. Returns {ruleset_id|rulebook_id, slug, name, graph: {nodes, edges, sections, stats}, mermaid}: each node's display.sentence / display.routes / display.expr shows how that branch composes, and mermaid is a ready-to-render diagram string. Use this to visualise or explain a ruleset's/rulebook's structure before or instead of aethis_explain. Ruleset graphs may be public (no auth for public showcase rulesets); rulebook graphs always require an API key.

Inputs: ruleset_id, rulebook_id.

aethis_list_domain_guidanceB
Read-only

List all active guidance hints for a domain. Returns cross-section hints that apply to all projects in the domain.

Inputs: domain (required).

aethis_list_guidanceA
Read-only

List all guidance hints accumulated for a project. Shows the text, source, and active status of each hint. Use before adding new guidance to avoid duplicates.

Inputs: project_id (required).

aethis_list_projectsB
Read-only

List all projects in the current tenant. Returns project IDs, names, domains, and latest ruleset information.

Inputs: no named parameters.

aethis_list_rulebooksA
Read-only

List rulebooks (composed wholes that bridge multiple rulesets) in the current tenant. Returns rulebook_id, slug (e.g. aethis/uk-fsm), name, domain, status (draft/active/archived), version, outcome_logic (the composition Expr AST), ruleset_refs, and timestamps. Use this when the user asks 'what rulebooks exist?' or to disambiguate whether several <ns>/<x>/* rulesets are bridged into one parent rulebook. Tenant-scoped — requires an API key. Pass a returned rulebook_id or slug to aethis_decide (rulebook_id arg) or aethis_rulebook_schema.

Inputs: no named parameters.

aethis_list_rulesetsA
Read-only

List all rule rulesets for a project, including version history. Shows ruleset ID, human-readable name (the section title the ruleset covers, e.g. 'Knowledge of language and life in the UK'), status (active/archived), version, field count, and rule count.

Inputs: project_id (required).

aethis_next_questionA
Read-only

Get the optimal next question for a conversational eligibility check. Call with empty field_values for the first question, then add answers and call again until decision is reached. When the ruleset author attached notes to a question (e.g. why it is asked, or legal background), they are surfaced under a Notes block.

Inputs: ruleset_id (required), field_values (required).

aethis_publishA

Publish the latest rule ruleset. Runs tests first and refuses if they fail unless force=true. Auto-deprecates previous active ruleset.

Inputs: project_id (required), name, force, label.

aethis_refineA

Refine an existing published ruleset: add optional feedback, then make the MINIMAL edit to fix failing test cases while keeping passing tests green, and re-run the full suite (seed-from-existing incremental re-authoring). Use this to fix a specific finding without re-authoring the whole section; use aethis_generate_and_test for a from-scratch rebuild.

Inputs: project_id (required), model, feedback, thinking, +5 more.

aethis_refine_fieldsA

Add guidance to improve field discovery, then re-discover. Use when fields are missing, misnamed, or enum values are incomplete. Adds a field_extraction guidance hint and re-runs discovery.

Inputs: feedback (required), project_id (required), openai_key, anthropic_key, +2 more.

aethis_refine_sectionsA

Add guidance to improve section discovery, then re-discover sections. Use when sections are missing, incorrectly split, or named differently than expected. Saves the feedback as a domain-level guidance hint and immediately re-runs discovery so you can see the effect. Repeat until the section list matches your expectations.

Inputs: domain (required), sources (required), feedback (required), openai_key, +3 more.

aethis_review_projectA
Read-only

Review an authoring project against the deterministic authoring-coach rubric and get skill-building feedback. Returns a score, per-check evidence across grounding / process / lifecycle, strengths, and the single highest-leverage next improvement. Advisory only — it never blocks publishing. The deterministic report needs no LLM key; set coach=true (with an Anthropic key) to add an LLM-synthesised coaching narrative on top of the computed checks.

Inputs: project_id (required), coach, openai_key, anthropic_key, +2 more.

aethis_rulebook_schemaA
Read-only

Get the composition + aggregated input fields for a rulebook. Returns the outcome_logic Expr AST (how the bridged rulesets compose, e.g. A AND (B OR C)), the list of bridged rulesets (ruleset_name, ruleset_id, slug, status), and the union of all required input fields. Use this BEFORE aethis_decide on a rulebook_id to know what field_values to supply, or to inspect how a rulebook is wired. Pass a rulebook slug (e.g. aethis/uk-fsm) or opaque id (rb_*).

Inputs: rulebook_id (required).

aethis_schemaA
Read-only

Get the input fields required for an eligibility check. Returns field names, types, descriptions, and allowed values. Use this before calling aethis_decide.

Inputs: ruleset_id (required).

aethis_set_bundle_contractA
Idempotent

Store the bundle contract for a project: input invariants, which are author-declared consistency rules over the ruleset's inputs (for example member.renewal_date must not be before member.joined_date). Every later generation copies them into the compiled ruleset. When a decision's inputs break one, it returns undetermined with undetermined_reason input_errors and a field_errors message for each named field, and asks no further question; an invariant is skipped while any input it reads is missing. Each invariant is {id, expr, error_fields, message}: expr is exactly one comparison (=, !=, <, <=, >, >=) over field references and typed constants, and every error field must be read by it. At most 32 invariants. Replaces any stored contract; omit input_invariants, or pass null or [], to clear it. Field names and types are checked against the project's fields when generation starts. Use a test case's expectations.field_errors to assert the messages.

Inputs: project_id (required), input_invariants.

aethis_set_field_specA
Idempotent

Store the expected field specification for a project. Once set, every aethis_discover_fields call automatically validates discovered fields against this spec. Mismatches (missing fields, wrong types, wrong enum values) generate guidance hints automatically and appear in the validation_result block. Call this BEFORE running aethis_discover_fields when the SME has already defined the field vocabulary. The spec is persisted on the project and survives across sessions. Optionally provide ordered notes for a field. Omit notes to leave existing note guidance unchanged; pass an empty list to clear it.

Inputs: project_id (required), expected_fields (required).

aethis_set_testsA
Destructive

Replace the complete reviewed test suite for an existing project after field discovery. Requires 1 to 100 legacy cases, or up to 500 with contract_version: 1, and replaces prior tests without creating a project or changing its sources, fields, or guidance. This is destructive. The target API must advertise replacement support before any write. If the response is interrupted, inspect the project before approving another replacement.

Inputs: project_id (required), test_cases (required), contract_version, retained_passages, +1 more.

aethis_update_rulebookA
Idempotent

Update a Rulebook's name, description, slug, or robot_hints (assistant guidance for the conversational agent). Provide at least one field to change; omitted fields are left as-is. Requires an API key.

Inputs: rulebook_id (required), name, slug, description, +1 more.

aethis_usageA
Read-only

Show the caller's rate-limit budget per operation class over the rolling 24h window: for each of decide / generate / author / read / keys / admin, the used count, limit, remaining, and reset time. generate (LLM rule generation) is the scarce class; browsing and status polling (read) are effectively unlimited-but-metered. Check this before a large authoring run — and report remaining generate budget to the user — so a 429 is never the first signal. Tenant-scoped — requires an API key.

Inputs: no named parameters.

aethis_validate_fieldsA
Read-only

Assert that the discovered fields match an expected field specification. Returns a structured diff: missing fields, type mismatches, enum value mismatches, and extra fields. all_match=true only when there are no missing fields and no type or enum mismatches. Extra discovered fields do not affect all_match. Run after aethis_discover_fields to verify field coverage before writing test cases. If all_match=false, call aethis_refine_fields with guidance about the missing or incorrect fields.

Inputs: project_id (required), expected_fields (required).

aethis_validate_sectionsA
Read-only

Compare discovered sections against an expected specification. Returns missing sections (expected but not found) and extra sections (found but not expected). Call after aethis_discover_sections to check whether the LLM found all sections the SME expects. If sections are missing, call aethis_add_domain_guidance with adherence='exact' to enforce them.

Inputs: domain (required), expected_sections (required), discovered_sections (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 36 tools

    Disambiguation4/5

    Most tools target clearly distinct resources and lifecycle stages, but several adjacent families can be confused: list_rulesets vs discover_rulesets, schema vs rulebook_schema, and explain vs graph vs explain_failure. The descriptions usually resolve the ambiguity explicitly by scoping tenant vs public, ruleset vs rulebook, or diagnosis vs description, so selection is mostly reliable.

    Naming Consistency4/5

    All tools are snake_case with the aethis_ prefix, and most follow a readable verb_noun pattern such as list_projects, create_ruleset, archive_project, and generate_and_test. A minority are verb-only or noun-only (decide, publish, schema, graph, usage), which is a minor deviation rather than a broken convention.

    Tool Count2/5

    Thirty-six tools is well beyond the 3-15 sweet spot and over the 25-tool heavy threshold, even for a broad rule-authoring platform. The clusters are logically organized, but the raw count will strain tool selection and context for an agent.

    Completeness4/5

    Coverage is unusually thorough across discovery, authoring, testing, generation, publication, decisioning, visualization, and diagnostics. Minor gaps remain: there is no archive/delete for rulebooks, no update/delete for guidance hints, and projects/rulesets can only be archived rather than truly deleted.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables users to trace regulatory rule changes to affected parties and required actions through deterministic safety gates, returning dated action plans and hash-linked evidence records. Supports 12 MCP tools over stdio or streamable HTTP for source comparison, obligation decomposition, scope assessment, planning, and evidence validation across multiple domain packs.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables agents to evaluate context against custom criteria and receive typed decisions (classifications, scores, probabilities) from JEV or local LAYA, with validation policies and durable decision records.
      4
      1
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI tools to search, retrieve, and verify verbatim federal mortgage and consumer-finance regulatory text and citations, check currency and version status, and run guided compliance review playbooks within a self-hosted environment.
      Elastic 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Gives tools read-only access to a hosted decision record, so they can ask natural-language questions and get an authoritative answer or an explicit hold before acting, and poll for decisions whose state changed since a cursor. It only answers queries and never takes actions in downstream systems.
      74 npm
      MIT