Call the model directly.
The Aether API exposes the one foundation model with streaming trajectories, capability-gated tool use, durable memory and built-in evaluation. Python, TypeScript, Go and Rust SDKs are first-class; a raw OpenAPI surface lets you wire the model into anything else.
Time-step-by-time-step rollouts
Trajectories stream as they unfold. Interrupt, branch and steer the rollout without re-running from scratch. Server-Sent Events or gRPC streams.
Solvers and instruments as first-class tools
Register your solvers, your CAD kernel and your bench instruments. The model decides when to call them — under your capability policy.
Durable across sessions
Episodic and semantic memory with provenance. Sessions resume cleanly across days. Memories are queryable, versioned and exportable.
Built-in evaluation runs
Submit a workload and a target metric — the API returns scored, traced runs that you can replay and bisect.
Tokens for thought, compute for work
Reasoning is billed per million tokens (frontier-model-comparable). Simulation runs — CFD, FEA, MD, DFT, FEP, ADMET, RTL synthesis — are billed per compute-unit, the way AWS bills GPU-hours. The runtime itself is per-seat.
Stable v1 with semver
v1 is committed. Breaking changes go through a six-month deprecation window and a v2 alias.
Not a hello-world. A turbine blade.
Couple thermal and structural across a transient load step on a turbine blade. Stream the trajectory, watch the stress field, steer the rollout when a limit is approached. The same call in four languages.
from apex import Aether
aether = Aether(api_key=os.environ["APEX_API_KEY"])
# Couple thermal -> structural across a transient load step
trajectory = aether.simulate(
domain="multiphysics",
geometry=open("blade.step", "rb").read(),
physics=["thermal", "structural"],
boundary_conditions={
"inlet": {"T": 1450, "p": 2.2e6},
"outlet": {"p": 1.0e5},
"root": {"fixed": True},
},
horizon_s=12.0,
stream=True,
)
for step in trajectory:
print(step.time, step.max_stress_MPa, step.tip_temperature_K)
if step.max_stress_MPa > 850:
trajectory.steer(redesign="root_fillet+1.5mm")Every endpoint we ship. Every discipline.
The v1 surface is small on purpose. Specialisation lives in the agents you call, not in a sprawl of endpoints.
| Method | Path | Purpose |
|---|---|---|
| POST | /v1/simulate | Run a forward-in-time simulation, optionally streamed and steerable. |
| POST | /v1/design | Generative design — molecules, geometries, layouts — under specified constraints. |
| POST | /v1/dock | Protein-ligand docking with optional induced-fit refinement. |
| POST | /v1/fep | Alchemical free-energy perturbation; relative and absolute binding free energies. |
| POST | /v1/admet | ADMET endpoints. Returns per-endpoint score, calibration, and confidence. |
| POST | /v1/rtl/synthesise | RTL synthesis with PPA targets. Hands off to placement on success. |
| POST | /v1/lab/plan | Bind reagents, schedule plates, allocate instruments — returns a runnable plan. |
| POST | /v1/code/edit | Plan and execute a whole-repo edit. Returns a diff, tests, and a review. |
| POST | /v1/agents/{id}:invoke | Call a specialised agent directly. Each discipline ships with dozens. |
| GET | /v1/sessions/{id} | Resume a long-horizon session. Memory and tool history are restored. |
| POST | /v1/eval/run | Run a workload against a target metric. Returns scored, traced replay. |
| GET | /v1/traces/{id} | Pull the full audit trace for a run — every decision and tool call. |
Failures, readable.
Every error is a documented code with a corrective hint in the body. We don't return generic 500s. We don't surface internal stack traces. The error you get is the error your retry logic can act on.
Your request didn't parse, or a constraint was invalid. The body contains a JSON-Pointer to the offending field and a corrective hint.
No API key or an invalid one. Rotate via /v1/keys; the runtime forces rotation after seven days of unused keys.
Capability policy refused the action — dual-use refusal, controlled-pathogen lookup, export-control gate, or RBAC. Body explains which rule and why.
Optimistic-concurrency clash. Refetch the resource, replay your edit, retry. Idempotency keys avoid this on writes.
Concurrency or compute cap hit. Retry-After header is authoritative. Per-seat plans have no per-token throttle.
Transient capacity pressure. Retry with exponential backoff. Critical workloads can pin a dedicated capacity slice.
Three meters, honest about compute.
Aether is a simulation-native model. One call can emit a few thousand reasoning tokens and then consume hours of solver compute on a CAD geometry. Hiding that cost inside a per-token meter would be misleading, so we don't. Three meters, shaped like the work — and like AWS, the customer's mental model already.
Tokens for thought
Reasoning, planning, code edits, dialog, tool-use decisions, audit traces. Billed per million input and output tokens — the same meter frontier model providers use. Prompt caching and batch get the standard discounts.
- Used by: /v1/code/edit, /v1/agents, /v1/sessions, /v1/eval
- Variants: Aether 7B, 40B, 280B-MoE, Bio 12B
- Discounts: cached input, batch API
Compute for simulation
Running a real workload — CFD, FEA, MD, DFT, FEP, ADMET, RTL synthesis, docking. The solvers are tool calls, and we pass through the GPU- and CPU-hours they actually consume, normalised to a single compute-unit.
- Used by: /v1/simulate, /v1/dock, /v1/fep, /v1/admet, /v1/rtl/synthesise, /v1/design
- Pricing: per CU · reserved capacity available
- Discounts: committed-use, spot-class jobs
Seat for the runtime
The IDE adapters, the long-horizon agent runtime, the memory store, the capability-policy engine, the audit log. Each seat ships with a monthly token and compute allowance; overage rolls into Meters 01 and 02.
- Used by: every IDE adapter, memory, agent runtime
- Allowance: bundled tokens + CU per seat
- Discounts: annual, education, sovereign
Reach the model from wherever you work.
First-class SDKs in four languages. A documented OpenAPI surface for the rest. A CLI for the work you'd rather scope in a terminal. MCP for agentic clients.
A key is a separate purchase from a plan.
A plan buys a person the right to work in the products. An API key buys a program the right to call them, unattended and at any volume. Bundling the second into the first would price the plan for the worst case — so the API is prepaid, and never draws on your plan's monthly allowance.
API calls burn the same credit, at the same published rate, as a run you start in the console. One currency, one rate card.
API credits are prepaid and held apart from your plan. One runaway script cannot consume a team’s month before anyone opens a browser.
| Prepaid bundle | Credits | You pay | Effective rate |
|---|---|---|---|
| 10% off list | 5,000 | $45 | $0.0090 / credit |
| 20% off list | 25,000 | $200 | $0.0080 / credit |
| 30% off list | 100,000 | $700 | $0.0070 / credit |
| Pay as you go | any | — | $0.01 / credit |
Credits do not expire. Buying ahead should not become a deadline.
| Tier | Requests / min | Concurrent jobs | How you get it |
|---|---|---|---|
| Start | 60 | 2 | On any paid plan |
| Build | 600 | 10 | After $100 of API spend |
| Scale | 3,000 | 50 | After $2,500 of API spend |
| Custom | — | — | Arranged with your account team |
Tiers are assigned automatically by spend. Nothing to buy, nothing to apply for.
Wire the model into your stack.
An API key is a separate purchase from a plan. Buy credits, call anything in the catalogue, pay the same published rate as an interactive run.