Build with AUREON.

RELEASE / DEVELOPMENT

Know which build you are using.

The selected runtime uses the preserved graph/reuse numerical path. This is not a claim of identical full-pipeline speed. Development candidates and retired fused-batching experiments are not alternate recommended installs; their evidence is retained.

Any-to-any remains an architecture direction, not universal route support. The published generation route remains TerraMind 1.0 base: S2L2A → synthetic S1GRD. Hosted inference remains closed.

INTERFACES / QUALIFICATION

Connect sources and resident models.

These interfaces are present in the current source and Best package. Installed-model and performance acceptance remain specific to the named artifact and route. The install guide below selects the current Best wheel.

Selected STAC raster windows

Resolve an explicitly selected local or controlled-range GeoTIFF asset, read bounded windows, run the existing TerraMind scene engine, and export COGs with provenance. Source identity, bands, units, grids and masks are validated. CPU fixtures cover local and loopback range-read delivery; this adds no real-model, external-provider or performance qualification.

Borrowed resident models and device tensors

Reuse a caller-owned resident model through explicit ownership and device/stream contracts. CPU interface checks pass; CUDA tensor/stream execution is not newly qualified.

Upstream temporal wrapper

The actual upstream temporal wrapper has CPU integration checks. This does not qualify new pretrained temporal models or GPU workloads.

Explicit adapter registration

Register adapters per instance with dependency admission. A registry entry does not imply every model or modality route is executable.

CPU suites cover COP-GEN contracts, raster/loopback delivery with a fixture engine, and actual upstream random-weight integration. The installed-model checks above qualify only their named routes. No public endpoint or automatic model download is enabled.

ENGINE / EXECUTION

One core. Model-specific execution.

Python, CLI and the local async API share the inference core. Adapters own tokenization, sampling and decoding; the delivery layer preserves spatial metadata and output provenance.

Resident execution

Keep weights loaded across jobs while isolating request RNG and sampling state.

Eligible conditioning reuse

Reuse unchanged work only under the applicable identity, shape, precision and recipe checks. This is not an output cache.

Guarded decoder graphs

The recorded TerraMind benchmark explicitly enables denoiser CUDA graphs. The recommended local base profile selects graph/reuse by default; eligibility checks and native reference execution remain available. This is not a universal graph backend.

Geospatial delivery

Write and verify COGs, masks, grid metadata and provenance. Generated SAR remains synthetic; spatial correctness does not prove physical accuracy.

These mechanisms describe implemented paths. Their combined measured result belongs to the original benchmark workload, not every model or development build.

MODEL FAMILIES

Supported model families.

Local support. Each family defines its inputs, outputs and runtime limits.

QUICKSTART / v0.1.0

Install AUREON Engine.

Linux x86_64 or WSL2 · Python 3.12 · NVIDIA GPU for explicit model execution.

Public alpha v0.1.0 · Available on GitHub.

Download the Best wheel and matching source from GitHub. Models, imagery, credentials and CUDA drivers are supplied separately. The release identity manifest binds the exact bytes. Original release files remain historical assets; the current recommended wheel is e09e710c9e9ace17b7bf2214d8c9eff2c4ed605a7d45e8c4e649b672f6f88a64.

1. Install in a fresh environment.

The direct URL uses ordinary dependency resolution. For the tested pinned generation stack, follow the source-lock instructions below.

python -m pip install "https://github.com/LeChiffreVol2/aureon/releases/download/v0.1.0/aureon_inference-0.1.0-py3-none-any.whl#sha256=e09e710c9e9ace17b7bf2214d8c9eff2c4ed605a7d45e8c4e649b672f6f88a64"

Both the original alpha and Best use version 0.1.0. Use a new environment and compare SHA-256; a version-only upgrade can retain the earlier wheel.

2. Reproduce the tested dependencies.

Download and verify the matching source archive SHA-256 586682c5e404da145ad99ac917f284fc45e49aef759f48283a2995903a2be02a, then use its locks. Do not install the historical scene/cu130 stack into this generation environment.

