Convert Suite to Folder

We added the ability to convert a test suite into a folder. This helps when the initial suite structure needs to be reorganized as test coverage grows.

Previously, restructuring required creating new folders and suites manually, then moving tests between them, which made test organization slower and more complex, especially when the structure was not fully defined in advance.

With this update, converting a suite creates a folder with the same name and places the original suite inside it. You can then continue organizing tests within this folder by adding additional suites and building the required structure.

This simplifies test structure refactoring, reduces manual effort when reorganizing tests, and allows teams to evolve their test hierarchy more efficiently as the project grows.

Expanded Suite Bulk Edit with Descriptions

We expanded the suite bulk edit functionality to support editing not only test titles, but also test descriptions directly within a single screen.

This allows working with multiple tests in a more structured way, including writing and updating descriptions alongside titles. It also enables creating tests within a suite as part of a larger, continuous flow—similar to drafting a single user story and breaking it down into multiple test cases.

For the best experience, this workflow is aligned with the Testomat markdown format for test definitions.

This improvement makes bulk test creation and editing more efficient, improves consistency between titles and descriptions, and supports a more natural workflow when defining tests based on requirements or user stories.

UI Improvements for Tests and Runs Pages

We updated the user interface of the Tests and Runs pages with new styles to improve clarity, consistency, and usability across test management workflows.

The refreshed design enhances visual structure, making it easier to navigate test hierarchies, distinguish between suites and test cases, and review run results. Key information such as statuses, tags, environments, and execution details is now more clearly presented.

The updated UI improves visibility of test data and run results, simplifies navigation across complex test structures, and provides a more consistent and readable interface for managing tests and analyzing execution outcomes.

🛠️ Fixes and Improvements

Improvements

• Improved Zephyr import, preserving Test Type data as labels
• Added filtering by labels in Automation Coverage https://github.com/testomatio/app/issues/1344
• Added filtering by detached tests in Automation Coverage https://github.com/testomatio/app/issues/1458
• Added ability to duplicate metadata when duplicating tests https://github.com/testomatio/app/issues/1309
• Improved counter processing for Run Groups https://github.com/testomatio/app/issues/1359
• Improved processing of Owner and CreatedBy fields when importing XLSX/CSV in Testomat format https://github.com/testomatio/app/issues/1516
• Improved formatting when saving AI-generated suite summaries https://github.com/testomatio/app/issues/1518
• Added support for commas in parameters (examples) https://github.com/testomatio/app/issues/1539

Fixes

• Fixed transition from read-only user to Accountant
• Fixed Run Duration view https://github.com/testomatio/app/issues/1423
• Fixed updating test descriptions after assigning status https://github.com/testomatio/app/issues/1450
• Fixed rendering of tags starting with uppercase letters https://github.com/testomatio/app/issues/1462
• Fixed "Explain Failure" error: "messages[1].content must be a string" https://github.com/testomatio/app/issues/1481
• Fixed partial deletion of tests after adding images or pasting text/images https://github.com/testomatio/app/issues/1482
• Fixed merging of test parameters when merging a branch https://github.com/testomatio/app/issues/1485
• Fixed processing of Cyrillic characters when exporting to Markdown https://github.com/testomatio/app/issues/1489
• Fixed "undefined method suite for nil" error in Chat with Tests https://github.com/testomatio/app/issues/1499
• Fixed AI provider request failure when using Explain Failure follow-up https://github.com/testomatio/app/issues/1504
• Fixed processing of automated tests in mixed runs https://github.com/testomatio/app/issues/1524
• Fixed filter duplication in the opened sidebar https://github.com/testomatio/app/issues/1535
• Fixed pagination in the "Jira Issues" tab on the Tests page https://github.com/testomatio/app/issues/1536
• Fixed Pin mode causing UI issues and missing "Save" button on the Templates page https://github.com/testomatio/app/issues/1546

Redesigned New Plan Screen with Combined Test Selection

We redesigned the New Plan screen to improve the usability and flexibility of Test Plan creation. Users can now combine filtering and manual selection of test cases and test suites within a single workflow.

This allows adding tests from different sources using multiple criteria. For example, you can include high-priority tests from one suite and labeled tests from another suite in the same plan. Multiple queries (test collections) can be combined into a single Test Plan.

The updated flow makes Test Plan creation more flexible and precise, reduces the need for separate plans or manual adjustments, and helps teams assemble test coverage that better matches real test execution and release needs.

Shared Tests Across Projects

We introduced shared tests, allowing test folders and test suites from a source project to be shared with one or multiple projects. This makes it possible to reuse common test structures and scenarios across teams and products without duplicating data.

Shared suites remain synchronized with the source project. Any updates to the original test folders, suites, or test cases are automatically propagated to all connected projects, ensuring consistency of shared test coverage.

At the same time, test cases in target projects can be adjusted independently. Changes made to test cases in a consuming project do not affect the source project or other projects using the same shared suites.

Benefits

• Reuse test folders and suites across one or multiple projects
• Keep shared test structures and content synchronized automatically
• Reduce test duplication and maintenance effort
• Allow project-specific customization without impacting the source project

Updated New Run UI with Launch Type Tabs

We updated the New Run screen and introduced tabs for different test launch types. This allows users to switch between run modes and focus only on the options relevant to the selected launch type.

By separating run configurations into dedicated tabs, the New Run flow becomes clearer and less cluttered, making it easier to set up the required type of test execution without distraction.

Passing Suite IDs to CI from New Run View

We added the ability to select and pass suite IDs to CI when creating a new run. This is available in the New Run view as a multi-select input, allowing you to define which test suites should be executed as part of a mixed run.

The multi-select is implemented as a dropdown, where you can choose the required suites by their IDs. The selected suite IDs are then passed to your CI system.

To use this feature, you need to adjust your CI workflow by adding grep by suites and update your Testomat CI configuration to accept and process the passed suite IDs. See example here.

Improved Test Result View UI

We improved the user interface of the individual test result view, focusing on layout, readability, and navigation.

The updated design makes test results easier to view and understand, while UI optimizations improve rendering performance. Navigation within test results is now clearer, helping users review large or complex test outputs more efficiently.

The improved layout and visual structure make individual test results easier to read and navigate, while UI optimizations ensure faster rendering and a smoother test review experience, especially for detailed or large test outputs.

Expanded Copying for Tests and Suites

We expanded the copying capabilities for tests and test suites. In addition to the test description, you can now copy labels, linked issues (including Jira), and test attachments.

The copy flow has been enhanced to make these options explicit and configurable in the UI. When initiating a copy action, the system now clearly shows which test metadata will be included, allowing users to review and confirm the scope of the copy before proceeding.

Updated UI flow

• Open a test or test suite

• Select the Copy action from the available options

• In the copy dialog, review the included data:

  • labels
  • linked issues (including Jira issues)
  • attachments

• Confirm the copy action to create a new test or suite with the selected metadata preserved

The detailed copy flow ensures tests and suites are duplicated with full context, reducing manual follow-up work and preventing data loss. This helps teams reuse tests faster while keeping labels, issue links, and attachments consistent across copied items.

Pin Mode and Display Settings for Tests Page

We introduced Pin mode for the tests and suites view, allowing users to keep a fixed side panel when viewing a test or suite. This layout is similar to other test management systems and helps make Testomat adoption easier.

To support this, we added Display settings on the Tests page, where you can control how the test structure and side view are displayed.

Display settings options

• Hide tests in tree — shows only folders and suites in the main tree, helping keep the project structure clean and easier to navigate
• Pin sidebar — keeps the suite or test view fixed in a side panel while browsing the test tree

The new Pin mode and display options provide a more familiar and flexible layout, improve navigation in large test structures, and make it easier to review and manage tests without losing context.

Optimized Test Result Processing

We optimized the reporting and processing of test results submitted via XML. Results are now delivered to Testomat faster, especially for large test runs.

This improvement resolves an issue where some test results could be missing in runs with thousands of tests and eliminates delays when updating tests and execution results.

