Skip to main content
Glama
aethis-mcp

aethis-mcp

Official
by Aethis-ai

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
AETHIS_API_KEYNoOptional deliberate process-environment override for the platform key. Prefer saved-profile references when installing; avoid putting raw keys in host config or command arguments.
AETHIS_PROFILENoNon-secret saved profile name. It pins the account and endpoint used by this registration, even if the CLI's active_profile later changes.
AETHIS_BASE_URLNoBase URL for the Aethis API. Default is https://api.aethis.ai.https://api.aethis.ai
XDG_CONFIG_HOMENoAbsolute 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_ANTHROPIC_KEY_ENVNoThe 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.

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Aethis is an AI platform for regulated eligibility checks.

Workflows

Author rules (TDD): aethis_create_ruleset → aethis_discover_fields → aethis_set_tests (complete reviewed suite) → aethis_generate_and_test (60-120s) → aethis_refine (if failures) → aethis_publish Evaluate eligibility: aethis_schema (discover fields) → aethis_decide (with optional include_trace/include_explanation) Conversational check: aethis_next_question iteratively with growing field_values until decision reached Discover (public catalogue): aethis_discover_rulesets — no auth required; cross-tenant showcase rulesets Discover (your tenant): aethis_list_projects → aethis_list_rulesets — requires AETHIS_API_KEY Discover rulebooks (composed wholes): aethis_list_rulebooks → aethis_rulebook_schema(rulebook_id) — answers 'what rulebooks exist?' and 'how do this rulebook's rulesets compose?'; requires AETHIS_API_KEY Create/update a rulebook: aethis_create_rulebook (empty draft) → aethis_update_rulebook (name/description/slug/robot_hints) — robot_hints is beat-keyed natural-language guidance for the conversational agent; requires AETHIS_API_KEY Visualise structure: aethis_graph(ruleset_id or rulebook_id) — the ruleset-map graph plus a ready-to-render mermaid diagram; pass include_graph_overlay: true to aethis_decide to stamp a specific decision's per-criterion status onto that same map

Key Principles

  • Tests come FIRST — define expected outcomes before generating rules

  • Guidance must reference specific source text — vague feedback like 'fix it' won't help

  • Decision tools (aethis_decide, aethis_schema, aethis_explain, aethis_next_question) need no authentication

  • aethis_discover_rulesets is the no-auth catalogue browser — use it whenever the user wants to explore what's available without committing to a tenant

  • Authoring tools need an API key (AETHIS_API_KEY or 'aethis login')

  • Decisions are deterministic, <1ms, no LLM at inference time — all rules are pre-compiled

Reporting decisions

  • Every factual claim in your prose must trace to a field in the tool response. If it is not in the JSON, do not assert it.

  • The engine evaluates one ruleset or one rulebook per call. Do not generalise a single-ruleset result to a household, organisation, or any larger composite outcome.

  • Do not name rulesets, rulebooks, fields, or capabilities you have not seen in a response from aethis_discover_rulesets, aethis_list_rulesets, or aethis_schema in this session. A slug pattern is not evidence of existence.

  • Before offering to call a follow-up tool against another ruleset or rulebook, verify it exists in this session. If you have not verified it, do not offer it.

  • If the user asks a question that the current decision does not answer, say so explicitly rather than extrapolating.

  • Quote decision_id, ruleset_id or rulebook_id, and engine version verbatim from the response when summarising — these are the audit primitives.

Prompts

Use the 'aethis-author' prompt for a step-by-step rule authoring guide. Use the 'aethis-decide' prompt for a decision workflow guide.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
prompts
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
aethis_schemaA

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

aethis_decideA

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.

aethis_next_questionA

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.

aethis_graphA

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.

aethis_explainA

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

aethis_explain_failureA

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.

aethis_list_projectsB

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

aethis_list_rulesetsA

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.

aethis_generation_statusA

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.

aethis_cancel_generationA

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.

aethis_discover_rulesetsA

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.

aethis_list_rulebooksA

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.

aethis_usageA

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.

aethis_rulebook_schemaA

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_*).

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.

aethis_update_rulebookA

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.

aethis_archive_projectA

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

aethis_archive_rulesetA

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

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.

aethis_set_testsA

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.

aethis_list_guidanceA

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.

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.

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.

aethis_list_domain_guidanceB

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

aethis_discover_sectionsA

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.

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.

aethis_validate_sectionsA

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.

aethis_discover_fieldsA

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.

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.

aethis_validate_fieldsA

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.

aethis_set_field_specA

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.

aethis_set_bundle_contractA

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.

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.

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.

aethis_publishA

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

aethis_review_projectA

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.

Prompts

Interactive templates invoked by user choice

NameDescription
aethis-authorStep-by-step guide to authoring eligibility rules from legislation or policy text (TDD workflow)
aethis-decideEvaluate eligibility against a published ruleset, or run a conversational eligibility check

Resources

Contextual data attached and managed by the client

NameDescription

No resources

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