tar -xzf aureon_inference-0.1.0.tar.gz
python3.12 -m venv "$HOME/aureon-best-env"
. "$HOME/aureon-best-env/bin/activate"
python -m pip install --require-hashes -r aureon_inference-0.1.0/packaging/lock-bootstrap-generation.txt
python -m pip install --require-hashes --no-build-isolation -r aureon_inference-0.1.0/packaging/lock-generation-linux-py312-cu128.txt
python -m pip install --no-index --no-deps ./aureon_inference-0.1.0-py3-none-any.whl
python -m pip check
aureon-engine check --environment generation

These are installation commands, not inference. KAO-TerraMind full-reference routes use the optional scene-legacy dependencies in the dependency guide. Frozen source documentation retains some earlier release-status wording; current release notes identify the published files.

FIRST RESULT

Use your own Sentinel-2 input.

Follow the asset and input quickstart, then the resident and whole-scene workflow. Model execution is explicit. TerraMind produces synthetic S1GRD with grid and provenance; it is not a radar observation.

Retained acceptance on this exact Best wheel covers 26 TerraMind calls across native tiles, a four-tile scene, local HTTP and private local dispatch, with exact FP32 output. Earlier KAO-TerraMind B/A/C receipts retain their artifact-specific scopes. This release update adds no model run or benchmark.

LOCAL API

Submit, observe and download.

Use the authenticated local service guide for upload → submit → status → verified COG/provenance. The selected TerraMind HTTP executor is base-generation/scene scoped; Backbone and TiM use their SDK/CLI contracts. The public website does not run an inference service.

SETUP CHECKS

Check identity before execution.

Verify wheel and source hashes, use the matching dependency profile, and run aureon-engine doctor for explicit model-asset checks. Installation and help do not download weights or run a model. Preserve the job ID after an observation timeout; inspect status before resubmitting. Hosted inference and PyPI remain closed.

AUREON USE CASE / LAND-COVER SEGMENTATION

Download. Verify. Inspect.

Available now · Recorded outputs

Explore an audited Thailand scene processed with KAO-TerraMind B. Download the original COGs, verify their hashes and open them in GIS.

"""Download the published recorded result; no model or service is started."""
import hashlib
import json
from pathlib import Path
from urllib.request import urlopen
from uuid import uuid4

BASE = "https://aureon-foundation.vercel.app"


def fetch(path, limit):
    with urlopen(BASE + path, timeout=30) as response:
        data = response.read(limit + 1)
    if len(data) > limit:
        raise ValueError("Response exceeded its expected size")
    return data


def main():
    receipt = json.loads(fetch("/examples/thailand/receipt.json", 65536))
    assert receipt["schema"] == "aureon.public_recorded_result.v1"
    verified = {}
    for name in ("class_map.tif", "valid_mask.tif"):
        item = receipt["artifacts"][name]
        path = "/examples/thailand/" + name
        if item["url"] != path or not 0 < item["bytes"] <= 16 * 1024 * 1024:
            raise ValueError("Unexpected artifact declaration")
        data = fetch(path, item["bytes"])
        if (len(data) != item["bytes"] or
                hashlib.sha256(data).hexdigest() != item["sha256"]):
            raise ValueError("Verification failed: " + name)
        verified[name] = data

    output = Path("aureon-example-" + uuid4().hex[:8])
    output.mkdir(exist_ok=False)
    for name, data in verified.items():
        (output / name).write_bytes(data)
        print("Verified:", name)
    (output / "receipt.json").write_text(json.dumps(receipt, indent=2))
    print("Results:", output)
    return output


if __name__ == "__main__":
    main()

Downloads recorded COGs to a new directory and verifies their hashes. No inference is run.

02 / INPUT CONTRACT

Prepare the scene.

Validated internally · Input reference

Align twelve Sentinel-2 L2A bands in this order:

B01 B02 B03 B04 B05 B06 B07 B08 B8A B09 B11 B12

Inference uses all twelve bands. RGB is display-only.

03 / INFERENCE API

Submit. Track. Retrieve.

Validated internally · No public inference endpoint

This reference documents the earlier registered-scene API behind the recorded result. Use the download example to inspect its outputs. The current Engine API supports authenticated local upload → submit → status → verified artifacts, with one model/task per service. This is not its upload quickstart.

{
  "scene_id": "your-registered-scene"
}

Use a bearer token from your operator and an Idempotency-Key per submission. Retry uncertain outcomes with the same key and payload. This website does not issue credentials.

