From pixels to decisions.
At planetary scale.

Union is built on Flyte, the open-source AI runtime we create and maintain under the Linux Foundation AI & Data.

A single global inference run can mean tens of millions of tiles across petabytes of imagery. Fanning out over them is plain async, and the cluster scales back to zero when the run is done, so you process a continent the same way you process a county.

• Concurrency you can cap. `flyte.map.aio(fn, tiles, concurrency=500)` bounds how many run at once, for a fan-out wider than the cluster.
• Retries with pacing. `retries=5`, or a `RetryStrategy` with exponential backoff so a flaky imagery API gets time to come back.
• Built for spot. `interruptible=True` puts tiles on spot nodes and cuts compute costs by more than 90%. Losing one is expected here, not an incident.

One Sentinel-2 tile fits comfortably in 8Gi. The next one, dense urban coverage at 10m with every band loaded, does not. Union hands you a typed error instead of a stack trace, so a tile that blows memory comes back as an exception you can catch and re-run on a bigger box.

• Typed infrastructure errors. `OOMError`,` TaskInterruptedError`,` TaskTimeoutError`, `ImagePullBackOffError`. Failures you can branch on.
• Resources changed at runtime. `.override(resources=...)` re-runs the same tile with different memory, CPU, or accelerator.
• The policy is yours. Write the handler once and every raster pipeline in your org can import it.
• The handler does not have to be human. Provisioning is an ordinary Python call, so the same API you write a retry policy against is one an agent can call while a run is in flight.

A continental inference run dies on tile nine million of eleven million. Starting from the top pays the bill for the nine million tiles that already succeeded. Union records what finished as the run happens, outside the node doing the work, and that record is what you resume from.

• Recover what failed. Point `recover` at a prior run. Finished tiles are reused and only what failed or changed runs again, even without caching enabled.
• Fork from any step. `flyte.rerun` starts a prior run again at the step you pick, with a new model version or a different AOI.
• Replay with today's code. `--rerun-from` runs a prior run's inputs against the code on your machine right now.

A land cover map should not be a path in a bucket that one person remembers. Artifacts are typed, versioned values that persist past the run that made them, so a change detection workflow consumes last week's classification without re-running it, and a new scene can fire the next run by itself.

• Passed between workflows and apps. One pipeline's mosaic is another's typed input, without re-running the producer.
• Versioned, not overwritten. A new version is a new artifact, so a downstream run resolves to the exact tiles it used.
• Events, not polling. `flyte.OnArtifact` fires a run whenever new imagery lands, with no cron hacks in between.

Someone is questioning a classification you published two quarters ago. Every run keeps what it takes to reproduce a result: the code that executed, the infrastructure it ran on, and the configuration applied to both. That is what makes a pipeline shareable rather than personal, and it is the same record an audit or a postmortem needs.

• Inputs and outputs per run. Open an execution from months ago and see exactly which scenes went in and which tiles came out.
• The code that ran, not the code today. Each run resolves to its own code bundle and container image, down to the GDAL version.
• Full lineage back to source imagery. Every intermediate and final output traces to the scenes that produced it.