Benefits

• Faster availability of test results in large-scale test runs
• More reliable and complete run data
• Reduced delays when updating tests and execution statuses

🛠️ Fixes and Improvements

• Fixed launching multi-environmets runs https://github.com/testomatio/app/issues/1445
• Fixed multiple runs creation when using TESTOMATIO_SHARED_RUN_TIMEOUT https://github.com/testomatio/app/issues/1410
• Improved traces processing BDD projects https://github.com/testomatio/app/issues/1370
• Improved editing plan for ongoing run so excluded tests are removed https://github.com/testomatio/app/issues/1330
• Improved processing tags for automated tests https://github.com/testomatio/app/issues/1236
• Removed showing failures 0 in Slack notification https://github.com/testomatio/app/issues/900
• Improved importing suites inside another suite for JS frameworks and markdown https://github.com/testomatio/check-tests/issues/198, https://github.com/testomatio/app/issues/1408
• Fixed export to markdown for cyrylic https://github.com/testomatio/app/issues/1489

AI Requirements Update

New Requirements Management Page

We introduced a dedicated Requirements page that brings all your requirements into a single, convenient workspace. Now you can view, organize, and update requirements in one place — without jumping across different parts of the project.

This improvement makes it easier to:

• browse and manage large requirement sets
• navigate between requirements and linked tests
• keep your requirement coverage clean and structured

A more scalable workflow for teams working with complex specifications.

New Requirement Sources: Files & Text

You now have more flexible ways to create requirements:

Supported sources include:

• Files — PDF, DOCX, XLSX, CSV, TXT, Markdown, and others
• Plain text — paste any text and instantly convert it into structured requirements

This makes it much easier to import requirements from PRDs, customer documentation, spreadsheets, briefs, or any internal artifacts your team already uses.

Global Requirements Setup

You can now set Requirements as Global, allowing the system to automatically attach selected requirements to every newly created test.
This is especially useful for teams working with mandatory compliance rules, overarching documentation, or project-wide standards that must be reflected in all tests.

To use it:
Open Project → Requirements → Select a Requirement → Global Requirements

This ensures consistency and saves time by eliminating repeated manual assignment.

Here is the updated paragraph title with an emoji — clean and appropriate for a changelog:

AI-Powered Image Understanding for Requirements

You can now attach images directly to your requirements, and AI will automatically analyze them and include their content in the requirement summary. This enriched summary is then used during test generation, ensuring that visual details are not missed.

All attached images are also automatically added to the tests created from these requirements.

The same behavior now applies to Jira- and Confluence-based requirements:
if your Jira ticket or Confluence page includes attachments (images, diagrams, files), Testomat.io will import them, analyze them, and enrich the requirements summary — giving you more accurate AI-generated tests.

🛠️ Easy MCP Server Setup from Project UI

You can now quickly connect the Testomat.io MCP Server directly from your project interface.

The Model Context Protocol (MCP) allows AI assistants like Claude Desktop, Cursor, and Zed to securely access and manage your test cases.
With this release, we’ve made configuration effortless — no need to search documentation.

How to access:
Open your project → Extra menu (top-right corner) → MCP Server

Inside, you will find step-by-step instructions for connecting the Testomat.io MCP Server to your preferred AI tool.

This makes integrating AI into your workflow faster, smoother, and more accessible for your entire team.

You can find more details on Testomat.io MCP Server here.

🤖 Robot Framework Support

Robot Framework is a popular Python based automation framework used for acceptance testing, ATDD, and RPA. It uses keyword-driven testing, making tests readable and easy to maintain.

With this update, you can now import Robot Framework tests into Testomat.io and report test results directly from your CI/CD pipelines or local runs.

Benefits of using Testomat.io for Robot Framework tests:

• Centralized test reporting and management for all Robot tests
• Traceability of test results and easy linking to requirements or issues
• Insights into test coverage, flaky tests, and execution trends
• Ability to combine Robot tests with manual and other automated tests in mixed runs for unified reporting

You can find more details Testomat.io plugin for Robot Framework here.

🌐 Global Analytics Improvements

We refined and improved the Global Analytics experience to make it more intuitive and visually appealing.

What’s new:

• Simplified widget creation – it’s now smoother and faster to configure analytics widgets for your workspace
• Refreshed UI – widgets have an updated, cleaner look for better readability and a more modern analytics dashboard

These enhancements make it easier to build meaningful insights and keep your global Testomat.io analytics organized and clear.

🔗 Linking Automated Tests to Manual Test Cases

We’ve expanded how automated test results can be connected with manual test cases, giving you full control over how tests appear in reports. This improvement ensures that all scenarios — automated or manual — are properly tracked and reported.

Key Updates

Automated Runs (Default)

Automated runs remain focused on automated test execution results. Manual test cases linked via linkTest() are shown as references but do not count as executed tests. This keeps automated test reports clean while still showing related manual coverage.

Manual Runs

In manual runs, you can link automated tests to manual test cases. Only manual test cases appear in the report, while automated tests remain hidden. This is useful when automated checks verify manual test status without inflating execution counts.

Mixed Runs

Mixed runs combine both automated execution and manual test results in a single report. Each appears as a separate entry, giving you a complete and accurate view of test coverage.

How It Works

# 1. Create a run (manual or mixed)
RUN_ID=$(TESTOMATIO=tstmt_xxxx npx @testomatio/reporter start --kind mixed | tail -n 1)

# 2. Run your automated tests while linking to the created run
TESTOMATIO=tstmt_xxxx TESTOMATIO_RUN=$RUN_ID <run tests command>

# 3. Or use the one-step approach
TESTOMATIO=tstmt_xxxx npx @testomatio/reporter run "<run tests command>" --kind mixed

This flexible linking system ensures that automated and manual tests are fully integrated, giving teams better insight into testing progress and coverage.

Find more details here.

🎯 Assign Priority & Link Issues While Creating or Editing Tests

We streamlined the test creation flow!
Now, when creating or editing a test, you can immediately:

• Set test priority
• Link the test to an issue (Jira, GitHub, etc.)

This removes the need for additional edits and helps maintain consistent test documentation from the start.

📍 This option is available now directly in the test creation/edit modal.

🚀 Launch Automated Tests Directly from the Test Tree

We expanded the ability to trigger automated tests right from the Tests page. You can now multiselect tests or suites in the Test Tree and launch:

• Manual runs
• Automated runs
• Mixed runs

This provides a faster workflow — especially when working with hybrid projects combining manual and automated testing.

➕ Create an Empty Test Run & Build It on the Go

We introduced a new way to start your testing process — create an empty Test Run first, then add or create tests as you go.

Ideal for:

• Exploratory testing
• Quick verification tasks
• Creating tests from findings during execution

Your Test Run can now evolve in real time, adapting to your testing flow without requiring upfront setup.

🧭 Issues Traceability Coverage Report

We added a new Traceability report to help you see how well your issues are covered by tests. Now you can easily track test coverage for Jira or other linked issues across your project.

Where to find it:
Analytics → Issues widget → Extra menu → Download Traceability report

Pro tip:
Use filters to narrow down results: Environments, Tags, Labels, Date Range, Priority

This report is especially useful for release readiness checks and coverage audits.

🛠️ Fixes and Improvements

• Fixed timestamps in Test Run tab — now showing exact execution time
• Fixed removing tests after launching tests from the Tests Tree
• Fixed UI updating when adding/removing tags in bulk
• Fixed reporting automated test steps via API

Test Case & Code Quality Review

We introduced AI-powered Quality Review for both manual test descriptions and automated test code.
This feature analyzes your tests and provides intelligent feedback with actionable advice to improve clarity, structure, and best practices.

You can use it in two ways:

• Test Case Quality Review – Evaluates the quality of a manual test’s description, suggesting improvements for readability, consistency, and completeness.
• Test Code Quality Review – Reviews your automated test code to detect potential issues, enhance maintainability, and align with testing standards.

