> For the complete documentation index, see [llms.txt](https://docs.valohai.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.valohai.com/changelog/announcements.md).
# Announcements
{% updates format="full" %}
{% update date="2026-04-30" %}
## Data browsing and navigation
Browsing data in Valohai now works the way your files are actually organized. A collapsible directory tree lets you navigate by folder path in execution outputs and dataset version views. Datum directory listings are available across all contexts, and you can search for specific files by ID or URI.
**Use cases**
* Navigate deeply nested output directories without scrolling through a flat file list
* Browse dataset version contents by folder structure to find files in specific subdirectories
* Search for a specific datum by its UUID or datum:// URI when you already have a reference
* Compare two dataset versions side by side in a full-page view with checkbox-based selection
* Browse datum folder structures across all views, not just within a single project
**How it works**
Open any execution's outputs tab or a dataset version's contents view to see the directory tree sidebar. Click folders to expand or collapse them, narrowing the file list to a specific path. The tree is built from the actual file paths in your data, so it reflects your directory structure as-is.
To find a specific file, use the datum search with a UUID or datum:// URI. The search works across the datum browser regardless of which view you're in.
The Compare Dataset Versions view has been rebuilt as a full-page layout with a clearer comparison interface. Select versions using checkboxes, swap the comparison direction with a single click, and see additions, removals, and changes in a readable layout.
**Learn more**
[Browse Data](https://docs.valohai.com/data#browse-data)
{% endupdate %}
{% update date="2026-04-30" %}
## Dataset and dataset version properties
Datasets and dataset versions now support structured key-value properties, the same metadata system that already exists for individual datums. Properties give you a proper way to describe your datasets with structured metadata and replaces the common workaround of using tags for information like data source, machine type, capture date, or preprocessing version.
**Use cases**
* Attach stable metadata to a dataset (e.g., species: pine, machine: XYZ-100, domain: forestry) that applies across all versions
* Record version-specific metadata on each dataset version (e.g., capture\_date: 2026-01-15, sample\_count: 47000, preprocessing\_version: 3.2)
* Set properties through the API, the UI, or automatically during executions via valohai.metadata.jsonl
* Filter and search datasets by property values instead of relying on naming conventions or tags
**How it works**
Open any dataset or dataset version detail page to see its properties. You can add, edit, and remove properties directly in the UI. Each property is a key-value pair where the value can be a string, number, boolean, or nested JSON object.
To set properties programmatically, include them in your execution code via output metadata, or use the properties API endpoints.
Properties on datasets represent stable attributes that don't change between versions. Properties on dataset versions represent version-specific metadata. Both are visible in the dataset list views, detail views and available through the API.
**Learn more**
[Dataset Properties](/data/datasets/dataset-properties.md)
{% endupdate %}
{% update date="2026-04-30" %}
## Query builder for dataset properties
A new visual query builder lets you find datasets by their properties without fully writing queries by hand. Build structured queries with dropdowns, combine conditions with AND/OR logic, and reorder conditions by dragging them into position.
**Use cases**
* Find all datasets matching specific property criteria (e.g., all datasets where machine == "XYZ-100" and preprocessing\_version >= 3.0)
* Build complex queries visually using AND/OR logic without memorizing query syntax
* Export queries as JSON to save, share, or reuse them in API calls or scripts
* Rearrange query conditions by dragging them to try different filter combinations quickly
**How it works**
Open the query builder from the dataset browser. Enter a property key you want to filter by. Choose an operator (equals, not equals, greater than, less than, contains, or exists) and enter a value. Add more conditions and combine them with AND or OR logic.
Drag and drop conditions to reorder them. When your query is ready, the matching datasets update in the results list. You can also copy the query for use in API integrations or to share with teammates.
The query builder currently supports dataset properties. Support for additional property types will be added in future releases.
**Learn more**
[Query Builder](/data/datasets/dataset-properties/query-builder-for-dataset-properties.md)
{% endupdate %}
{% update date="2026-03-11" %}
## Execution Input Source Tracking
The execution detail view now shows where each input came from, organized by source type. Instead of a flat list of file URIs, inputs are grouped by their origin: dataset version, model version, individual datum, metadata query, or direct URL. Each source includes a clickable link to navigate to the original dataset or model.
Separate inputs tab showing inputs grouped by their origin.
**Use cases**
* Trace which dataset version provided the training data for a specific execution
* Verify that a model deployment pulled the correct model version as input
* Understand how a metadata query resolved into specific data files
* Audit the full provenance of an execution's inputs for reproducibility
* Navigate directly to source datasets or models from the execution detail page
**How it works**
Open an execution detail page and scroll to the Inputs or go to the new dedicated Inputs tab. Each input now displays source type badges (Dataset, Model, Datum, Query, or URL) indicating where the files originated. Click the expand arrow on any source to see the full URI or metadata query, the list of resolved files, and a link to the source dataset or model version.
**Learn more**
[Running a basic execution](https://docs.valohai.com/executions/run-basic-execution)
{% endupdate %}
{% update date="2026-02-19" %}
## Output Preview Grid for Compare Executions
Valohai's Compare Executions view now features an image grid tab that lets you visually compare image outputs side by side across executions. With synchronized hover states and filtering capabilities, you can quickly spot differences in generated images across different runs.
**Use cases**
* Compare generated images across different model checkpoints or training runs
* Review visual outputs from hyperparameter sweeps to identify trends
* Quality-check computer vision model outputs across multiple test sets
* Spot differences in generated images from experiment variations
* Validate consistency of image outputs when testing model architecture changes
**How it works**
Navigate to the Compare Executions view and select the new Preview Grid tab. The grid displays image outputs from your selected executions in a synchronized layout, with each column representing one execution. As you hover over an image in one column, the corresponding images in other columns are highlighted, making it easy to compare the same output across different runs.
Use the filter field to narrow down which outputs are displayed in the grid, focusing on specific file name patterns. The grid supports image files that can be previewed directly in the browser.
**Learn more**
[Image Preview Grid](https://docs.valohai.com/experiment-tracking/compare-images#use-preview-grid)
{% endupdate %}
{% update date="2026-02-11" %}
## Execution Selector for Comparing Executions
The Compare Executions view now includes a dedicated execution selector sidebar that makes it easier to choose which executions to compare. With built-in filtering support, you can quickly find and switch between executions in your comparison workflows.
**Use cases**
* Quickly swap out executions in your comparison without returning to the main executions list
* Filter executions by status, date range, or other criteria while building your comparison
* Compare different combinations of experiment runs to identify the best performers
* Build comparison workflows that involve multiple iterations of selection and analysis
* Maintain comparison context while exploring different execution combinations
**How it works**
When you enter the Compare Executions view, the execution selector sidebar appears alongside your comparison workspace. Use the filtering controls to narrow down the list of available executions, then select the ones you want to compare by checking their boxes. You can add or remove executions from your comparison without losing the current view state.
The selector maintains your filter settings as you work, making it easy to iterate through different comparison scenarios within the same workflow.
**Learn more**
[Compare Executions](https://docs.valohai.com/experiment-tracking/compare-executions)
{% endupdate %}
{% update date="2026-02-03" %}
## Grouped Metadata Plot
A new grouped chart view helps you compare distributions across experiment groups at a glance. This visualization combines box plots with a statistics table, supporting grouping by categorical metadata keys to reveal patterns and outliers in your experiment results.
**Use cases**
* Compare model performance distributions across different hyperparameter configurations
* Analyze training metrics grouped by dataset version or data split
* Identify outliers and variance patterns when testing multiple model architectures
* Visualize resource utilization statistics grouped by instance type or execution environment
* Generate statistical summaries for A/B testing or multi-variant experiments
**How it works**
The grouped metadata plot automatically generates box plots for your numeric metadata, with each box representing the distribution of values within a group defined by categorical metadata keys. The accompanying statistics table shows key metrics like median, quartiles, and outliers for each group.
You can filter the visualization by metadata values and choose to group by either metadata keys or specific metadata values, bringing pivot-table-like interactivity to your experiment analysis. Access the grouped plot from any execution or datum browser view where metadata is available.
**Learn more**
[Grouped Metadata Plot](https://docs.valohai.com/experiment-tracking/visualize-metrics/grouped-metadata-plot)
{% endupdate %}
{% update date="2026-01-14" %}
## Transient Environment Variables
Valohai now supports transient environment variables that can be injected into job payloads without persisting them in your project configuration. This enables you to pass short-lived, secret-capable variables through the API while maintaining security best practices and keeping sensitive data out of your version-controlled configuration.
**Use cases**
* Inject API keys or access tokens for external services that rotate frequently without updating project settings
* Pass experiment-specific credentials that should not be shared across all executions
* Manage temporary authentication tokens for CI/CD pipelines that trigger Valohai jobs
* Provide user-specific or session-specific variables when programmatically creating executions
* Handle sensitive configuration that shouldn't be stored in project YAML or visible in the UI
**How it works**
You can define transient environment variables via the Valohai API when creating executions or through the new editor in user and organization settings. These variables are injected directly into the job payload at runtime and are not persisted in your project configuration. They work alongside regular environment variables but are only available for the specific execution context where they're provided.
To use transient variables via the API, include them in your execution creation payload. To manage them through the UI, navigate to your user or organization settings where you'll find the new transient environment variables editor.
**Learn more**
[Transient Environment Variables](https://docs.valohai.com/executions/custom-environment-variables#transient-environment-variables)
{% endupdate %}
{% update date="2025-12-11" %}
## Interactive Terminal: Debug Your Running Executions in Real-Time
Valohai now supports running terminal commands while an execution is running, giving you direct access to your execution environment without interrupting your workflow. When something goes wrong during a long-running training job, you can jump into the running execution to inspect processes, check GPU utilization, examine file outputs, or validate your Docker environment in real-time. No need to wait for failures, restart from scratch, or guess what went wrong from logs alone.
**Use cases**
* Debug data loading issues before they derail your entire training run
* Monitor GPU utilization and memory usage in real-time
* Verify Docker configurations and dependencies are correctly installed
* Test commands and file paths before incorporating them into your execution steps
* Inspect model checkpoints as they're being saved during training
**How it works**
Set the `VH_INTERACTIVE` environment variable to `true` or `1` in your execution. This adds an input field to the terminal in the Log tab, where you can send commands directly to your running execution. Your code needs to be set up to handle incoming commands.
**Learn more**
[Interactive Terminal documentation](https://docs.valohai.com/executions/development-and-debugging/interactive-terminal)
{% endupdate %}
{% update date="2025-12-11" %}
## Embed Rich Content Directly in Your Executions
Valohai executions now support embedding external content directly in the execution view. While you could always link to dashboards and visualizations from tools like Weights & Biases, you can now embed them inline. This means that your team can see training curves, monitoring dashboards, and experiment results without leaving Valohai or opening multiple tabs. This keeps your ML experiment context consolidated in one place, improving reproducibility and making it easier for your team to understand what was tried and what the results were.
**Use cases**
* Embed for example Weights & Biases dashboards showing training curves and model performance metrics
* Display TensorBoard visualizations directly in your execution view
* Include production monitoring dashboards for deployed models
* Show experiment tracking tools like MLflow or Neptune alongside execution logs
* Add custom visualization dashboards built with Plotly, Streamlit, or similar tools
**How it works**
Add a Service Button to your execution by printing a command to stderr (not stdout):
```python
print('::show-service-button::{"url":"https://dashboard.example.com/","name":"Dashboard","style":"embed"}', file=sys.stderr)
```
**Learn more**
[Service Buttons documentation](https://docs.valohai.com/executions/advanced-features/service-buttons)
{% endupdate %}
{% update date="2025-11-25" %}
## Compare Model Predictions Side-by-Side with Image Comparison
Valohai now includes image comparison capabilities that let you visually compare model predictions across different executions. Whether you're evaluating object detection bounding boxes or segmentation masks, you can overlay predictions from different model versions, adjust colors and opacity, and quickly identify performance improvements or regressions. Save metadata with your images to automatically group related outputs across executions, or manually stack specific images for detailed comparison. All directly in Valohai without downloading files or switching tools.
**Use cases**
* Compare object detection performance between model versions to identify reduced false positives
* Evaluate segmentation quality improvements across training iterations
* Review predictions on validation sets to spot edge cases or failure modes
* Compare multiple model architectures on the same test images
* Navigate through large prediction sets efficiently using grouped comparisons
**How it works**
Save metadata with your output images to define groups for automatic organization. Select the executions you want to compare in the Executions view and click the Compare button. You can then overlay images, adjust visualization settings, and navigate through grouped predictions to evaluate model performance.
**Learn more**
[Image Comparison documentation](https://docs.valohai.com/experiment-tracking/compare-images)
{% endupdate %}
{% endupdates %}
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.valohai.com/changelog/announcements.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