{
  "job": {
    "job_id": "<job-id>",
    "status": "queued"
  },
  "reused": false
}

Poll for completed, failed or cancelled. Completed jobs include artifact paths, sizes and SHA-256 hashes. Verify each download.

Public downloads contain both original COGs and a curated receipt.

04 / USE THE OUTPUT

Read the class map.

Available now · Run with downloaded files

Open class_map.tif in QGIS with categorical styling. Apply valid_mask.tif before analysis. The Python example uses NumPy and Rasterio to check grids and count valid pixels.

"""Read verified recorded COGs: python read_result.py <result-directory>."""
import sys
from pathlib import Path
import numpy as np
import rasterio

folder = Path(sys.argv[1])
with rasterio.open(folder / "class_map.tif") as classes, \
        rasterio.open(folder / "valid_mask.tif") as mask:
    assert classes.crs == mask.crs
    assert classes.transform == mask.transform
    assert classes.shape == mask.shape
    prediction = classes.read(1)
    valid = (mask.read(1) > 0) & (classes.read_masks(1) > 0)
    valid &= prediction != 255
    assert np.all(prediction[valid] < 10)
    counts = np.bincount(prediction[valid], minlength=10)
    print("Grid:", classes.crs, classes.shape)
    print("Valid pixels:", int(valid.sum()))
    print("Excluded pixels:", int((~valid).sum()))
    for class_id, count in enumerate(counts):
        print(f"Class {class_id}: {int(count)}")

Run python read_result.py <download-directory>. Expected: 262,143 valid pixels and 1 excluded pixel. Numerical parity verifies execution, not accuracy. Predictions are not ground truth.

CLASS REFERENCE

Class reference.

KAO-TerraMind class order. NoData: 255.

JOB LIFECYCLE

Job states and errors.

Validated internally · Engine reference

queued → running → completed. Failed and cancelled jobs do not publish result artifacts. Only queued jobs can be cancelled through DELETE /v1/jobs/<job-id>.

Hosted jobs are not yet open. Capacity and service levels are unpublished.

MEASUREMENT / 27 OCT 2026

Benchmark methodology.

The landing table reports one TerraMind 1.0 base run on an RTX 3070 with 8 GB VRAM: real 224 × 224 Sentinel-2 L2A to synthetic S1GRD, highest FP32, 8 token steps and 10 diffusion steps. Same checkpoint, input and seeds; alternating U–A–A–U.

Full input read/upload through verified saved COG and provenance, using local IPC with serial batch 1 / FIFO 3. The baseline is TerraTorch + native vLLM with an independent TerraMind adapter, corrected conventional I/O and explicit batch-one, in-process and 0.85 reservation overrides. AUREON combines resident execution, encoder reuse, denoiser CUDA graphs and descriptor I/O.

20 logical jobs plus 8 conditioning requests pass exact parity. Each arm contributes 2 sequential and 6 burst observations; all 8 matched warm delivery pairs and both execution orders favor AUREON. Warm worker-hours exclude startup and represent the audited pooled burst workload, not sequential median latency.

The original cost evidence uses 1 THB per machine-hour. Dividing those amounts by that rate gives 0.148807 upstream and 0.118213 AUREON worker-hours per 1,000 jobs. The audit derives this from summed burst windows divided by 6 jobs, scaled by 1,000 / 3,600. At the same hourly rate, normalized cost is 20.56% lower. Multiply worker-hours by your own worker-hour rate; no currency conversion, service price or provider bill is implied. The downloadable source metrics retain their original THB fields.

Elapsed timing uses CLOCK_MONOTONIC_RAW, checked against 1,900 Windows QPC samples. GPU clocks were observed, not locked: the first upstream residency was P0; the remaining residencies were P2. Both orders improve, including P2 versus P2. These are observed results for this configuration, not guaranteed performance on other hardware.

Download metrics and method summary

Exact FP32 parity measures execution fidelity, not the physical accuracy of synthetic SAR. This benchmark measured original Best wheel 0fa5ef2b9440fcc310a17c76f78df52278cbe2d354015be2046a8e4196715c97. The selected integrated e09e710c package has separate functional acceptance; these competitor percentages do not measure that package. The public alpha download and later development qualifications remain separate artifacts; the original competitive table has not been re-benchmarked.