How to use:
Open any test → choose Description or Code → click the AI button → select Code Quality Review or Test Quality Review.

Company Statistics Widgets

We’ve introduced Company Statistics, a new feature that provides an overview of activity across all projects within your organization.
This update includes three insightful widgets:

• Data Statistics – Tracks model activity such as Tests, Plans, Suites, Runs, Imports, and Test Runs. Displays created, updated, and deleted counts per project for complete visibility of repository changes.
• User Activity – Shows detailed insights into user behavior, including logins, actions performed on tests and other models, and manual test run activity across the organization.
• AI Usage – Monitors AI prompt utilization, displaying success rates, the number of active users, and usage distribution by prompt type across all projects.

📊 You can also export company usage data to a spreadsheet for reporting, sharing, or deeper analysis.

This option is available for users with Owner and Manager roles.
To access it, go to Companies → open your Company → Extra menu button → Statistics.

Notes (Temporary Test Cases)

Introducing Notes — lightweight, temporary test cases designed for quick or one-time checks during your testing process. They help teams record ad-hoc test ideas or short-term validations without adding unnecessary clutter to the main test repository.

Key Highlights:

• Quick creation – Instantly create a Note within an active test run or test plan.
• Isolated from repository – Notes stay separate from the permanent test hierarchy, keeping your project clean and focused.
• Convertible – When a Note turns out to be valuable, you can easily convert it into a permanent test case.

This feature is ideal for exploratory sessions, short-term fixes, or documenting spontaneous test scenarios during a run.

Learn how it works in user guide.

Drag-and-Drop in Side View

We’ve enhanced navigation and organization within the Side View by adding drag-and-drop functionality.
Now you can easily reorder items without switching context:

• Reorder tests within a suite – simply drag tests to adjust their order.
• Reorder suites within a folder – drag entire suites to reorganize structure within the same folder.

This improvement is especially valuable for projects with deeply nested hierarchies, helping teams manage large repositories more efficiently while keeping changes local to the current context.

Import Jira Links from Spreadsheet

We’ve expanded the spreadsheet import functionality to support Jira (and other issue tracker) links.

Now, when you import tests using the Testomat.io spreadsheet format, the corresponding Jira issues will be automatically linked to your test cases during import.

How it works:

• 📄 Use the Testomat.io spreadsheet template, now enriched with an “Issues” column.
• 🔗 When you import, Testomat.io will automatically connect tests to their related Jira (or other issue tracker) items.
• ⚙️ Make sure your Issue Management integration is configured before importing — see setup guide for details.

This improvement streamlines migration and bulk data import by keeping all test-to-issue relationships intact right from the start.

Plan Updates Now Reflected in Pulse

We’ve enhanced Pulse to provide even deeper visibility into your project activity. Now, any changes made to Test Plans — such as edits, updates, or new plan creations — are instantly reflected in Pulse.

This improvement ensures that your team can easily track not only test runs and results but also strategic updates in your testing workflow, all in one place.

Fixes and Improvements 🛠️

• Done optimization in search - providing faster search results
• Added more options for quick test creation in test tree
• Fixed showing Jira statuses when hovering Jira issue
• Fixed Test Run History duplication and filtering https://github.com/testomatio/app/issues/1425

Java Support Added

We’ve expanded Testomat.io with native Java support 🎉

Previously, you could already use our Java Reporter and Java Check-Tests CLI tool to import and report Java tests.

With this update, the setup process is even smoother:

• 🚀 Instructions for importing Java tests are now available directly in the application UI.
• 📝 Guidance for using the Java reporter is also included, so you can easily connect your automated Java tests with Testomat.io.

This makes Java integration more straightforward, reducing the need to jump between documentation and your project.

Easier Jira Integration Without Admin Rights

We’ve simplified how you connect Jira with Testomat.io. Now, you can set up the integration without requiring Jira administrator rights.

This improvement makes it much easier for teams to get started, especially when:

• Users don’t have admin permissions in Jira
• Companies want to avoid lengthy setup approvals
• Teams need a faster way to link test management with issue tracking

With this change, more users can seamlessly integrate Jira and start benefiting from synchronized workflows between test cases, runs, and Jira issues — all without waiting for admin access.

Run Report Notifications via Telegram

We’ve expanded communication options in Testomat.io — now you can send Run Report notifications directly to Telegram. This makes it simple to keep your team instantly updated on the status of test runs, without switching tools.

With this update, you can:

• Customize your notifications: Use Run Report templates to adjust the content and formatting of messages.
• Share with any audience: Deliver notifications to Telegram chats, channels, or groups, depending on where your team collaborates.
• Stay aligned in real time: Ensure distributed teams, stakeholders, or external partners receive updates immediately, keeping everyone on the same page.

This integration helps improve visibility and speeds up decision-making by bringing test results directly into the conversations where your team works every day.

Learn more here.

Filter Manual and Automated Tests in Mixed Runs

Mixed Runs in Testomat.io allow you to execute manual and automated tests together within the same run, combining results into one unified report.

With this update, we’ve added a filter option that lets you quickly separate manual from automated tests inside a Mixed Run.

This makes it easier to:

• Focus only on manual work when needed
• Review automated results independently
• Navigate large runs with better clarity and control

AI-Suggested Tests from Suite Description

We’ve made it even easier to create tests with the help of AI. ✨

Now, you can simply add a text description to any suite, and Testomat.io will generate tests for you directly from that description.

• No additional integrations or setup required.
• Quickly turn suite documentation into actionable test cases.
• Perfect for jumpstarting test creation or expanding coverage based on functional requirements.

This improvement helps you save time and move from idea → documentation → tests in just a few clicks.

Change Project Slug (Project ID)

We’ve added the ability to change a project slug (project ID) — a feature that was not available before.

This option is accessible only to Project Owners from the Company Projects Dashboard. It gives more flexibility in managing project identifiers, especially if naming conventions or organizational structures change.

⚠️ Important Note:
Changing a Project ID will:

• Affect all existing project links
• Potentially disconnect the project from Jira integrations

👉 We recommend updating the Project ID only when absolutely necessary.

Fixes and Improvements 🛠️

• Introduced the ability to delete ongoing runs
• Fixed 400 error when creating a bug via YouTrack and ClickUp integration
• Improved optimization for uploading stack traces in test run result
• Improved linking tests by test plan in Jira plugin
• Fixed AI settings update

Dashboard Widgets for Global Analytics

We’re introducing customizable widgets for Global Analytics, giving you the power to organize and visualize testing data in the way that best fits your team.

Getting started is simple: navigate to Dashboard → Analytics → Dashboards → Create your own Dashboard and choose the widgets you’d like to display. You can track key metrics such as Success Rate by Date, Run Stats, Automation coverage, and Execution trends.

Why this is useful

• Personalized view – focus on the metrics that matter most to your project.
• Better visibility – instantly understand the health and progress of your testing activities.
• Data-driven decisions – spot trends, identify bottlenecks, and track improvements over time.
• Team alignment – share a unified view of test results across the organization.

With customizable dashboards, your analytics experience becomes more flexible and actionable, helping you drive smarter QA and release decisions.

Agents Temporarily Available for Professional Plan

Testomat.io Agents are intelligent assistants that enhance your testing workflow by:

• Deep Analyze - Deeply analyzes the project and provides a comprehensive overview of the running status and coverage of tests
• Improve Test Descriptions - Go through all tests with descriptions and improve their markdown formatting. This action won't change the content, only improves the formatting. Applied changes can be safely reverted in Pulse.
• Write Descriptions from Code - Updates all automated tests which have no description by analyzing their code and writing descriptions.
• Mark Flaky Tests - Adds "Flaky" label to all flaky tests detected by analytics. Update analytics settings to customize flaky detection.
• Mark Failed Tests - Adds "Failed" label to all tests that failed all the time. Analytics will detect tests that failed for last month.
• Transform Project to BDD - Creates a new project with all the tests converted to BDD Gherkin format.

