> ## 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.

# Your first 20 minutes with an AI coding agent

> Connect Claude Code or Codex, discover Aethis tools and skills, and explain your first decision. Then author a reviewed policy and explore versioned replay.

Connect your coding agent, run a public decision, and explain the result from its trace. Then move to a small policy of your own.

The first 20 minutes is a suggested learning session, not a measured completion guarantee. Install downloads, host access and human review take different amounts of time. Authoring is a separate stage with an invitation and model-provider access.

## Before you start

* An installed, signed-in Claude Code or Codex host and Node.js/npm for the MCP server and skill installer.
* A project directory you control. Start a new agent session there after setup.
* No Aethis key or model-provider key for public decisions. Your coding agent's own access is separate.
* For authoring later: [invited access](https://aethis.ai/developer-access), an Aethis credential profile, and a securely supplied Anthropic key reference.

## 1. Connect your host

<Tabs>
  <Tab title="Claude Code">
    ```bash theme={null}
    claude mcp add aethis -- npx -y aethis-mcp
    claude mcp list
    ```

    Start a new Claude Code session and confirm that Aethis tools are available.
  </Tab>

  <Tab title="Codex">
    ```bash theme={null}
    codex mcp add aethis -- npx -y aethis-mcp
    codex mcp list
    codex mcp get aethis
    ```

    Start a new Codex session and confirm that Aethis tools are available. Codex uses its MCP configuration, rather than Claude Code's `.mcp.json`. See [Codex MCP configuration](https://developers.openai.com/codex/mcp).
  </Tab>
</Tabs>

If you use the [Aethis CLI](/interfaces/cli), `aethis mcp install --target claude-code` or `aethis mcp install --target codex` configures the chosen host. `--target all` includes Codex and requires its executable to be installed. The installer records non-secret profile/configuration references, not key values. Preserve any deliberate existing host overrides; an ambiguous configuration needs review before replacement.

## 2. Install and discover the skills

From your project directory:

```bash theme={null}
npx skills add Aethis-ai/aethis-skills -a claude-code -a codex
```

Select the four Aethis skills in the installer, then start a fresh host session. Ask:

```text theme={null}
List the installed Aethis skills and the Aethis MCP tools you can actually call.
Confirm decide-with-trace, policy-to-ruleset, train-validate-publish and
regression-compare are available. If anything is missing, stop and explain
which installation or host restart is needed.
```

Expected result: the host discovers the four skills and callable MCP tools. A successful shell install alone does not establish discovery inside a running host.

## 3. Make and explain a public decision

```text theme={null}
Use the decide-with-trace skill and Aethis MCP.
Read the schema for aethis/uk-fsm/child-eligibility.
Evaluate child.age = 10 and child.school_type = state_funded with a trace.
Explain the outcome from the returned trace and source references.
Report field_errors and retain the returned ruleset identity and content digest.
Do not use general knowledge to invent an eligibility answer.
```

Expected result: `eligible`, no blocking `field_errors`, and a trace from the selected ruleset. The [first-decision page](/getting-started/first-decision) shows the corresponding no-key HTTP call.

Now check an intentional input error:

```text theme={null}
Repeat the decision with child.aeg instead of child.age.
Show the field error and outcome. Then correct the field name using the schema
and repeat the original decision.
```

Expected result: the misspelt field produces `undetermined` with a field error; the corrected call returns the original outcome. You have now connected the host, discovered skills/tools, evaluated a case and used the schema to recover from an input error.

## 4. Go deeper: author one small policy

<Warning>
  Authoring is invite-only and generation uses your model-provider capacity. Finish [authentication setup](/reference/authentication) before continuing. Keep credentials out of chat, source files, command arguments and transcripts.
</Warning>

Use `aethis login` to establish a saved profile, then run the install command for your host again and restart it. The installer pins the selected profile name and configuration location. If a one-off environment key or endpoint conflicts with that profile, save/select the intended profile before installing; do not paste the key into host configuration to bypass the refusal.

Supply the provider key through the MCP process's secure environment or a macOS keychain reference. Pass only its reference name, such as `anthropic_key_env: "PARTNER_QA_ANTHROPIC_KEY"`. A variable in an unrelated terminal is not available to an already-running desktop host. See [key management](/mcp-server/overview#key-management).

```text theme={null}
Use policy-to-ruleset, then train-validate-publish, for this synthetic policy:
An applicant is eligible if and only if applicant_age_years is at least 18.
The input is an integer number of whole years; no other fact affects the rule.

First look for an existing matching project and ask before selecting an ambiguous
match. Keep the selected project ID throughout. Review the source, discovered
field names, and tests with me before generation: 17 is not_eligible,
18 and 19 are eligible. Do not invent expectations for unspecified cases.
If reusing a project, do not replace stored tests unless I supply and approve
the complete authoritative suite.

After approval, save tests to that same project, generate and run every reviewed
test. Repair the candidate from the source if a test fails; do not change the
expectations to obtain a pass. Ask before publishing and retain the immutable
publication receipt. Evaluate the published result against the same cases.
```

Follow [Author your first ruleset](/getting-started/author-first-ruleset) for exact calls and review checkpoints. Completion means the approved tests pass on the selected project and the published result, with retained identity—not merely that generation stopped.

### Resume after a tool timeout

The host can stop waiting before server generation finishes. Keep the `project_id` before starting generation. Call `aethis_generation_status` for that exact project; do not start another generation because a host tool timed out. Use short read-only status calls until the job is terminal, then follow its retry readiness. A lost creation response is a separate uncertainty: inspect existing projects rather than assume nothing was created.

## 5. Advanced: versions, composition and integration

Use [Versions and replay](/agents/versions-and-replay) to run `regression-compare` on an approved corpus, inspect an existing synthetic composition, replay its immutable release through REST, and integrate decisions in an application.

The [Python SDK](/interfaces/python-sdk), [CLI](/interfaces/cli), [MCP server](/mcp-server/overview) and [REST API](/interfaces/rest-api) have distinct supported operations. The TypeScript SDK is not released. A working example on one interface does not certify every workflow on another.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.