# io.github.Aethis-ai/aethis-mcp (npm · aethis-mcp)

Deterministic eligibility decisions and test-driven rule authoring via the Aethis developer API.

- Trust score: 90/100 (high trust)
- Change this week: +19
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- npm · `aethis-mcp`: 90/100 (this document), [markdown](https://verifymcp.io/servers/aethis-ai-aethis-mcp/aethis-mcp.md), [page](https://verifymcp.io/servers/aethis-ai-aethis-mcp/aethis-mcp)

## Channel facts

- Registry: `npm`
- Package: `aethis-mcp`
- Version: `0.18.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-21.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 97 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Aethis-ai/aethis-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 6 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 80/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6867 tokens (~196/item across 35 items; 35 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 60/100
  - Stability observed for 18 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 36 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.Aethis-ai/aethis-mcp server?

io.github.Aethis-ai/aethis-mcp runs locally as an npm package, launched with npx -y aethis-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add aethis-ai-aethis-mcp -- npx -y aethis-mcp
```

### Cursor

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

### VS Code

```json
{
  "servers": {
    "aethis-ai-aethis-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "aethis-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add aethis-ai-aethis-mcp -- npx -y aethis-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "aethis-ai-aethis-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "aethis-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add aethis-ai-aethis-mcp --command npx --arg -y --arg aethis-mcp
```

### Hermes

```yaml
mcp_servers:
  aethis-ai-aethis-mcp:
    command: "npx"
    args: ["-y", "aethis-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "aethis-ai-aethis-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "aethis-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add aethis-ai-aethis-mcp -t stdio -c npx -a -y aethis-mcp
```

### Other

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

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-21 (score 90, +1)

No change was recorded against any check on this day. Stability & Change Management went from 57 to 60. That category is still filling its 30-day observation window: 17 days of observed history at the previous scan, 18 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-19 (score 89, +1)

No change was recorded against any check on this day. Stability & Change Management went from 50 to 53. That category is still filling its 30-day observation window: 15 days of observed history at the previous scan, 16 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-17 (score 88, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-15 (score 87, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-09-14 (score 71, −15)

- [security regression] Malware scan: pass → unverified
- [functional] Package version: 0.17.4 → 0.18.0

### 2026-09-13 (score 86, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-11 (score 85, +4)

- [functional improvement] Stability: unverified → 0.27

### 2026-09-03 (score 81)

First indexed and scored.

## MCP tools (35)

### `aethis_schema` (~59 tokens)

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

Input parameters:

- `ruleset_id` (string, required): The ID of the published rule ruleset

### `aethis_decide` (~364 tokens)

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.

Input parameters:

- `field_values` (object, required): Input field values (see aethis_schema for required fields)
- `include_explanation` (boolean): Include human-readable rule explanations with source citations
- `include_graph_overlay` (boolean): Stamp this decision's per-criterion outcome (satisfied/not_satisfied/pending) onto the ruleset-map graph and return it as graph_overlay — the same {nodes, edges, sections, stats} shape as aethis_grap…
- `include_trace` (boolean): Include the full evaluation trace showing how each rule was evaluated
- `rulebook_id` (string): The ID or slug of a composed rulebook (e.g. `aethis/uk-fsm`). Mutually exclusive with ruleset_id. Requires an API key — anonymous callers get HTTP 401.
- `ruleset_id` (string): The ID or slug of a single published ruleset. Mutually exclusive with rulebook_id.

### `aethis_next_question` (~109 tokens)

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.

Input parameters:

- `field_values` (object, required): Answers collected so far (empty dict for first question)
- `ruleset_id` (string, required): The ID of the published rule ruleset

### `aethis_graph` (~233 tokens)

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.

Input parameters:

- `rulebook_id` (string): The slug (e.g. `aethis/uk-fsm`) or opaque id (`rb_*`) of a composed rulebook. Mutually exclusive with ruleset_id. Requires an API key — anonymous callers get HTTP 401.
- `ruleset_id` (string): The ID or slug of a single published ruleset. Mutually exclusive with rulebook_id.

### `aethis_explain` (~50 tokens)

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

Input parameters:

- `ruleset_id` (string, required): The ID of the published rule ruleset

### `aethis_explain_failure` (~132 tokens)

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.

Input parameters:

- `expected_outcome` (string, required): The outcome you expected from this input
- `field_values` (object, required): The test input values that produced the unexpected outcome
- `ruleset_id` (string, required): The ID of the rule ruleset to diagnose
- `test_name` (string): Name of the failing test case (included in the diagnosis for context)

### `aethis_list_projects` (~33 tokens)

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

### `aethis_list_rulesets` (~82 tokens)

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.

Input parameters:

- `project_id` (string, required): The project ID

### `aethis_generation_status` (~101 tokens)

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.

Input parameters:

- `project_id` (string, required): The project ID whose generation status to inspect

### `aethis_cancel_generation` (~167 tokens)

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.

Input parameters:

- `confirm_job_id` (string, required): Repeat job_id to bind the cancellation target; host/user approval is a separate requirement
- `job_id` (string, required): The exact job ID returned by aethis_generation_status
- `project_id` (string, required): The project ID containing the observed generation job

### `aethis_discover_rulesets` (~156 tokens)

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.

Input parameters:

- `limit` (integer): Maximum rulesets to return (default 20, max 50).
- `offset` (integer): Pagination offset (default 0).

### `aethis_list_rulebooks` (~154 tokens)

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_usage` (~122 tokens)

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_schema` (~172 tokens)

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

Input parameters:

- `rulebook_id` (string, required): The slug (e.g. `aethis/uk-fsm`) or opaque id (`rb_*`) of the rulebook

### `aethis_create_rulebook` (~269 tokens)

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.

Input parameters:

- `description` (string): Optional description
- `domain` (string): Domain hint, lower-snake (e.g. 'uk_fsm')
- `name` (string, required): Human-readable name for the rulebook (e.g. 'UK FSM')
- `robot_hints` (object): Assistant guidance for the conversational agent, keyed by conversational beat. Natural language only — no rule syntax, no field keys. Active beats: general_context, preamble, session_start, postamble…
- `slug` (string): Stable human-readable alias (e.g. 'aethis/uk-fsm'). Globally unique when set; recommended for any rulebook referenced from outside this session.

### `aethis_update_rulebook` (~215 tokens)

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.

Input parameters:

- `description` (string): New description
- `name` (string): New human-readable name
- `robot_hints` (object): Assistant guidance for the conversational agent, keyed by conversational beat. Natural language only — no rule syntax, no field keys. Active beats: general_context, preamble, session_start, postamble…
- `rulebook_id` (string, required): The slug (e.g. `aethis/uk-fsm`) or opaque id (`rb_*`) of the rulebook to update
- `slug` (string): New stable alias

### `aethis_archive_project` (~41 tokens)

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

Input parameters:

- `project_id` (string, required): The project ID to archive

### `aethis_archive_ruleset` (~50 tokens)

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

Input parameters:

- `ruleset_id` (string, required): The ruleset ID to archive

### `aethis_create_ruleset` (~140 tokens)

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

Input parameters:

- `domain` (string): Domain hint (e.g., 'uk_immigration')
- `name` (string, required): Human-readable name for the rule ruleset
- `section_id` (string, required): Unique section identifier (e.g., 'flight_readiness')
- `source_text` (string, required): The source legislation, policy, or specification text
- `test_cases` (array, required): Test cases: [{name, field_values, expected_outcome}]. At least 1 required.

### `aethis_set_tests` (~120 tokens)

Replace the complete reviewed test suite for an existing project after field discovery. Requires 1 to 100 cases 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.

Input parameters:

- `project_id` (string, required): Existing project ID whose complete test suite will be replaced
- `test_cases` (array, required): The complete authoritative reviewed suite (1-100 cases); this replaces existing tests

### `aethis_list_guidance` (~54 tokens)

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.

Input parameters:

- `project_id` (string, required): The project ID

### `aethis_add_guidance` (~168 tokens)

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

Input parameters:

- `adherence` (string): How strictly the LLM must follow this hint. 'exact' = must follow precisely, produce nothing beyond what is specified; 'guided' = strong preference, may adapt if source text requires (default); 'loos…
- `guidance_text` (string, required): Domain knowledge or correction not present in the source text
- `process_type` (string): Which authoring phase this hint targets. Use 'field_extraction' for field design principles (e.g. raw-facts principle, solicitor navigation). Defaults to 'rule_generation'.
- `project_id` (string, required): The project ID

### `aethis_add_domain_guidance` (~234 tokens)

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.

Input parameters:

- `adherence` (string): How strictly the LLM must follow this hint. 'exact' = must follow, produce nothing beyond what is specified (use for SME-defined section lists); 'guided' = strong preference, may adapt if source text…
- `domain` (string, required): Domain identifier (e.g. 'uk_citizenship')
- `guidance_text` (string, required): The guidance hint text
- `notes` (string): SME commentary or legislation provenance. Never sent to LLM.
- `process_type` (string): Which authoring phase this hint targets — rule_generation (default), field_extraction, or section_discovery

### `aethis_list_domain_guidance` (~54 tokens)

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

Input parameters:

- `domain` (string, required): Domain identifier (e.g. 'uk_citizenship')

### `aethis_discover_sections` (~332 tokens)

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.

Input parameters:

- `anthropic_key` (string): Your Anthropic API key. [sensitive — do not echo or log] Deprecated in favour of anthropic_key_env / anthropic_key_keychain: when passed as a tool argument, the raw value is written verbatim to the h…
- `anthropic_key_env` (string): Preferred. Name of an env var (set in your MCP client config) holding the Anthropic API key. The raw value never appears in the tool call, so it does not land in the session transcript.
- `anthropic_key_keychain` (string): Preferred on macOS. Keychain reference: either 'service:account' or just 'account' (service defaults to 'aethis-anthropic-key'). The server reads it via the `security` command at call time.
- `domain` (string, required): Domain identifier, e.g. 'uk_citizenship'
- `openai_key` (string): Deprecated — use anthropic_key_env or anthropic_key_keychain. [sensitive — do not echo or log] Accepted for backwards compatibility.
- `sources` (array, required): Source documents to analyse. Provide the actual text content.

### `aethis_refine_sections` (~350 tokens)

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.

Input parameters:

- `anthropic_key` (string): Your Anthropic API key. [sensitive — do not echo or log] Deprecated in favour of anthropic_key_env / anthropic_key_keychain: when passed as a tool argument, the raw value is written verbatim to the h…
- `anthropic_key_env` (string): Preferred. Name of an env var (set in your MCP client config) holding the Anthropic API key. The raw value never appears in the tool call, so it does not land in the session transcript.
- `anthropic_key_keychain` (string): Preferred on macOS. Keychain reference: either 'service:account' or just 'account' (service defaults to 'aethis-anthropic-key'). The server reads it via the `security` command at call time.
- `domain` (string, required): Domain identifier, e.g. 'uk_citizenship'
- `feedback` (string, required): What was wrong and how to fix it, e.g. 'The english language and life in the UK test should be separate sections'
- `openai_key` (string): Deprecated — use anthropic_key_env or anthropic_key_keychain. [sensitive — do not echo or log] Accepted for backwards compatibility.
- `sources` (array, required): The same source documents used in the initial aethis_discover_sections call

### `aethis_validate_sections` (~152 tokens)

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.

Input parameters:

- `discovered_sections` (array, required): Section names/IDs returned by aethis_discover_sections
- `domain` (string, required): Domain identifier, e.g. 'uk_citizenship'
- `expected_sections` (array, required): Section names/IDs the SME expects (snake_case, e.g. ['english_language', 'residence', 'good_character'])

### `aethis_discover_fields` (~275 tokens)

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.

Input parameters:

- `anthropic_key` (string): Your Anthropic API key. [sensitive — do not echo or log] Deprecated in favour of anthropic_key_env / anthropic_key_keychain: when passed as a tool argument, the raw value is written verbatim to the h…
- `anthropic_key_env` (string): Preferred. Name of an env var (set in your MCP client config) holding the Anthropic API key. The raw value never appears in the tool call, so it does not land in the session transcript.
- `anthropic_key_keychain` (string): Preferred on macOS. Keychain reference: either 'service:account' or just 'account' (service defaults to 'aethis-anthropic-key'). The server reads it via the `security` command at call time.
- `openai_key` (string): Deprecated — use anthropic_key_env or anthropic_key_keychain. [sensitive — do not echo or log] Accepted for backwards compatibility.
- `project_id` (string, required): The project ID

### `aethis_refine_fields` (~294 tokens)

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.

Input parameters:

- `anthropic_key` (string): Your Anthropic API key. [sensitive — do not echo or log] Deprecated in favour of anthropic_key_env / anthropic_key_keychain: when passed as a tool argument, the raw value is written verbatim to the h…
- `anthropic_key_env` (string): Preferred. Name of an env var (set in your MCP client config) holding the Anthropic API key. The raw value never appears in the tool call, so it does not land in the session transcript.
- `anthropic_key_keychain` (string): Preferred on macOS. Keychain reference: either 'service:account' or just 'account' (service defaults to 'aethis-anthropic-key'). The server reads it via the `security` command at call time.
- `feedback` (string, required): Guidance about missing or incorrect fields (e.g., 'Section 7 implies a criminal record check')
- `openai_key` (string): Deprecated — use anthropic_key_env or anthropic_key_keychain. [sensitive — do not echo or log] Accepted for backwards compatibility.
- `project_id` (string, required): The project ID

### `aethis_validate_fields` (~138 tokens)

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.

Input parameters:

- `expected_fields` (array, required): The fields you expect to find in the discovered field set
- `project_id` (string, required): The project ID

### `aethis_set_field_spec` (~128 tokens)

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.

Input parameters:

- `expected_fields` (array, required): The fields the SME expects to be discovered for this project
- `project_id` (string, required): The project ID

### `aethis_generate_and_test` (~298 tokens)

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.

Input parameters:

- `anthropic_key` (string): Your Anthropic API key. [sensitive — do not echo or log] Deprecated in favour of anthropic_key_env / anthropic_key_keychain: when passed as a tool argument, the raw value is written verbatim to the h…
- `anthropic_key_env` (string): Preferred. Name of an env var (set in your MCP client config) holding the Anthropic API key. The raw value never appears in the tool call, so it does not land in the session transcript.
- `anthropic_key_keychain` (string): Preferred on macOS. Keychain reference: either 'service:account' or just 'account' (service defaults to 'aethis-anthropic-key'). The server reads it via the `security` command at call time.
- `openai_key` (string): Deprecated — use anthropic_key_env or anthropic_key_keychain. [sensitive — do not echo or log] Accepted for backwards compatibility.
- `project_id` (string, required): The project ID

### `aethis_refine` (~317 tokens)

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.

Input parameters:

- `anthropic_key` (string): Your Anthropic API key. [sensitive — do not echo or log] Deprecated in favour of anthropic_key_env / anthropic_key_keychain: when passed as a tool argument, the raw value is written verbatim to the h…
- `anthropic_key_env` (string): Preferred. Name of an env var (set in your MCP client config) holding the Anthropic API key. The raw value never appears in the tool call, so it does not land in the session transcript.
- `anthropic_key_keychain` (string): Preferred on macOS. Keychain reference: either 'service:account' or just 'account' (service defaults to 'aethis-anthropic-key'). The server reads it via the `security` command at call time.
- `feedback` (string): Optional correction or domain knowledge to add before regenerating
- `openai_key` (string): Deprecated — use anthropic_key_env or anthropic_key_keychain. [sensitive — do not echo or log] Accepted for backwards compatibility.
- `project_id` (string, required): The project ID

### `aethis_publish` (~177 tokens)

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

Input parameters:

- `force` (boolean): Publish even if tests are not all passing
- `label` (string): Human-readable label for this ruleset version, e.g. 'v5 — raw facts, date arithmetic'. Stored on the ruleset and shown in aethis_list_rulesets.
- `name` (string): Override the human-readable section name for this ruleset. When omitted, the ruleset keeps the name set at generation time (a titlecase of section_id, e.g. 'english_language' → 'English Language'). S…
- `project_id` (string, required): The project ID

### `aethis_review_project` (~375 tokens)

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.

Input parameters:

- `anthropic_key` (string): Your Anthropic API key. [sensitive — do not echo or log] Deprecated in favour of anthropic_key_env / anthropic_key_keychain: when passed as a tool argument, the raw value is written verbatim to the h…
- `anthropic_key_env` (string): Preferred. Name of an env var (set in your MCP client config) holding the Anthropic API key. The raw value never appears in the tool call, so it does not land in the session transcript.
- `anthropic_key_keychain` (string): Preferred on macOS. Keychain reference: either 'service:account' or just 'account' (service defaults to 'aethis-anthropic-key'). The server reads it via the `security` command at call time.
- `coach` (boolean): Add an opt-in LLM-synthesised coaching narrative on top of the deterministic rubric. Requires an Anthropic key (anthropic_key_env / anthropic_key_keychain / anthropic_key). Off by default — the deter…
- `openai_key` (string): Deprecated — use anthropic_key_env or anthropic_key_keychain. [sensitive — do not echo or log] Accepted for backwards compatibility.
- `project_id` (string, required): The project ID to review

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/aethis-ai-aethis-mcp/aethis-mcp#diagnostics

## Score history

- 2026-09-21: 90
- 2026-09-20: 89
- 2026-09-19: 89
- 2026-09-18: 88
- 2026-09-17: 88
- 2026-09-16: 87
- 2026-09-15: 87
- 2026-09-14: 71
- 2026-09-13: 86
- 2026-09-12: 85
- 2026-09-11: 85
- 2026-09-10: 81
- 2026-09-09: 81
- 2026-09-08: 81
- 2026-09-07: 81
- 2026-09-06: 81
- 2026-09-05: 81
- 2026-09-04: 81
- 2026-09-03: 81

## Common questions

### What is the io.github.Aethis-ai/aethis-mcp server?

io.github.Aethis-ai/aethis-mcp is listed in the public MCP registry as io.github.Aethis-ai/aethis-mcp. Deterministic eligibility decisions and test-driven rule authoring via the Aethis developer API. This page covers its npm package (aethis-mcp).

### Is the io.github.Aethis-ai/aethis-mcp server safe to use?

io.github.Aethis-ai/aethis-mcp scores 90 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 September 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.Aethis-ai/aethis-mcp server expose?

io.github.Aethis-ai/aethis-mcp exposes 35 tools: aethis_schema, aethis_decide, aethis_next_question, aethis_graph, aethis_explain, and 30 more. Their descriptions and schemas cost roughly 6,115 tokens of context every time the server is loaded.

### Is the io.github.Aethis-ai/aethis-mcp server still maintained?

io.github.Aethis-ai/aethis-mcp is still listed as active in the MCP registry. We last reached this channel on 21 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.Aethis-ai/aethis-mcp server under?

io.github.Aethis-ai/aethis-mcp declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/aethis-mcp
- Socket report: https://socket.dev/npm/package/aethis-mcp
- Repository: https://github.com/Aethis-ai/aethis-mcp
- Website: https://docs.aethis.ai/
- Changelog RSS feed: https://verifymcp.io/servers/aethis-ai-aethis-mcp/aethis-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/aethis-ai-aethis-mcp/aethis-mcp.json
- HTML version of this page: https://verifymcp.io/servers/aethis-ai-aethis-mcp/aethis-mcp