These powerful features are normally included in the Enterprise plan. However, we’re excited to announce that AI Agents are now temporarily available for Professional plan users.

This is the perfect opportunity to try them out in your projects and see how AI can optimize your QA process.

👉 Give them a spin and share your feedback with us in our Slack community.

🚀 Testomat.io Reporter 2.3.0

We’re excited to introduce a new version of the Testomat.io Reporter packed with powerful enhancements that make your reporting more flexible and deeply integrated with your workflow.

🔖 Add Labels to Tests via Reporting

You can now add a label to a reported test directly through the Reporter.
Unlike the meta label, these labels are persisted to the test case itself, not just to the reported run.

• If the label doesn’t exist in Testomat.io, it will be automatically created and linked to the test case.
• You can also use existing labels or pass a label value if the label was created as a custom field.
  👉 Learn more

🔗 Link Tests to a Run Result

It’s now possible to link one or multiple tests to the current test in the report.
This lets you associate multiple test cases with a single execution, ensuring more precise coverage tracking.
👉 See docs

📝 Link Run Results to Jira Issues

With Reporter 2.3.0, you can now link Jira issue IDs to your test report, creating a direct connection between executed tests and related Jira issues. This tightens the feedback loop between QA and development.
👉 See docs

🗑️ New Runs Deletion Strategy

Starting September 2025, Testomat.io replaces the old Delete option with a safer Purge for Runs workflow. Purged Runs are first compressed and moved to the Archive, preserving essential data like test results and artifacts. Runs can be restored from the Archive, and permanent deletion only happens when manually removed from the Archive. Automatic purges follow the same two-step process, keeping your workspace clean while safeguarding important data.

You can find more details in our documentation.

🤖 Improved Artifacts Support for WebdriverIO

We’ve fixed and improved artifacts support for WebdriverIO (WDIO), a popular end-to-end testing framework for web applications. With this update, you can now generate and view artifacts more reliably when running automated tests.

To ensure accurate Wdio reporting, please use Testomat.io Reporter v2.2.2.

Gauge Framework Support

We’re excited to announce support for the Gauge test automation framework — an open-source tool for writing lightweight, readable, and maintainable acceptance tests.

With this update, you can:

• 📥 Import Gauge tests into Testomat.io and keep them synced
• 🔑 Update test IDs so automated tests match correctly during CI/CD reporting
• 🛠️ Find all required commands directly in Testomat.io for easy setup
• 📊 Report Gauge test results with Testomat.io Reporter.

This integration makes it seamless to manage Gauge projects in your existing Testomat.io workflows.

Improved Invite Page

We’ve made the Invite Page more user-friendly. Now, when inviting new team members to your company, you can assign a user role right away.

This small but impactful improvement streamlines the onboarding process, saves time, and ensures new users get the correct permissions from the start.

Export Suite as PDF

You can now download any suite as a PDF file and easily share it with teammates, managers, or stakeholders.

Using this feature is simple:

1. Open the desired suite
2. Click the Extra menu button
3. Select Export as PDF

This makes it convenient to share test content outside of Testomat.io, whether for reviews, documentation, or reporting purposes.

Export Insights as PDF

We’ve expanded the Insights feature with the ability to export reports as PDF files. Now, instead of keeping your analytics only within Testomat.io, you can easily download and share Insights with teammates, stakeholders, or management.

This makes it simple to:

• Distribute test health and coverage reports during sprint reviews or release planning.
• Attach detailed insights to documentation or presentations.
• Keep a snapshot of project quality for historical tracking or audits.

With just one click, you can generate a professional, shareable PDF version of your Insights report.

Save Tests as Templates

We’ve enhanced the Templates feature with the ability to save any existing test as a reusable template. When editing a test, you can now select Save as Template, and a new template will be created automatically.

This allows you to:

• Reuse well-structured tests as blueprints for similar scenarios.
• Maintain consistency across large test repositories.
• Speed up test creation by starting from proven test cases instead of building from scratch.

With this update, templates become even more practical — helping teams standardize test design and improve productivity.

Updated UI for Advanced Relaunch

The Advanced Relaunch option allows teams to restart failed or selected tests from previous runs, ensuring faster recovery and more efficient reruns without starting the entire suite again.

We’ve updated its UI to make it even more powerful:

• Added new sorting options to organize tests before relaunch.
• Introduced advanced filtering to easily target tests in mixed runs (manual + automated).

This improvement makes it easier to relaunch exactly what you need — helping teams save time and keep test cycles lean and focused.

Add Text to Completed Reports

We’ve introduced the option to add text to a report even after the run has been completed. This means you can provide additional context, document conclusions, or highlight key observations once execution is finished. The added text will appear in the summary section of the report, making it easier to keep your team and stakeholders aligned with the most up-to-date insights.

Fixes and Improvements 🛠️

• Fixed an issue where code templates were missing tag IDs, allowing variables to be set correctly
• Fixed incorrect symbols in a test code template
• Fixed an issue that prevented creating issues with YouTrack integration
• Fixed issues with test runs and manual test data loading, improving overall system reliability
• Improved processing of Test Results on Run Report page - optimized artifacts and traces uploading
• Added support labels to use a Key:Value format in notification templates

Mark Suites as Favourites ⭐

Working with large projects often means navigating through a long test tree or running the same search queries over and over again. To make your workflow smoother, we’ve introduced the Starred feature for test suites.

Now you can:

• ⭐ Star any suite you plan to work on — whether it’s for the current sprint, a specific release, or ongoing maintenance.
• 📂 Create your own quick-access list of suites to eliminate repetitive navigation through the entire test tree.
• 🔍 Mark favourites directly from search results — if you’re looking for a test or suite by keyword or using filters you can instantly star it without leaving the search view.
• ⏱ Quickly return to starred suites even after filters or selections are reset — simply use the Starred filter to jump back.
• 🛠 Work more efficiently by keeping frequently accessed suites at your fingertips, especially in large or multi-team projects.

Whether you’re focusing on smoke tests, regression packs, or a specific customer scenario, the Starred feature ensures you spend less time navigating and more time testing.

Export & Version Control Manual Tests in Git (Markdown Support)

You can now export your manual tests as Markdown files directly into your Git repository and keep them under version control.
This allows your team to write, edit, and track changes to manual test cases just like code — with full history, branching, and collaboration benefits that Git offers.

What’s new:

• 📤 Export manual tests to Markdown – keep human-readable test cases in your repository.
• 📥 Import manual tests via CLI – instantly sync Markdown changes from Git into Testomat.io.
• 🔄 Version control for manual tests – review, revert, and track changes over time.
• ✍️ Write and modify in your editor – use your favorite IDE to create or update test cases.

User Scenario:
Imagine you’re working on a new product release and your QA team collaborates closely with developers.
Instead of switching back and forth between Testomat.io and your code editor, the manual test cases live right next to your application code in Git.

• A developer spots a missing step in a test case and updates the Markdown file in their branch.
• The change is committed, reviewed in a pull request, and merged into main.
• The updated test case is automatically synced back into Testomat.io via CLI.

This workflow makes test case management seamless, collaborative, and fully traceable — aligning your manual testing process with modern DevOps practices.

How to Export Tests?

Run the export command in your project directory to download tests from Testomat.io.
Tests will be created in Markdown format.
It’s highly recommended to use Git Version Control to manage exported tests locally as files.

What Gets Exported?

• All test suites and tests from your current project.
• Test IDs, descriptions, priorities, and structure are preserved in the generated files.

Deep Analyze Agent – AI-Powered Project Insights

Introducing the Deep Analyze Agent, an advanced AI tool designed to give you a comprehensive, data-driven overview of your project’s testing health.
It goes beyond surface-level reporting to deeply assess running status, test coverage, and release readiness.

It provides:

