June 2026

🐛 Interactive Debugging

flyte debug opens an interactive session against a task over a WebSocket tunnel, so it works without direct network access to the cluster.

• You can attach SSH or VS Code to a running task’s container.
• debug.relaunch on flyte.rerun relaunches a failed action straight into a debug session with the same inputs.

See Debug runs.

🚀 Distributed Multi-Node Tasks

ClusteredTaskEnvironment runs a single task across a coordinated group of pods for multi-node training and other tightly coupled distributed work.

A failed member exits non-zero and the error is recorded once the whole set is terminal, so a partial failure reports as one failure. GPU configuration flows through to every member.

See Clustered task environment.

💾 Persistent Volumes

A new Volume type gives tasks a durable, mountable filesystem.

• Lineage. The platform records which runs wrote to a volume, so you can trace data back to the work that produced it.
• Explorer. A three-pane terminal explorer browses volume contents and lineage.
• FUSE. Clusters advertise FUSE as a requestable device, so a task opts in with allow_fuse() instead of running as a privileged container.

See Volumes.

🚥 Run-Level Action Concurrency and Queue Binding

Set max_action_concurrency on a run (flyte run --max-action-concurrency 5 ...) or as a default per org, domain, or project to bound how many of a run’s actions execute at once. Excess actions wait and start as running actions complete.

Leaving it unset, or setting 0, means unlimited. 1 is rejected because a parent awaiting its children would deadlock.

Every queue now binds to a cluster pool, and queue creation, editing, and per-run queue selection are available from the CLI and the Console.

See the Queues documentation.

🏷️ Labels on Runs

Set labels when you create a run, from the SDK, the CLI, or the launch form.

• You can filter runs by label in the API (labels.<key> filters) and the Console runs list, including grouped views.
• Labels render in every run listing with stable per-value colors.

🔧 Settings in the Console

A Settings surface in the Console edits org, domain, and project settings with inheritance, and shows where each effective value comes from.

New settings include a default queue, run_base_dir, and run-level max action concurrency. Max-GPU settings now apply only when a task requests GPUs.

🔔 Notifications and Conditions in the Console

A Notifications tab on the launch form configures notifications, with email as the default channel.

For conditions, you can now:

• Resolve a condition from the run details page.
• Abort an action from the condition UI.
• See who aborted an action or resolved a condition, including the value they supplied.

Condition timeouts surface as a user error that explains the timeout.

🤖 Agent Updates

• Agents gain code_mode, which runs tool calls as generated code in a sandbox, with a call_handler hook on @tool.
• MemoryStore is decoupled from Agent.
• Agent tools accept File, Dir, and DataFrame.
• Human-in-the-loop approval runs on native conditions.

📦 Usage-Based Image Retention on AWS

On AWS, images built by ImageBuilder are no longer deleted 30 days after they were built. They move to archive after 60 days without a pull and are deleted 90 days after that, so actively used images are never removed.

Archived images can be restored on request within that window. GCP and Azure registries keep 30-day age-based cleanup.

🔧 Reliability Improvements

• Pod templates. Task resources, Ray head and worker resources, and app resources are merged into your pod template’s primary container instead of replacing it.
• Stuck phases. Action phases no longer get stuck on “Initializing” after a lost status update.
• Uploads. Large uploads auto-size their multipart chunks.
• Ray GPUs. Ray tasks requesting GPUs through a pod template land on the intended GPU pools.
• Apps. Apps in a project assigned to a non-default cluster pool deploy to the right cluster.
• Log links. Cloud log links resolve to the right log group, region, and project.

🚀 Retries with Backoff and Timeout Controls

Tasks now accept a flyte.RetryStrategy with exponential backoff and a flyte.Timeout with three independent bounds:

• max_runtime: per-attempt running time.
• max_queued_time: per-attempt time waiting for capacity.
• deadline: an absolute wall-clock budget across all attempts.

The max_runtime budget starts when your code begins running. Pod scheduling and image pulls no longer count against it.

import flyte
from datetime import timedelta

env = flyte.TaskEnvironment(name="resilient")

@env.task(
    retries=flyte.RetryStrategy(
        count=4,
        backoff=flyte.Backoff(base=timedelta(seconds=1), factor=2.0, cap=timedelta(seconds=3)),
    ),
    timeout=flyte.Timeout(
        max_runtime=timedelta(minutes=10),
        max_queued_time=timedelta(minutes=5),
        deadline=timedelta(minutes=30),
    ),
)
async def bounded_work() -> str: ...

See the Retries and timeouts documentation.

🤖 Flyte-Native Agent Construct

You can now author agents as a first-class construct:

• Define an agent with registered tools.
• Persist memory across runs with MemoryStore.
• Serve it behind a chat interface using the pre-built app environment.
• Mark sensitive tools with @tool(requires_approval=True) to pause the run until a human approves.

agent.run(...) works synchronously, and await agent.run.aio(...) works in async code.

📝 Multi-Pod Log Streaming

