Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.aethis.ai/llms.txt

Use this file to discover all available pages before exploring further.

You are an AI coding agent (Claude Code, Cursor, Windsurf, or similar) — or you’ve been told to integrate Aethis with one. This page is the only one you must read to use the platform. It covers install, a verification call, the auth model, and the four common workflow patterns. Everything else links out to deeper references.

​
Setup

If aethis-cli is available on the user’s machine, one command wires up the MCP server in their editor’s config: 
aethis mcp install --target all
# or one editor at a time: --target claude-code | cursor | claude-desktop | windsurf
If aethis-cli is not installed, fall back to the per-client manual command: 
claude mcp add aethis -- npx -y aethis-mcp
After install, restart the editor. Decision tools (aethis_decide, aethis_schema, aethis_explain, aethis_next_question) are now available with no key. For routing nuance (which interface for which task), see Which interface to use.

​
Verify

Make one decision against a public ruleset: 
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)"
  }
}
If you get this response, the install is working. Browse all public rulesets with aethis_list_rulesets({}).

​
Auth model

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. If your user wants to author rules and isn’t approved yet, point them at aethis.ai/developer-access before continuing.
Once approved, the user provisions an AETHIS_API_KEY (ak_live_…). It goes in the MCP client’s config file, not the shell — the MCP server doesn’t inherit shell env. Generation tools also need an ANTHROPIC_API_KEY, forwarded per-request and never stored.

​
Workflow patterns

Four common tasks an agent will be asked to do. Each maps to one MCP prompt or a short tool sequence.

​
1. User asks: “Check whether X is eligible for Y”

Use the aethis-decide prompt, or run the two-call sequence directly: 
aethis_schema({ ruleset_id: "..." })          // discover required fields
aethis_decide({ ruleset_id, field_values })   // returns eligible | not_eligible | undetermined
Pass include_trace: true for the per-criterion evaluation trail. Pass include_explanation: true for human-readable rule descriptions. If the user provides facts conversationally rather than as a complete struct, switch to pattern 4.

​
2. User asks: “Why did this come out this way?”

Two tools, depending on the question:
  • Explain a decision (rule-text) — aethis_explain({ ruleset_id }) returns the rules in human-readable form. Use this when the user wants to understand the rule structure before or after a decision.
  • Diagnose a failing test — aethis_explain_failure({ ruleset_id, field_values, expected_outcome, test_name }) returns the criterion that failed and a targeted fix hint. Use this during authoring when a test doesn’t pass.

​
3. User asks: “Encode these rules from a policy doc” (private beta)

Use the aethis-author prompt. It walks the 8-step TDD loop:
  1. Gather requirements from the user (target outcome, edge cases)
  2. Discover sections in the source text
  3. Establish field vocabulary
  4. Write test cases first
  5. Seed initial guidance
  6. aethis_generate_and_test
  7. Iterate with aethis_refine and additional aethis_add_guidance until tests pass
  8. aethis_publish
Full procedural guide: Author a rule from legislation. Stop and confirm with the user at the end of each phase. Authoring is the most consequential thing an agent does on the platform — a rule that ships wrong returns wrong decisions to every caller.

​
4. User wants a guided eligibility interview

For decisions where the user supplies facts one at a time: 
let field_values = {}
loop:
  next = aethis_next_question({ ruleset_id, field_values })
  if next.is_eligible !== undefined: break    // decision reachable, stop asking
  ask the user next.question
  field_values[next.field_id] = parsed_answer
The engine computes the optimal next question after each answer — minimum questions to a reachable decision. Different applicants get different question paths.

​
Skills

The aethis-skills package provides higher-level workflows on top of the raw tools. Install once, then invoke by skill name:
SkillPublic/privateWhat it does
decide-with-tracepublicRun a decision with schema validation, full trace, and explanation in one go
policy-to-rulesetprivate betaCreate or reuse a project, discover fields, write test-first scenarios, generate the first ruleset
train-validate-publishprivate betaIterative guidance loop until tests pass, then publish
regression-compareprivate betaCompare decision behaviour between rule versions on a stable corpus, highlight regressions
Install: npx skills add Aethis-ai/aethis-skills. The skills assume the Aethis MCP tools are already wired up.

​
Tool reference

25 tools across decision, authoring, discovery, and management groups. Full list with parameters: MCP server tools. Two MCP prompts: aethis-author (TDD authoring) and aethis-decide (decision lookup). Surfaced as selectable templates in compatible clients. Documented at MCP server overview — Prompts.

​
Going deeper