• 🔍 Full project scan – AI examines the structure, test suites, and execution history.
• 🗂 Functional area mapping – identifies project areas based on suites and their test coverage.
• 📊 Coverage analysis – compares existing tests with execution results to highlight untested or risky areas.
• 💡 Actionable insights – provides recommendations for improving coverage, stability, and release readiness.
• 🚀 Release readiness check – helps teams make informed go/no-go decisions before deployment.

User Scenario:
You’re preparing for a major release and need a clear picture of your project’s testing health.
Instead of manually compiling reports from multiple runs, the Deep Analyze Agent automatically:

1. Scans your entire project structure and suite organization.
2. Maps suites to functional areas of your product.
3. Compares planned coverage with executed coverage.
4. Flags untested, low-pass-rate, or high-risk areas.
5. Summarizes the results into an easy-to-read dashboard with recommendations.

This means QA leads, PMs, and developers can make data-backed decisions faster, with confidence in the quality status of the product.

Analyze Suite – Functional Coverage & Stability at a Glance

The new Analyze Suite tool brings AI-powered analytics directly to individual suites, helping you assess both functional coverage and suite stability without navigating the entire project view.

What’s new:

• 🗂 Functional area coverage mapping – analyzes tests within a suite to determine which parts of your product it covers.
• 📊 Suite Stability Report – evaluates recent test execution results to highlight flakiness, instability, or recurring issues.
• 🔍 Focused insight – ideal for monitoring the health of specific product modules or critical flows.

By providing actionable insights at the suite level, teams can quickly identify improvement areas, address instability, and maintain high-quality standards in critical parts of their projects.

AI Features in the Jira Plugin

We’ve extended Testomat.io’s AI capabilities to the Jira plugin! Now you can access powerful AI-assisted options directly within your Jira projects, including:

• Suggest Tests — Automatically generate relevant test cases.
• Suggest Description — Get AI-powered recommendations for detailed and clear issue descriptions.
• Other AI-driven enhancements to streamline your test design and issue tracking workflow.

This integration helps improve collaboration between development and QA teams by embedding intelligent test suggestions right where your work happens.

Merge Tests – Simplify and Clean Your Test Repository

Sometimes test repositories accumulate duplicate or overlapping tests that can cause confusion and inefficiency. The new Merge Tests feature helps you clean up your test library by combining multiple tests into one while preserving valuable information from all merged tests.

Key benefits:

• 🧹 Easily remove duplicate or redundant tests
• 📝 Consolidate descriptions and important details from all merged tests
• 🔄 Maintain test history and continuity without losing data

How it works:

• On the Tests page, enable multiselection
• Select the tests you want to merge
• Click the extra button on the bottom menu bar and choose Merge
• Select the main test to keep as the base for merging
• Review and edit the suggested combined description
• Add any follow-up notes if needed
• Confirm by clicking Update test description

This streamlined process makes test maintenance easier, helping teams keep their test repository clean, accurate, and up-to-date.

Collapse and Expand All Suites in Runs

Managing large test runs with hundreds or thousands of tests can be overwhelming. To make navigation easier, we introduced the ability to collapse and expand all suites in the test list.

This feature allows you to quickly hide or show all test suites within a run, helping you focus on specific parts of your test set or get an overview without endless scrolling.

Perfect for runs with 1000+ tests, it saves time and reduces visual clutter, making manual test execution smoother and more efficient.

Nightwatch Framework Support

We’ve added Nightwatch framework support to Testomat.io! Now you can easily import your Nightwatch automated tests and enable detailed reporting within the platform.

Use the latest version of the check-tests and @testomatio/reporter CLI tools to import and run your Nightwatch tests with full integration. This allows you to track test results, analyze trends, and generate reports directly from your Nightwatch test runs.

For detailed instructions on importing and configuring Nightwatch tests, see the dedicated documentation.

Fixes and Improvements 🛠️

• Fixed RunGroup pagination https://github.com/testomatio/app/issues/1386
• Added Launch a Copy option for Mixed runs https://github.com/testomatio/app/issues/1389
• Save option for Mixed runs https://github.com/testomatio/app/issues/1388
• Fixed test order in PDF report not matching the test order in the run report https://github.com/testomatio/app/issues/1383
• Improved processing of multiselection bulk actions for Manual Run

Global Analytics Revamped

The Global Analytics page just got a major upgrade!

• 🚀 Faster loading & improved performance across large data sets
• 🧠 Smarter UI with redesigned layout for better readability
• 🎯 Simplified filtering by project, tags, status, and more
• 📈 New pie-chart diagrams to instantly visualize test coverage and outcomes

Now it's easier than ever to get a quick view of testing across your entire organization.

Global Analytics: Now with Label & Custom Field Filters

We’ve expanded the filtering options in Global Analytics:

• ✅ Filter by labels to narrow down results by tag (e.g., smoke, regression, critical)
• 🛠️ Filter by custom fields defined in your workspace or test suite

These additions make cross-project analysis even more precise and tailored to your team’s needs.

Mixed Runs Without CI Configuration

You can now launch mixed test runs (manual + automated) even if your project isn’t connected to a CI system. Previously, this option was only available for projects with a configured CI pipeline.

With this update, you can:

• Start a mixed test run that includes both manual and automated tests.
• Send automated test results via API or the Testomat.io Reporter.
• Keep full control of test execution in projects that are managed outside CI/CD tools.

🔗 For reporting with Testomat.io Reporter, see the documentation

🔗 For reporting via API, see the reference

This gives teams greater flexibility when working in hybrid environments or when CI integration isn’t yet set up.

Improved Template Creation Experience

We’ve enhanced the template creation interface to make it more intuitive and efficient. The updated UI offers a clearer layout, helping you build and manage templates with ease.

What’s new:

• ✅ Streamlined UI – Clean and simple layout for faster editing
• 🔤 More dynamic variables – Easily insert parameters and placeholders to customize content for different test cases or runs
• 🔍 Searchable variables list – Quickly find the variables you need without scrolling
• 🧩 Better flexibility – Create reusable templates tailored to various teams, workflows, or projects

These improvements help diversify your test documentation and boost consistency across test cases, reports, and communication.

See more variables in the documentation.

Custom Templates for Slack and MS Teams Notifications

You can now customize Slack and Microsoft Teams notifications using powerful templates. Whether you're alerting teams about test results, failures, or run completions — tailor the message content to your needs with the expanded set of dynamic variables.

Key Highlights:

• ✏️ Fully customizable content – Adjust tone, structure, and data shown in notifications
• 🔁 Use rich variables – Access test names, run IDs, statuses, links, durations, and more
• 🔍 Searchable variables list – Easily find and insert relevant variables while editing
• 📢 Improve clarity and relevance – Ensure your team gets the right info at the right time, in the right format

⚠️ Note: If you already have Slack or MS Teams notifications configured, you’ll need to create a new Notification Rule to apply the updated templates.

Improved Handling of Jira Fields: Versions & Components

We’ve enhanced support for Jira fields, specifically:

• 🔄 Versions – improved mapping and synchronization of release versions
• 🧱 Components – better detection and association with test artifacts

These fields are commonly used during defect creation, so this improvement ensures more accurate and seamless linking between your Jira issues and test cases — making your defect reporting process more efficient and reliable.

Rungroup Statistic Report

Introducing the Rungroup Statistic Report — a new way to analyze the health and progress of test runs grouped together.

This report includes:

• ✅ Run Execution Summary – a quick breakdown of passed, failed, and skipped tests across all runs in the group
• 🔍 Detailed Analytics by Run Status – view trends, patterns, and key metrics within each run
• 💡 AI-Powered Recommendations – suggested actions to improve stability and address recurring issues

Perfect for teams managing large-scale test executions across multiple environments or test types.

Fixes and Improvements 🛠️

• Fixed follow-up messages for AI features
• Implemented combined Report to include test runs from the child folders
  https://github.com/testomatio/app/issues/1192