Log streaming now covers every pod of a distributed action (Ray, Spark, multi-node training), for both live tail and persisted logs.

A pod filter in the Console log viewer selects which pod you’re reading, and task metrics can be filtered by pod for multi-pod executions.

💻 Build and Deploy MCP Servers

You can now author a Model Context Protocol server with the SDK and deploy it as a Union app, so agents and IDEs can call your tasks and data as tools.

See the MCP server documentation.

✨ Smarter Failure Classification

A task that raises flyte.errors.NonRecoverableError now fails on the first attempt without consuming its retry budget.

Image pulls rejected by registry rate limits are classified as system errors rather than user failures, so they no longer burn your retries.

⚡ Faster CLI Startup and Unified Local Caches

Heavy imports have been moved off the CLI’s direct path for faster startup. Image and bundle caches are consolidated into a single local database, and the local cache is scoped by init config so different configurations no longer collide.

✨ Friendlier Build and Deploy Errors

Missing image source folders, unknown image references at deploy time, and user-module import failures now surface as specific, actionable error types instead of raw tracebacks. Dependency-export failures include the underlying tool output.

⚡ More Resilient Uploads

Uploads now honor server Retry-After hints on 429 and 503 responses, use a higher retry backoff cap, and report clearer errors when retries are exhausted.

🔧 SDK Reliability Improvements

• DNS. DNS resolution now uses the operating system’s resolver, fixing connectivity in VPN and split-DNS environments.
• Defaults. Pydantic and dataclass default values are resolved correctly at serialization time.
• Refresh tokens. CLI clients request refresh tokens by default, so you log in less often.

🔧 Exclude Files from Code Bundles with .flyteignore

You can now exclude files from code bundles even when they are tracked in git, such as large datasets, notebooks, and docs. .flyteignore files use gitignore-style patterns and are applied automatically during every bundle build.

🔧 Settings Applied at Run Creation

Org- and domain-scoped settings are now fully applied when runs are created: tasks submitted without explicit resource values pick up the defaults configured in Settings.

See the Settings documentation.

✨ Console Run Exploration Improvements

• The runs list supports unconstrained lookback past the previous 7-day window.
• Run labels render in Run Info.
• Trace action durations are accurate in the run sidebar.
• The log viewer’s full-screen mode matches the reports experience.
• Inputs and outputs past their retention window show a clear retention notice.
• The versions table scrolls infinitely, with graceful handling of invalid versions.
• Browser tab titles include the entity name.
• Secrets are cluster-pool aware.

✨ Task Environment Details Drawer

From a run’s details page in the Console, you can now inspect the environment behind the run: name, version, image, resources, and the full reuse policy.

⚙️ Cluster and Cluster Pool Management from the CLI

You can now register and manage clusters and cluster pools directly from the CLI.

• flyte create|get|delete cluster registers clusters into your org, with a detail view covering identity, health, cloud and storage, config drift, capacity, and bound queues.
• flyte create|get|delete cluster-pool manages the shared object-store, secret-store, and image-registry configuration for a group of clusters.

📈 GPU Configuration for Ray Clusters

Accelerator and shared-memory settings now propagate automatically from your resource requests to Ray head and worker groups.

✨ Pydantic Union Types with Field Annotations

Pydantic Union types with Field annotations are now supported in task signatures.

✨ Queues with Concurrency and Depth Control (Beta)

Queues now support concurrency control (how many actions a queue runs at once) and depth control (how deep the queue can grow), with runnable SDK examples.

Queues are in Beta: in this release, the execution engine does not yet enforce queue definitions.

See the Queues documentation.

✨ Events API (Beta)

A new top-level SDK construct lets you emit events from your tasks, with a runnable example. Signalling events from the Console is not available in this release.

⚙️ Self-Managed Data Plane Updates

Update to the latest Union Helm chart to pick up:

• Accurate max_runtime anchoring and per-attempt max_queued_time enforcement.
• Immediate failure on NonRecoverableError.
• Multi-pod log streaming.
• VS Code debugger links routed through the data plane ingress.
• App connector endpoint fixes with project and domain propagation.
• Billing metering on the data plane operator in low-privilege mode.
• Configurable Azure OAuth app secret expiry.

Later in June, the chart also adds:

• Coordinated task groups for ClusteredTaskEnvironment.
• Unprivileged FUSE mounts for Volumes and allow_fuse().
• Task memory metrics reported from cgroup usage instead of working set.
• Retried action status updates.
• An app startup-failure classifier.
• Heartbeat reliability fixes.

Secret-bearing payloads are no longer written to operator logs.

New self-managed topologies include:

• A separate control plane and data plane multi-cluster setup on GCP.
• OpenShift kubeconfig support for operator access through browser-based login.
• Helm v4 compatibility.

⚠️ Breaking Changes

• A cluster now belongs to exactly one cluster pool. Clusters that were assigned to multiple pools were migrated so each sits in a single pool. Confirm each cluster is in the intended pool, and create an explicit pool first if you need a queue to target something other than the default.