Three languages.
One daemon contract.

Connect to your daemon

Request evaluation packages (v0.1.0). They are not on npm or PyPI. After you receive the archive, install from that directory. Binaries and SDKs are not public downloads.

AAES_ENDPOINT

The daemon address configured with platformd -listen. The default daemon address is http://127.0.0.1:8090. The daemon does not terminate TLS by default.

AAES_TOKEN

The operator-issued bearer token. The credential resolves the tenant. The SDKs fill tenant_id and actor_id so they match the token.

After you receive the evaluation archive, work from that directory. These examples assume a running daemon and a token associated with a registered caller. Set AAES_ENDPOINT and AAES_TOKEN first. Each example reads the capabilities the caller may use.

For routes and the HTTP contract, see the API reference and download the OpenAPI 3.1 contract. Remaining integration notes ship with the evaluation package.

Go

A zero-dependency Go 1.27 module, separate from the daemon tree. After you receive the evaluation archive, from that directory, replace the module with the supplied source:

go mod edit -replace=github.com/aaes-dev/aaes/sdk/go=./sdk/go

Read permitted capabilities and handle a failed request:

package main

import (
    "context"
    "fmt"
    "log"

    aaes "github.com/aaes-dev/aaes/sdk/go"
)

func main() {
    client, err := aaes.FromEnv()
    if err != nil { log.Fatal(err) }
    result, err := client.Capabilities(context.Background())
    if err != nil { log.Fatal(err) }
    fmt.Printf("%d permitted capabilities\n", len(result.Capabilities))
}

Python

From the evaluation archive directory, install the supplied Python 3.12+ wheel. Its runtime uses only the standard library; annotated source and PEP 561 metadata are included:

python3 -m pip install ./aaes_sdk-0.1.0-py3-none-any.whl

Read the caller's permitted capabilities:

from aaes import AaesError, Client

try:
    result = Client.from_env().capabilities()
    print(f"{len(result.capabilities)} permitted capabilities")
except AaesError as error:
    raise SystemExit(str(error))

JavaScript

From the evaluation archive directory, install the supplied ESM package for Node 24+. Public TypeScript declarations and wire response types are included. JavaScript method names are camelCase throughout:

npm install ./aaes-sdk-0.1.0.tgz

Import the installed package:

import { Client } from "@aaes/sdk";

try {
  const result = await Client.fromEnv().capabilities();
  console.log(`${result.capabilities.length} permitted capabilities`);
} catch (error) {
  console.error(String(error));
  process.exitCode = 1;
}

Read the method and authorization matrix. New read APIs retain daemon wire names, such as work_id; existing action results retain their language-native fields.

Methods and helpers

The table lists Go entry points. Python uses snake_case (request_access, present_grant). JavaScript uses camelCase (requestAccess, presentGrant). Use the SDK methods page for the full matrix.

Daemon refusals are JSON with a reason. A remedy is included when the daemon can name the smallest change that would satisfy the refusal.

Request safety and verification

• Registered destinations. An action does not accept a caller-supplied application URL, HTTP method, or credential. Brokered calls use deployment-controlled application credentials. Federation, when separately wired and validated, instead returns credential material or issuance instructions and the registered target to the caller. The bearer token authenticates the daemon caller; it is not an application credential to embed in an action.
• Caller identity. tenant_id and actor_id are claims that must match the token. The SDKs fill them.
• Explicit retries. Retry is limited to 503, is opt-in, and requires an effect key. Automatic retries are permitted only for release-documented operations and failure stages; never use a new effect key merely to get past a conflict or an uncertain result. On the decision routes a daemon-originated 503 precedes the sealed decision, so nothing was committed or executed; a post-seal failure arrives as 403 in the route's decision shape, whose receipt records how far the action got. On the federated route a 503 can follow a sealed decision (a mint or marker failure), but no grant material was released and the live-grant slot was freed, so a retry with the same effect key step is permitted there. A missing response (timeout, reset connection, intermediary error) is not evidence of anything. Reconcile first via GET /v1/receipts?work_id=… and the intent, effect and effect-id fields the read API publishes, or give the work ID, effect key step and your correlation identifiers to the operator to find the sealed decision in the journal. A missing receipt is not proof nothing was committed; a duplicate-effect 409 proves recording, not downstream success; and 409 also covers other state conflicts, so the status alone never identifies the situation. Read the reason. Remaining retry notes ship with the evaluation package.
• Receipt verification. The SDKs do not verify receipts. Use the offline operator CLI.

Verify offline

Given an export and public key from your evaluation install, run:

aaesctl verify --export <export.jsonl> --pubkey <key.pub>

No running service is required. See the CLI reference for offline audit commands, or return to the API reference for the daemon contract.