• Fixed suite search inconsistent behavior for newly created suites https://github.com/testomatio/app/issues/1303
• Fixed Global analytics filtering by Jira issue https://github.com/testomatio/app/issues/1377
• Improved handling Artifacts for Minio: added Enable if you use Minio FORCE_PATH_STYLE=true setting to Artifacts configuration UI
• Fixed filtering by Jira issue for Global analytics https://github.com/testomatio/app/issues/1377

Testomat.io Reporter v2.0.1 Released

We’ve rolled out a major update to the Testomat.io Reporter library — the core utility that sends your automated test results to the Testomat.io platform. This update improves compatibility, performance, and control for engineering teams integrating our reporter into their CI/CD pipelines.

What’s New:

• Full ESM Support (with CommonJS fallback)
  Works seamlessly with modern JavaScript projects and still supports older setups.

• Simplified Imports
  Cleaner, shorter import paths to make configuration easier.

• New replay Command
  Re-send reports for a test run using a simple command — helpful for debugging or audit trails. (Run must be executed with DEBUG pipe enabled.)

• Control File Creation in XML Mode
  Use TESTOMATIO_IGNORE_NEW_TESTS to prevent new files from being created during XML imports.

• New Path Config Options
  Specify the root location for test files using TESTOMATIO_SUITE and TESTOMATIO_WORKDIR — more flexibility for monorepos and custom setups.

• XML Import Enhancements
  Improved accuracy and compatibility for teams working with JUnit or other XML formats.

• Faster Network Layer
  Switched from axios to the lighter gaxios (built on node-fetch) for leaner HTTP performance.

• Improved Report Metadata
  Added a timestamp column and unique runId for better tracking and traceability in reports.

👉 For full technical details, visit the release notes: Testomat.io Reporter v2.0.1 on GitHub

AI-Powered Project Runs Status Report

We’ve added a smart new feature that automatically generates a high-level status report for your project’s test runs — powered by AI.

The Runs Status Report gives you a quick overview of test stability, critical issues, and performance trends across recent runs. It helps QA teams and stakeholders understand what’s working well and where attention is needed — without digging through individual test logs.

What’s included:

• Summary Overview – Total test runs, overall pass rate, trends, and key action items.
• Area-Specific Stability – Performance insights grouped by feature areas (e.g. subscriptions, user roles, etc.).
• Flaky & Failed Tests – Highlights of recurring issues or flaky behavior with potential risk.
• Execution Time Trends – How test durations are behaving over time.
• Top Errors – Most frequent failure messages to help speed up debugging.
• Systematic Failures – Pinpointed test cases that failed consistently and may block critical flows.

This report is available automatically based on recent test run history, giving your team instant visibility into the health of your project.

Apply Labels to Imported Tests

Now you can automatically organize your tests by adding labels to them at the moment they are imported into Testomat.io. Labels act like tags or categories that help you group and filter your tests more easily — for example, by test type, area of functionality, or team ownership.

What this means in plain language:

When a developer imports automated tests into Testomat.io, they can now attach labels in bulk. This saves time and ensures tests are properly organized from the beginning — no need to label them one by one later.

Example Use Cases:

• Group all tests for a login feature with feature:auth
• Mark high-priority tests with severity:high
• Separate backend and frontend tests with team:backend, team:frontend
• Identify core tests for quick runs with smoke

Once imported, you can easily filter and find tests in the UI using these labels — improving test planning, execution, and reporting.

The feature is available in check-tests@0.11.1 and check-cucumber@0.6.0.
Find more details for check-tests and check-cucumber

Custom View for Run Reports

You can now customize the table view inside any Run Report, just like on the Runs and Run Groups pages.

This allows you to:

• Show or hide columns such as test status, duration, labels, tags, priority, etc.
• Focus only on the data that matters most to you or your team
• Tailor the report layout for different review needs

How to use:

• Click the “Custom view” button to instantly open the configurable view
• Adjust Run list settings, including the width of individual columns to suit your preferences
• These settings are saved automatically and will apply to all Run Reports until changed again

Add Tests to Ongoing Run from the Tests Page

You can now add tests directly to an ongoing test run right from the Tests page — making test management more dynamic and efficient.

🔍 How It Works:

1. Go to the Tests page.
2. Enable multiselection.
3. Use filters or checkboxes to select individual tests or entire suites.
4. In the bottom bar, click the Extra (•••) button.
5. Select Add to Run.
6. Choose the ongoing run from the list or use the search bar.
7. Confirm your selection — and you're done!

✅ The selected tests will be immediately added to the active test run, helping you keep your execution plan up-to-date even while a run is already in progress.

Simplified Top Bar on the Runs Page

We've cleaned up the top bar on the Runs page to make the interface more streamlined and focused.
But don’t worry — you still have access to all key actions!

What changed:

• The buttons for New Manual Run, Run Group, and CI Launch are now grouped under a single “Action” button in the top-right corner.
• This change reduces visual clutter while keeping all important actions just one click away.

Fixes and Improvements 🛠️

• Improved multiple files uploading, preventing file loss https://github.com/testomatio/app/issues/1215
• Improved search for tests, returning results with matching test descriptions, both for classical and BDD projects
• Fixed issue with loading artifacts in Run Report Custom view https://github.com/testomatio/app/issues/1375
• Fixed editing test title issue - when editing title with the double click option

Simplified Test Tree View: Hide Tests in Tree

For large projects, the test tree can get overwhelming. We’ve added a "Hide tests in tree" option on the Tests page to help you keep things tidy. When enabled, expanding folders or suites will only show their structure — without displaying individual tests.

This improves navigation clarity and speeds up browsing for users managing extensive test repositories.

To enable this mode:
Go to the Tests page → click the Display button → enable "Hide tests in tree"

Benefits:

• Quickly navigate large or deeply nested test structures
• Reduce visual clutter when focusing on suites and folders
• Improve performance and responsiveness of the tree view

Dynamic Parameter Rendering in Test Steps

You can now reference parameter values directly in test steps and expected results of parameterized test cases using {{variable}} syntax. This allows test steps to dynamically reflect the input data for each test iteration — improving maintainability and clarity.

Example:

• Step: Enter username {{username}} and password {{password}}
• Expected result: User {{username}} is logged in successfully

Use cases:

• Reusable data-driven test cases for login, forms, or bulk workflows
• Reduced duplication by avoiding hardcoded values
• Easier review and execution with clear step context per data set

Track Changes in Ongoing Test Runs

We’ve added a Configuration Details view to help you track changes made during an active test run. This includes updates like added or removed tests — giving your team better visibility and consistency when managing evolving test scopes.

To access this view: Open an ongoing run → click the Edit button → go to Details

Benefits:

• Maintain traceability when test scope changes during execution
• Ensure test results reflect all modifications made mid-run
• Support audit and review processes in dynamic test cycles

Fixes and Improvements 🛠️

• Optimized custom fields rendering: truncating custom field title ans showing more value
• Improved project management: restricted project settings for non-management users
• Fixed parameters rendering in mail notifications https://github.com/testomatio/app/issues/1232
• Optimized Global Analytics uploading: better loading results
• Fixed missing Feature code when using TESTOMATIO_PREPEND_DIR option https://github.com/testomatio/app/issues/1352
• Polished styles for Company members page
• Improved formatting in Comments text area
• Fixed assigning users in manual runs https://github.com/testomatio/app/issues/1355
• Optimized processing requirements https://github.com/testomatio/app/issues/1358
• Improved SCIM integration with correct namespace and eager-load compatibility
• Fixed an issue with AI BDD descriptions, removing code duplication

AI Agent: Mark Flaky Tests

Our new AI-powered agent automatically detects flaky tests and assigns them a "Flaky" label based on test execution analytics. This helps teams quickly identify unstable tests that require attention and improves visibility into test reliability across projects.

You can customize flaky detection thresholds and conditions in your project’s Analytics Settings for greater control and accuracy.

Use cases:

• Quickly isolate unreliable tests that frequently fail intermittently and impact CI pipelines.
• Improve test quality over time by tracking and addressing flaky tests more systematically.
• Streamline triage processes by flagging flaky tests with a consistent label used across dashboards and reports.

