March 2026

🔧 Extended Idle Timeout for Panel Apps

Panel apps now support longer idle times for WebSocket connections, and session tokens now expire after 3 hours.

New parameters for managing the lifetime of unused sessions improve the stability of long-running applications.

🔧 Plugin Variants Documentation

The new --plugin-variants flag in flyte gen docs generates variant-scoped CLI documentation.

Plugin-contributed CLI commands are wrapped in Hugo {{< variant >}} shortcodes. Core commands appear unconditionally, while plugin commands appear only in the variants you specify (for example, flyte or union).

🚀 Google Gemini Plugin Integration

You can now integrate Google’s Gemini API with Flyte. The new function_tool decorator converts Flyte tasks into Gemini agent tools, and supports both synchronous and asynchronous operations.

import flyte
from flyteplugins.gemini import function_tool, run_agent

env = flyte.TaskEnvironment("gemini-agent")

@env.task
async def get_weather(city: str) -> str:
    return f"The weather in {city} is sunny."

# Run Gemini agent with a tool
async def agent_task(prompt: str):
    tools = [function_tool(get_weather)]
    return await run_agent(prompt=prompt, tools=tools, model="gemini-2.5-flash")

🔨 Forced Image Build Caching

You can now force an image rebuild by setting force=True. This skips the existence check and rebuilds the image even if it already exists.

With the remote image builder, force=True also sets overwrite_cache=True.

import flyte

image = flyte.Image("your_image")
result = await flyte.build.aio(image, force=True)

💻 LLM-Powered Code Generation

The new flyteplugins-codegen plugin uses LLMs to generate code from natural language prompts, run tests, and iterate in isolated sandboxes.

from flyteplugins.codegen import AutoCoderAgent

agent = AutoCoderAgent(model="gpt-4.1", name="data-processor", resources=flyte.Resources(cpu=1, memory="1Gi"))

result = await agent.generate.aio(
    prompt="Process the CSV data to calculate total revenue and units.",
    samples={"sales": csv_file},
    outputs={"total_revenue": float, "total_units": int},
)

🔧 Updated AI Plugin Examples

The plugin examples for OpenAI and Anthropic in Flyte 2.0 are fixed and improved. They now use updated versions of flyteplugins-openai and flyteplugins-anthropic.

from flyteplugins.openai.agents import function_tool

agent_env = flyte.TaskEnvironment(
    "openai-agent",
    resources=flyte.Resources(cpu=1),
    secrets=[flyte.Secret(key="openai_api_key", as_env_var="OPENAI_API_KEY")],
)

@function_tool
@agent_env.task
async def get_bread() -> str:
    await asyncio.sleep(1)
    return "bread"

🔧 Debug Mode Integration

You can now start tasks in VS Code debug mode from the CLI with the --debug flag, or from Python.

In Python, set debug=True in flyte.with_runcontext to attach a VS Code debugger during task execution.

import flyte

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

@env.task
def say_hello(name: str) -> str:
    greeting = f"Hello, {name}!"
    print(greeting)
    return greeting

if __name__ == "__main__":
    flyte.init_from_config()
    run = flyte.with_runcontext(debug=True).run(say_hello, name="World")
    print(run.name)
    print("Run url", run.url)
    print("Waiting for debug url...")
    print("Debug url", run.get_debug_url())

✨ Improved CLI Enum Support

The Flyte CLI now supports EnumParamType, so you can pass enum names directly (for example, --color=GREEN) instead of internal values.

📝 Programmatic Log Access

You can now access logs programmatically with the get_logs() method on remote.Run and remote.Action.

It returns an iterator over log lines. You can process logs asynchronously with .aio(), filter out system-generated logs, and include timestamps.

⚡ Simplified PyTorch Example Setup

PyTorch environment setup is simpler: specify flyteplugins-pytorch directly in with_pip_packages instead of using the internal PythonWheels API.

📈 Distributed Training Evaluation

Flyte now supports distributed training with callback-driven evaluation.

EvalOnCheckpointCallback triggers an evaluation task after each training checkpoint. Evaluations run in parallel with training and monitor convergence. When training converges, a stop signal halts it gracefully.

⚡ Improved Benchmark Flexibility

The benchmark script for large I/O operations is refactored:

• CPU and memory allocations are now parameterizable.
• File and directory tests can run independently.
• HTML report generation handles missing data gracefully.

💻 CLI Project Management

You can now create, update, and manage Flyte projects from the CLI, including their IDs, names, descriptions, labels, and archive status.

# Example usage
flyte create project --id my_project_id --name "My Project" --description "Project description" -l team=dev -l env=prod
flyte update project my_project_id --archive
flyte get project --archived

🤖 Anthropic Claude Integration

You can now use Flyte tasks as tools for Anthropic Claude agents. Define tasks in Flyte and convert them into Claude tool definitions with the function_tool utility.

⏳ Panel App Enhancements

The Flyte SDK panel app now uses a threaded asynchronous execution model, so actions like code execution no longer block the interface.

A Reo.Dev tracking integration adds monitoring.

⚙️ AWS Config File Support

Flyte now supports S3 authentication through the AWS_CONFIG_FILE environment variable.

When you set both AWS_PROFILE and AWS_CONFIG_FILE, Flyte uses a boto3-backed credential provider for profile-based authentication.

✨ Improved Task Execution Reliability

Flyte now uses task.aio() for both synchronous and asynchronous tasks, so all tasks run consistently through the Flyte controller.

The previous fallback to asyncio.to_thread() for synchronous tasks is removed.

🔧 Enhanced Action Service Integration

