February 2026

✨ JSON Schema Enhancement

Flyte now converts Python types to JSON Schemas using its internal type system. Previously, some types, such as Literal["C", "F"], were mapped incorrectly.

Input schemas for Flyte tasks now reflect precise JSON Schemas, which improves integrations with tools like Anthropic’s Claude.

# Example: Converting Literal to JSON Schema correctly
def my_func(unit: Literal["C", "F"]) -> str:
    return unit

schema = NativeInterface.from_callable(my_func).json_schema
assert schema["properties"]["unit"] == {"type": "string", "enum": ["C", "F"]}

🧮 Panel Calculator Example

A new example shows a calculator app embedded in a Panel interface using Flyte’s AppEnvironment. Use it as a model for building interactive web UIs with Flyte.

✨ Spark Plugin Update

The flyteplugins-spark dependency is now >=2.0.0, replacing the pre-release versions.

🔒 Secure Package Specification

Package version constraints like apache-airflow<=3.0.0 are now automatically quoted in generated Dockerfiles. Previously, unquoted constraints could cause incorrect shell interpretation and build failures.

⚡ Enum Name Acceptance in CLI

The Flyte CLI now accepts both enum names and enum values as inputs. Previously, it accepted only values, so --color=RED failed when the value was "red".

import enum
import flyte

class Color(enum.Enum):
    RED = "red"
    GREEN = "green"
    BLUE = "blue"

@flyte.task
def example_task(color: Color):
    return f"Selected color is {color.name}"

🔧 Enhanced Pod Template Handling

Pod templates now persist across task overrides. Previously, overriding certain task attributes could discard custom pod templates.

Pod specifications, labels, and annotations now persist when you rename a task or modify other properties.

⚡ Stress Testing Example Added

A new stress testing example demonstrates a fan-out execution pattern. It creates a dynamic tree of asynchronous tasks to simulate high concurrency.

You control the number of tasks spawned at each layer, and you can add variability with a jitter parameter.

🐛 Correct Serialization Field

Scaling metrics now serialize to the correct field, target_value, instead of val. Scaling.Concurrency and Scaling.RequestRate metrics now serialize as the protobuf definitions expect.

🔧 Improved Async Task Handling

Async Flyte tasks now route execution through task.aio(). This gives consistent invocation through Flyte’s controller and correct handling of nested async tasks.

🔧 Sync Alignment of File Upload Methods

File.from_local_sync and File.from_local now handle filenames consistently when uploading to remote storage. Previously, the sync and async methods could produce different filenames for the same upload.

# Example of uploading a file with consistent naming:
import flyte

with tempfile.TemporaryDirectory() as temp_dir:
    local_path = os.path.join(temp_dir, "source.txt")
    remote_path = os.path.join(temp_dir, "destination.txt")

    # Ensure the file content
    with open(local_path, "w") as f:
        f.write("sample content")

    # Upload the local file to a remote location
    uploaded_file = File.from_local_sync(local_path, remote_path)

    print(f"Uploaded file path: {uploaded_file.path}")

⌛ Request Timeout Configuration

You can now configure request timeouts for Flyte apps with the new Timeouts dataclass. Set a request timeout, as an integer or a timedelta, to limit how long a request can take within an app environment.

🔧 Enhanced Bundling and Error Handling

Two changes make code bundling leaner and clearer:

• .git directories are now excluded from deployment code bundles, which reduces artifact size and speeds up deployment.
• The copy_style parameter now has explicit error handling that tells you when bundling is unnecessary.

🔧 Dynamic Pydantic Model Creation

The new PydanticTransformer.guess_python_type method creates Pydantic models dynamically from JSON Schema metadata. Use it when the original Pydantic model class isn’t available, to deserialize complex nested structures.

👥 Human-in-the-Loop Plugin

The new Human-in-the-Loop (HITL) plugin lets a workflow pause and wait for human input, either through a web interface or programmatically. You create events that prompt for input through an automatically served FastAPI app.

import flyteplugins.hitl as hitl

# Create event and wait for human input
event = await hitl.new_event.aio(
    "input_event",
    data_type=int,
    scope="run",
    prompt="Enter a number"
)
value = await event.wait.aio()

🚀 Stateless Code Sandbox

You can now run arbitrary Python code and shell commands in an isolated, stateless Docker container with the flyte.sandbox.create() API.

