AuraOne / Developers

Build against a versioned API and keep the evidence attached.

Typed TypeScript and Python clients for evaluation workflows, signed webhooks, and REST endpoints for runs, evidence, and exports.

Explore our public TypeScript and Python SDKs, signed webhook specifications, and enterprise connector catalog below.

At a glance

API at a glance

Typed SDKs & workflow API
Typed clients
2 typed clients
Connectors
9 catalog entries (5 GA)
Workflow API
Versioned REST & webhook contracts
Events
HMAC signed
Evidence
Delivery history per webhook

Developer tools

Start with the contract your system can use today.

Connect Enterprise Intelligence workflows, call the versioned evaluation API from TypeScript or Python, and verify signed webhook deliveries.

SDK packages
2 TypeScript and Python clients.
Connector catalog
9 5 GA · 4 Beta. Beta connectors are in active development.
Delivery contract
Signed Verify webhook origin before routing the event.

Developer path

Enterprise workflow integrations

Enterprise Intelligence provides a canonical versioned workflow API for definitions, approvals, runs, traces, human exceptions, delivery, and acceptance.

Build against the EI workflow API

Developer path

REST API

Create and track evaluation runs through versioned /api/v1 endpoints with typed request and response contracts.

Read the SDK reference

Developer path

Signed webhooks

Verify the HMAC signature on each delivery before routing it into downstream systems. Event subscriptions are configurable per workspace.

Inspect event delivery

Developer path

Robotics contracts

Work with reviewed clips. Each one keeps its session, its license scope, and its provenance as a single record.

Read the capture schema

Developer path

Infrastructure boundaries

Trace reviewed work from training through serving, rollback, and customer handoff.

Review infrastructure

First commands

Install the client, set the scope, and create the first run.

The quickstart switches language without changing the API contract or the evidence fields returned by the run.

quickstart.ts
npm install --save-exact @auraone/[email protected]
import { AuraOneClient } from "@auraone/sdk";

// Platform-issued key: ak_<8 hex>_<64 hex>
const client = AuraOneClient.withApiKey(process.env.AURAONE_API_KEY!, {
  // Optional: assert the organization — must match the key's org.
  orgId: process.env.AURAONE_ORG_ID,
});

const run = await client.evaluations.create({
  template_id: "YOUR_TEMPLATE_ID",
  agent_bundle_url: "s3://YOUR_BUCKET/path/to/agent-bundle.zip",
  config: { inputs: [{ prompt: "Hello", expected: "Hi" }] },
  wait: false,
});

console.log(run.id, run.status);

TypeScript

@auraone/sdk

Published

npm distribution. Current version: 1.0.0. Entry point: AuraOneClient, VERSION, DEFAULT_CONFIG.

Package documentation

Python

auraone-sdk

Published

PyPI distribution. Current version: 1.0.0. Entry point: AuraOneClient, AsyncAuraOneClient.

Package documentation

Operating trace

Keep context connected from API request to delivery.

Follow each object from authentication through review, delivery, and downstream verification.

  1. 01

    Authenticate

    Use a scoped key and named API version.Key owner and scopes
  2. 02

    Create work

    Submit the source object and versioned criteria.Request and source context
  3. 03

    Review

    Retain reviewer state, exceptions, and decisions.Review evidence
  4. 04

    Deliver

    Return the result, manifest, and signed event.Export and webhook

The coding sample

Check the coding sample yourself.

The sample ships with one script. It runs offline and needs no credentials. It tells you whether the files are the ones we shipped, and whether each task's recorded runs support its verdict. Node.js 20 or later.

node coding/run-all.mjs

Optional: rebuild each task's starting code from its source. This needs git, and network access for tasks from public repositories. Nothing is installed and no test is run.

node coding/run-all.mjs --rebuild-start-trees --work /tmp/fs-replay

What it checks

Offline, from the files in the package.

  • Files Every file matches the manifest hash. Nothing is missing, altered or unlisted.
  • Records Each task record is canonical JSON with a matching hash.
  • Verdicts For each verified task, the verdict is recomputed from the recorded runs: identical cold starts, a failure before the fix, a pass with the reference fix, three of three repeats, every wrong patch we tried rejected, every tamper probe detected.
  • Attempts Each recorded attempt names its model, serving route and run id, and matches its build receipt.

What it does not check

The limits are in the package, and here.

  • Hidden tests The hidden grading tests and reference fixes are not in the package.
  • Human review None of the six tasks has had one yet.
  • Model quality Six tasks and nine attempts are too few for any statistic about a model.

What is in the package

Records you can read, and schemas that describe them.

  • Manifest Every file and its hash.
  • Schemas Task, verification receipt, trajectory, and rights matrix.
  • Dataset card Names every limit of this sample.
  • Contract tier Hidden checks, reference fixes and holdouts sit here, disclosed by signed scope.

There is no hosted grader, and no public access to hidden tests.

A production integration has an inspectable path.

The same steps apply whether you start from an SDK, a REST endpoint, or a webhook.

  1. 01

    Choose the contract

    Confirm the package, version, endpoint, event, and scope.

    SDK manifest and API version

  2. 02

    Run a realistic workflow

    Use a source item that exercises the real criteria, review, and export path.

    Request, response, and review result

  3. 03

    Verify downstream delivery

    Validate the signature, retries, idempotency, and archive destination.

    Webhook and connector receipt

  4. 04

    Confirm production ownership

    Record ownership, retention, failure handling, and the next release check.

    Production ownership plan

Before launch

Production integration checklist

Confirm the interface, the authentication, and the recovery path before launch.

Interface
SDK package, API version, and event schemaSDK and API documentation
Authentication
Key owner, environment, and rotation pathCustomer integration configuration
Verification
Test request, response, and retry behaviorIntegration test results
Operations
Retention, ownership, and failure handlingProduction review