You can now attach custom gRPC headers to requests to the Actions service. This gives you consistent request metadata for routing and integration in distributed environments.

🚀 Async Training with Early Stopping

A new ML pattern example runs asynchronous training with periodic evaluations, using Flyte’s durable task management.

The training task saves checkpoints asynchronously while evaluation tasks assess convergence. Training stops gracefully when convergence is detected.

async def train(checkpoint_dir: str, total_epochs: int, seconds_per_epoch: float) -> File:
    # Training logic
    pass

async def evaluate(checkpoint_file: File, eval_round: int, convergence_loss: float) -> bool:
    # Evaluation logic
    pass

async def main(total_epochs, seconds_per_epoch, convergence_loss, eval_interval_seconds, max_eval_rounds):
    # Orchestration logic
    pass

Run flyte run examples/ml/async_train_eval.py to execute this pattern locally.

🔧 Improved Include Path Handling

Flyte now resolves include paths relative to the app directory during deployment.

Previously, include paths that escaped the app script’s directory caused deployment to fail with invalid tar entries.

⚡ Enhanced Retry Management

Task retries in local runs now support exponential backoff and track each retry attempt, so you can recover from transient errors.

Retries are also more visible, in both the controller logic and the terminal UI.

⚡ Improved Module Loading

Module loading in the Flyte SDK now respects .gitignore and standard ignore rules, and excludes directories like .venv and __pycache__.

⚡ Dynamic Batching for Improved GPU Utilization

The new DynamicBatcher and TokenBatcher classes let concurrent tasks share a single GPU, which improves throughput for use cases like large-scale inference.

An example shows TokenBatcher in inference tasks with reusable containers.

✨ Run Cache Disabling

You can now disable task result caching for a run. When caching is disabled for a run, cache operations are bypassed and no cache hits are reported.

The TUI shows clearly that caching is disabled.

💻 Vim Key Navigation for TUI

The TUI (FlyteTUIApp and ExploreTUIApp) now supports the Vim keys j and k for cursor movement in ActionTreeWidget and RunsTable.

✨ Clickable Image Build URLs

Image URIs in TaskMetadata are now clickable in the Union frontend and link directly to the Flyte run that built the image.

✨ Enhanced Run Filters

You can now filter runs and actions by project, domain, and creation or update time range, in both the SDK and the CLI.

The new TimeFilter class filters on the created_at and updated_at timestamps.

from flyte.remote import TimeFilter

# Example usage to fetch runs created after a specific date
runs = Run.listall(
    project="my-project",
    created_at=TimeFilter(after="2026-03-01")
)

🔧 Simplified Dependency Management

In dependencies_only mode, UVProject now copies only the pyproject.toml file of each editable dependency instead of the entire directory. This reduces the build context size and speeds up image builds.

🤖 MLE Agent Enhancements

Two new agents, the MLE Orchestrator Agent and the MLE Tool Builder Agent, use LLMs to generate orchestration and processing code.

They create, execute, and iteratively optimize ML models in an isolated sandbox with configurable compute resources.

✨ Improved Task Command Initialization

The Flyte CLI now initializes configuration when it lists or resolves task commands through TaskPerFileGroup, so config-dependent operations no longer fail.

import flyte
from flyte.io import File

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

@env.task
async def test_file(project: str, input_file: File) -> str:
    return f"Got input {project=}, {input_file=}"

⚡ New Example Applications & Bug Fixes

New example applications:

• Distributed training with async tasks.
• MNIST model handling with PyTorch.
• Agent workflows with LangGraph and the Gemini API.

This release also fixes a bug in scaling metric serialization.

⚙️ Phase Transitions Tracking

You can now see phase transition details for actions, including the time spent in each phase (QUEUED, INITIALIZING, RUNNING, and so on).

To find bottlenecks programmatically, use the get_phase_transitions method and properties like queued_time and running_time.

action = Action.get(run_name="my-run", name="my-action")
details = action.details()
transitions = details.get_phase_transitions()
for t in transitions:
    print(f"{t.phase}: {t.duration.total_seconds()}s")

🔧 Multiple Source Files Support

with_source_file now accepts a list of file paths, so you can add multiple files in a single image layer.

If duplicate filenames target the same location, it raises an error.

from flyte._image import Image
from pathlib import Path

# Example usage with two different files
img = Image.from_debian_base(name="my-image").with_source_file([Path("a.py"), Path("b.py")])

📦 Simplified Code Bundling

The new with_code_bundle() method packages source code into Docker images. Set copy_style in with_runcontext() or during flyte deploy:

• "none" bakes the source code into the image automatically.
• "loaded_modules" includes specific Python modules.
• "all" includes entire directories.

🔧 Improved Error Messaging for Deployment

With a src/ layout, the “Duplicate environment name” error during deployment now suggests the --root-dir option to resolve dual-import issues.

# New deployment configuration example
flyte deploy --dry-run --recursive --root-dir src src/my_module

🔧 Improved Debugging for Reusable Tasks

Reusable tasks now disable debugging automatically.

Previously, debugging was enabled by default, which could cause issues with reusable tasks.

✨ JSONL Plugin Support

The new JSONL plugin adds the JsonlFile and JsonlDir types for Flyte workflows.

It supports async and sync reads and writes with optional zstd compression, and uses orjson for fast serialization.

from flyteplugins.jsonl import JsonlFile, JsonlDir

# Example usage of JsonlFile
@env.task
async def process_file(f: JsonlFile):
    async for record in f.iter_records():
        print(record)

# Example usage of JsonlDir for sharded directories
@env.task
async def process_dir(d: JsonlDir):
    async for record in d.iter_records():
        print(record)