AI Agent: Mark Failed Tests

This AI-driven agent automatically identifies consistently failing tests and assigns them a "Fail" label. It analyzes the last month of test execution data to detect tests that have failed 100% of the time, helping teams focus on the most critical issues first.

You can review and act on these labeled tests directly from analytics or test repository views.

Use cases:

• Prioritize test fixes by highlighting tests that fail consistently and block releases.
• Improve test suite stability by quickly spotting long-term failures across large projects.
• Enable smart filtering in dashboards or test plans using the "Failed" label.

Chat with Tests for a Folder

You can now use Chat with Tests to analyze the content of any specific folder within your project. The AI will examine all nested suites and tests under the selected folder, providing targeted insights, summaries, and test suggestions for that specific section of your test repository.

This enables more focused analysis and planning when working with large or modular projects.

New Pre-Configured Prompts for Chat with Tests

We've expanded the Chat with Tests AI feature with a set of pre-configured prompts to speed up your work and get instant insights from your test base. The new options include:

• Summarize this project – Quickly generate a high-level overview of the project, including tested areas, suite structure and understand the scope of each feature and its corresponding test coverage.
• Suggest test cases for a specific feature – Instantly generate relevant test cases based on a given feature name or description.
• Create a plan with 30 test cases for testing – Let the AI build a structured test plan with a detailed list of test cases tailored to your context.

These enhancements turn Chat with Tests into a smart assistant for planning, onboarding, and test gap analysis.

Run Summary Overview

We’ve introduced a Run Summary feature that provides a concise overview for every completed test run. This summary appears automatically once the run is finished and includes key details such as status breakdown, test duration, and overall test outcomes — helping teams quickly assess run results at a glance.

Expanded Drag-n-Drop for Tests, Suites, and Folders

We’ve enhanced the drag-n-drop functionality to make organizing your test structure more intuitive and efficient. You can now:

• Reorder tests directly within a suite using drag-n-drop in the side view.
• Move tests between suites by dragging them from an opened suite and dropping them into another suite in the project tree on the left panel.

This update streamlines test suite management, especially in larger projects with complex structures.

Fixes and Improvements 🛠️

• Optimized data processing for Requirements
• Improved 0Auth handling for Jira
• Improved UI for Company members page - updated styles
• Fixed test counter update after test Plan editing - no page refresh needed
• Improved operator IN for TQL - no errors when searching IN issue, state, status,created_by, etc
• Improved handling tests structure in manual run after adding/deleting tests and users
• Added substatus parameter to the reporter https://github.com/testomatio/reporter/issues/541

AI Agent: Write Descriptions from Code

We’ve introduced a new AI-powered feature that automatically generates descriptions for automated tests that currently lack them. The AI agent analyzes each test’s code and creates meaningful descriptions to improve readability and documentation across your project.

This significantly reduces the manual effort needed to document existing tests and helps teams quickly understand test coverage without digging into implementation details.

Use cases:

• Improving test documentation at scale: Automatically populate missing descriptions in large test repositories.
• Onboarding new team members: New testers or developers can better understand test purposes without reading through code.
• Maintaining traceability: Well-described tests improve coverage visibility and make it easier to link tests to requirements or defects.

AI Agent: Transform Project to BDD

With this new feature, you can now automatically convert an entire project to BDD using Gherkin syntax. The AI agent analyzes your existing automated tests and creates a new project with the same tests written in the BDD format.

This allows teams to adopt behavior-driven development practices without manually rewriting tests, saving significant time and ensuring consistency.

Use cases:

• Migrating to BDD workflows: Quickly shift to Gherkin-based testing without reauthoring test cases from scratch.
• Improving collaboration with non-technical stakeholders: Make tests more readable and accessible to product owners or business analysts.
• Standardizing test style across teams: Align legacy or mixed-format projects to a single, consistent BDD structure.

Confluence as a Requirement Source

You can now link your Confluence space to a Testomat.io project and use it as a source of requirements. Once connected, the system can analyze your Confluence pages to extract requirement descriptions, assess traceability, identify edge cases, and generate relevant test suites and test cases.

This integration bridges the gap between documentation and test planning, enabling seamless test coverage based on the requirements your teams already maintain.

AI-Powered Chat with Tests

We’ve reintroduced the Chat with Tests feature — an AI-powered assistant that allows you to ask questions about existing tests in your project. The AI analyzes your test repository and responds with insights, summaries, or clarifications based on the actual test content.

This interactive capability makes it easier to explore, understand, and manage large sets of tests without manually browsing through them.

Azure OpenAI Integration

You can now connect your Azure OpenAI account to power AI-driven features in Testomat.io using your own infrastructure. This integration enables your team to leverage advanced AI capabilities while staying compliant with internal security and data policies.

With Azure OpenAI connected, you can continue using Testomat.io's intelligent features, including:

• Generating test descriptions from code
• Suggesting test cases based on requirements
• Analyzing Confluence or Jira content for test coverage
• Explaining automation errors based on test execution data

Use cases:

• Enterprise-grade AI integration: Maintain control over data flow and comply with company-specific cloud policies.
• Secure, scalable AI usage: Run AI-driven features like requirement analysis and test generation through your Azure infrastructure.
• Custom AI behavior: Tailor AI responses and manage usage across teams with Azure monitoring and configuration options.

SCIM Integration (Enterprise)

We’ve added SCIM (System for Cross-domain Identity Management) integration, available for Enterprise clients. SCIM enables automated provisioning and de-provisioning of users and teams by syncing identity data from your identity provider. Now it's available for Okta.

This helps enterprise teams streamline user management, reduce manual work, and maintain secure access control at scale.

Use cases:

• Automated user lifecycle management: Add or remove users in Testomat.io automatically based on changes in your identity provider.
• Simplified onboarding and offboarding: Ensure new team members are assigned to the right projects and roles without manual configuration.
• Improved access governance: Keep your Testomat.io environment compliant and up to date with organizational structure.

Need help setting it up?
Contact our support team to enable SCIM and get assistance with integration.

Bulk User Management

Managing users at scale just got easier. On the Company Members page, you can now select multiple users and apply actions in bulk. This streamlines the process of updating access, roles, or project assignments across large teams.

Benefits:

• Mass role updates: Quickly promote multiple users to QA or downgrade access to Read-only with a single action.
• Efficient project onboarding: Assign multiple users to specific projects without repetitive manual steps.
• Simplified team management: Easily deactivate or reassign users in response to organizational changes.

This feature is especially useful for growing teams or enterprise accounts managing a large user base.

Fixes and Improvements 🛠️

• Published fix for WebdriverIO artifacts - use testomatio reporter 1.6.17 version
• Fixed publishing username when linking test or issues to Linear https://github.com/testomatio/app/issues/1341

💬 Comments for Test Cases

You can now add comments directly to individual test cases. This makes it easy to discuss details with your team, share context, and decide what actions to take next—whether to fix, update, or remove a test. Great for collaboration around flaky tests, unexpected failures, or test ownership questions.

Common use cases:

• Clarify why a test is failing (e.g., due to a known bug or environment issue)
• Ask a teammate for input on expected behavior
• Link to a related ticket or external discussion
• Leave a note about test setup or edge cases for future reference

🎯 Improved Test Status Icons

We’ve updated the icons that indicate a test’s status — whether it's manual, automated, or detached. The icons are now more consistent and clearly styled.
They’ve also been repositioned to appear right before the test title, making it easier to scan and identify the status at a glance.

🔁 Advanced Relaunch for Manual and Mixed Runs

Advanced relaunch is now available not only for automated runs, but also for manual and mixed runs.
This allows you to selectively relaunch failed or specific tests within any type of run, giving you more control and flexibility—no matter how the test execution was initiated.

✏️ Edit Steps Available Without Description

You can now use the Edit Steps feature even if a test case doesn't have a description yet.
Previously, this option was only accessible when the “Steps” heading was present in the description. Now, it's available directly from the extra menu, making it easier to add or update steps at any point in your workflow.

