Build agents that actually ship.

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

An agent picks its own tools at runtime, so you cannot size the box for a plan you have not seen yet. One branch reads a short page, the next loads a model or parses a document that will not fit. Union hands you a typed error instead of a stack trace, so the step that blows memory comes back as an exception you can catch and re-run on a bigger box. And because provisioning is just a call, the agent can be the one making it.

• Typed infrastructure errors. `OOMError`, `TaskInterruptedError`, `TaskTimeoutError`,` ImagePullBackOffError`. Failures you can branch on.
• Resources changed at runtime. `.override(resources=...)` re-runs the same tool call with different memory, CPU, or accelerator.
• Every tool in its own container. Call OpenAI, Anthropic, or Gemini, or serve your own models with vLLM or SGLang, each with its own image, secrets, and hardware.
• 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.

Agentic workflows run for hours and make hundreds of LLM calls. One bad API response an hour deep should not cost you the whole run, and it should not cost you the tokens either. Union records what finished as the run happens, outside the node doing the work, so a bad step in an agent run is where the next run starts.

• Recover what failed. Point `recover` at a prior run. Completed tool calls 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 prompt, a different model, or a corrected tool.
• Pause without burning compute. Human-in-the-loop gates wait indefinitely for approval, then continue from exactly where they stopped.

An agent's output should not be a string that vanishes when the process exits. Artifacts are typed, versioned values that persist past the run that made them, so a synthesis becomes the typed input to the next workflow, or to the app serving it, without re-running the agents that produced it.

• Passed between workflows and apps. One pipeline's research output 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 output it acted on.
• Events, not polling. `flyte.OnArtifact` fires a run whenever a new version lands, with no cron hacks in between.

A non-deterministic system is only debuggable if you can see what it actually did. 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. For agent workloads that same record doubles as the trace of every step the agent chose for itself.

• Observability for agents. Every step a non-deterministic workflow took is on the record, including the ones it chose itself.
• Inputs and outputs per run. Open an execution from months ago and see every prompt that went in and every response that came back.
• The code that ran, not the code today. Each run resolves to its own code bundle and container image, down to the model and prompt version.

Parallel research agents, debate loops, and manager-worker hierarchies are all native Python async. `asyncio.gather` when you want the whole panel at once, `flyte.map.aio` when you want bounded concurrency over a long list, each agent in its own isolated container.

• Concurrency you can cap. `flyte.map.aio(fn, items, 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 rate-limited LLM API gets time to come back.
• Planner, ReAct, debate, manager-worker. The coordination is ordinary async composition, so the pattern is yours to write rather than a framework to fight.