Three execution modes are available: Auto-IO, Verbatim, and Command. Each handles inputs and outputs differently, and all run code in fresh, ephemeral containers.

🔧 Improved CLI Logging Initialization

The Flyte SDK now sets up logging consistently when you use the CLI. Previously, CLI commands initialized configuration multiple times, which duplicated log entries. Now:

• Initialization occurs once per command execution.
• RichHandler is enabled from the start, so all logs display in rich format.
• The hello.py example script now has a default value, so it runs without arguments.

@env.task
def main(x_list: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) -> float:
    x_len = len(x_list)
    if x_len < 10:
        raise ValueError(f"x_list doesn't have a larger enough sample size, found: {x_len}")
    y_list = list(flyte.map(fn, x_list))
    y_mean = sum(y_list) / len(y_list)
    return y_mean

🔧 Enhanced Ignore Handling

The Flyte SDK now skips .gitignore and .flyteignore files inside commonly ignored directories, such as .venv and __pycache__, to avoid redundant file processing.

🐳 CI Image Builder

A new example script builds and pushes Docker images from CI. Configure it with your source and target image details to use it in continuous deployment pipelines.

🔧 TypedDict Compatibility Fix

The Flyte SDK now correctly handles TypedDict for Python versions earlier than 3.12 by using typing_extensions.TypedDict.

# Importing TypedDict based on Python version
import sys
if sys.version_info >= (3, 12):
    from typing import TypedDict
else:
    from typing_extensions import TypedDict

🌐 Cross-Platform Code Bundling

The Flyte SDK now uses POSIX-style paths for file hashing and tarball creation, so code bundling behaves the same on Windows and Unix systems.

🔧 Improved CLI JSON Formatting

The flyte CLI now uses an object’s to_dict() method, when available, for JSON output. This fixes TypeError failures with certain non-iterable object types.

🔧 Improved Pod Image Handling

Flyte now merges container images consistently when you use a pod template. If no explicit image is set, the primary container uses app_env.image, and both "auto" and specific image values are handled correctly.

✨ Flyte Webhook Environment

A pre-built Flyte webhook environment provides FastAPI endpoints for common Flyte operations, such as running tasks, managing apps, and handling triggers.

The environment uses httpx for HTTP requests and exports more endpoints, so you can customize it further.

🔁 Retry Interceptor for gRPC

A new retry interceptor for gRPC channels retries gRPC calls that fail with transient errors. Set the number of retry attempts with the rpc_retries option when you create the channel.

✨ Orchestration Sandbox Feature

Flyte 2.0 now supports dynamic orchestration within a sandbox with flyte.sandbox.orchestrator_from_str(). It creates reusable orchestration templates directly from Python code strings, without decorated functions.

This is useful when code is generated dynamically, for example by a UI or a language model.

🔧 Task Shortname Override Fix

Setting the short_name parameter in task overrides now changes the task’s short name in the UI. Previously, overridden short names did not appear in the Flyte UI.

✨ NVIDIA H100 GPU Support

Flyte now supports NVIDIA H100 GPUs with various MIG partitions for fine-grained resource allocation.

from flyte import GPU, Resources

h100_mig_env = flyte.TaskEnvironment(
    name="h100_mig",
    resources=Resources(
        cpu="1",
        memory="4Gi",
        gpu=GPU(device="H100", quantity=1, partition="1g.10gb"),
    ),
)

⚡ Enhanced Error Handling in PyTorch Elastic Jobs

Flyte’s PyTorch integration now has configurable NCCL timeout settings for handling CUDA out-of-memory (OOM) errors. Faster failure detection and customizable restart policies keep elastic jobs from hanging on OOM.

You can:

• Reduce timeout durations.
• Enable asynchronous error handling.
• Turn on built-in monitoring.

🔧 Reverse Path Priority Fix

When you run tasks remotely, the Flyte SDK’s handling of sys.path now respects local path priority. Previously, the entrypoint directory could override top-level packages. Path priority is now consistent between local development and remote execution.

🌐 S3 Virtual Hosted-Style Support

You can now set the addressing style for S3-compatible backends. Set the FLYTE_AWS_S3_ADDRESSING_STYLE environment variable to virtual to build URLs in the format https://<bucket>.<endpoint>/<key>, which more storage providers support.