🛠️ Fixes and Improvements 🛠️

• Fixed rendering unordered list child items in markdown editor https://github.com/testomatio/app/issues/1098
• Fixed test content disappearance without saving in Block-based editor https://github.com/testomatio/app/issues/1317
• Improved user management for Manager role https://github.com/testomatio/app/issues/1322
• Added more visibility to AI features with clearer UI

Meta Information Support in Manual Test Execution

You can now add meta information during manual test runs using key-value pairs, enabling teams to capture execution context more precisely. Once the run is completed, this metadata appears in the Meta panel of the test result detail view. Example metadata you might include: Browser, OS, Release, Build, Network, Device, Screen Resolution, Special Conditions.

This enhancement supports better test documentation, result filtering, and post-execution analysis.

Split Suite View into Description and Tests Tabs

To improve usability, we’ve separated the suite detail view into two distinct tabs: Description and Tests. This change helps users better manage suites that contain extensive documentation or test cases.

• The Description tab displays the suite’s documentation and context.
• The Tests tab now exclusively lists the associated tests.

This separation makes it easier to navigate and edit large or content-heavy suites without losing focus.

Configurable View for Manual Test Execution

We’ve enhanced the manual test execution experience by adding the ability to customize the test list view. Users can now choose to show or hide labels and tags, making it easier to focus on the information that matters most during execution.

This flexibility helps reduce visual clutter or highlight specific metadata depending on your testing workflow. Simply toggle visibility options directly in the interface to tailor the view to your preferences.

Unified Sidebar for Labels and Custom Fields Management

We’ve updated the labels assignment interface by introducing a consistent sidebar view across all pages. Whether you’re managing labels or custom fields, you’ll now experience the same streamlined and intuitive interface throughout the platform.

This change ensures a more cohesive user experience and simplifies bulk updates and quick edits across plans, steps, runs, or test cases.

Fixes and Improvements 🛠️

• Added ability to assign labels from Run Report view
• Fixed error when trying to open test from Clusterize Errors https://github.com/testomatio/app/issues/1321
• Improved counters updating for Run Groups

AI-Powered Requirements

We’ve introduced AI-powered requirements analysis to streamline test coverage alignment with product requirements. When you link a Jira issue as a requirement in Testomat.io, the system will analyze the issue’s description and automatically suggest a structured requirement description. Based on the analysis, you’ll be offered two intelligent options:

• Generate a new test suite with suggested test cases
• Analyze existing suites and suggest test coverage improvements

This feature is available both at the project level and within individual test suites, enabling flexible, requirements-driven testing whether you’re planning at a high level or working in a focused domain.

Key benefits:

• Automates the transition from requirements to test cases
• Ensures traceability and alignment between business goals and test coverage
• Reduces manual effort and potential gaps in test planning

AI-Suggested Bug Description

To accelerate the defect reporting process, we’ve introduced AI-generated bug descriptions. When executing tests and creating a new defect, Testomat.io will automatically suggest a concise, context-aware bug title and a description. These suggestions are based on the test case content and its execution results, helping teams report issues faster and more consistently.

Why is this useful

• Speeding up defect logging: Testers can instantly use or refine AI-suggested bug details, reducing time spent writing repetitive or obvious issue reports.
• Maintaining consistent bug reporting standards: The AI helps standardize descriptions across team members, which improves clarity and communication with developers.
• Assisting less experienced testers: Junior team members or non-technical testers can rely on AI-generated suggestions as a starting point, ensuring important details aren’t missed.

Draft Support for BDD Scenarios

We’ve added the ability to save BDD Features and Scenarios as drafts, even when they contain syntax errors or typos. This feature was requested by users who needed more flexibility when writing or editing under time pressure. Previously, Testomat.io enforced strict BDD syntax validation, preventing users from saving incomplete or incorrect scenarios — now, you can save your work and return later to fix it.

Use cases:

• You're in the middle of writing a scenario but have to leave for a meeting — save your progress without losing your work.
• A teammate wants to jot down a test idea quickly but doesn’t have time to ensure the syntax is correct.
• You're experimenting with scenario structure and want to save a rough version before finalizing it later.

Please note: Only one draft is allowed per BDD Feature/Scenario at a time.

Advanced Relaunch Options for Automated Test Runs

Based on user feedback, we’ve expanded our CI integrations to allow more flexibility when relaunching tests. You can now select specific tests to relaunch, instead of repeating the full test run. This allows for more targeted, efficient workflows — whether you’re rerunning failed tests or just need to retest a subset of scenarios.

Key benefits:

• Customize relaunches to better fit your team's workflow
• Simplify recovery after CI failures or flaky test results
• Avoid redundant test executions and manual reconfiguration

How it works:

1. Open a completed automated test run
2. Click the Extra menu button
3. Select Advanced relaunch
4. In the sidebar, configure your relaunch (optional):
   • Enter a custom run title
   • Choose to create a new run (if needed)
   • Select specific tests to include
5. Click Relaunch

Expanded Attachments Capabilities

We’ve enhanced the ability to manage attachments across Testomat.io by allowing users to add attachments to suites, folders, and the readme section. This improvement helps streamline workflows by keeping all relevant files and documentation in one place. Whether you’re sharing important notes, reference materials, or test data, you can now attach them directly to the relevant test structures for easy access.

Use cases:

• Suite-level attachments: Attach detailed test execution reports or configuration files to specific test suites for easy reference by team members.
• Folder-level attachments: Add relevant project documentation or setup instructions to test folders, ensuring that all files related to a specific testing area are easily accessible.
• Readme section attachments: Include critical resources or additional context in the readme section, such as diagrams, code samples, or links to external resources, improving overall clarity for team members.

Test Creation During Manual Run Execution

We’ve added the ability to create new tests directly during a manual test run. This streamlines the process of capturing missing or newly discovered scenarios on the fly, without interrupting your testing flow. When a test is added this way, it is automatically saved to the appropriate suite in the test repository and immediately included in the current test plan.

If needed, this functionality can be disabled by selecting Hide Test Creation from the extra options menu above the test list.

Use cases:

• Identifying gaps in test coverage during execution: While performing manual testing, a tester discovers an untested scenario. They can instantly add it to the run and repository without switching context.
• Capturing exploratory test cases: Testers conducting exploratory testing can log and formalize new test cases as they go, ensuring useful insights are not lost.
• Collaborative test planning in real time: During team sessions or test reviews, testers can collectively identify and add new tests based on discussion or observed issues.

Export Run Reports to PDF

You can now export your test run results as a PDF report. This feature enables easy sharing and archiving of test outcomes outside of Testomat.io. After completing a run, simply open the extra options menu and select Export to PDF to generate a structured report with test execution details.

Use cases:

• Sharing results with stakeholders: Quickly generate a portable summary of test outcomes for product owners, QA managers, or external partners who may not have access to the platform.
• Audit and compliance documentation: Maintain a formal record of test results in a fixed format for compliance, certification, or audit purposes.
• Team retrospectives and reviews: Use the PDF report to review test coverage and outcomes during retrospectives or sprint reviews without relying on live access to the system.

Fixes and Improvements 🛠️

• Fixed issue links loss after runs merge https://github.com/testomatio/app/issues/1299
• Improved Jira links UI for bigger summary
• Fixed multiselection for Runs table view https://github.com/testomatio/app/issues/1243
• Improved handling NUnit tests https://github.com/testomatio/app/issues/1283, https://github.com/testomatio/app/issues/1279, https://github.com/testomatio/app/issues/1280
• Added Runs deletion and purge tracking in Pulse
• Added test parameters to Run Reports https://github.com/testomatio/app/issues/1262
• Fixed redirecting public Report link from Slack to login page instead of the run report https://github.com/testomatio/app/issues/1300
• Improved performance of adding/removing tags https://github.com/testomatio/app/issues/1247
• Improved Jira links UI by showing status and summary of linked defect