Building and maintaining automated tests has always been a challenge, especially when it comes to speed, coverage, and collaboration across technical and non-technical roles.

The release of Autonomous 2.2 helps teams reduce the time and effort needed to build and maintain reliable end-to-end tests. It combines LLM-generated test steps, automatic test data generation, built-in API validation, and visual comparisons across environments so that teams can find bugs earlier and release with more confidence.

API Step Builder: Visual API Testing, No Context Switching

Applitools Autonomous has always supported API testing, but with Autonomous 2.2, creating API tests is easier and more accessible than ever.

The new API Step Builder lets you build, run, debug, and update API calls with the UI, directly in your workflow—no code or external tools required.

• Paste in raw cURL or HTTP
• Translate into readable test steps
• Add headers, cookies, auth, body, and parameters visually
• Chain responses into UI steps via variables

Supported Features:

• Full HTTP method support: GET, POST, PUT, PATCH, DELETE, etc.
• Built-in request fields for headers, cookies, authorization, body, and URL params
• Dynamic variables: Ex. use {response.body.token} or {response.body.name} like variables in downstream steps
• Support for raw cURL or HTTP input with automatic translation to English-readable steps

Whether you’re preparing state, validating backend responses, or asserting API behavior, you can now do it all in one place—with a clean, intuitive UI that works just like the rest of Autonomous.

LLM Generated Test Steps: From Business Logic to Automation in Seconds

Write test steps the way you think—in plain English. With LLM Generated Test Steps, you can simply describe your business logic (e.g., “Select Ohio from the state dropdown menu”) and Autonomous will convert it into executable steps.

Let’s say you’re testing a job application page. Instead of clicking through each form field manually, you simply type:

Submit the form as an obscure Tolkien character

Autonomous analyzes the rendered page in real-time, understands the structure and semantics, and breaks down that one line into multiple actionable steps, such as:

• Typing the name and email address
• Selecting an appropriate option from dropdown menus
• Clicking the “Submit” button

The result? A complete, readable, and editable test created in seconds—no coding, no selectors, no extra UI to learn.

Perfect for:

• Speeding up test creation during sprints
• Empowering manual testers to create automated tests
• Eliminating writer’s block in test authoring

Join our Platform Pulse webinar on July 24 to see Autonomous 2.2 in action

Test Data Generation: Realistic Input with Zero Effort

Test coverage is only as good as the data behind it. Autonomous 2.2 introduces natural language–based test data generation that instantly produces realistic data at runtime, helping with edge case coverage and state variability.

Just say what you need:

Submit the form using random data for 90’s TV dads

Autonomous parses your request, uses LLMs to create diverse, high-quality data, and injects it directly into your test. Each run can generate fresh values—so no two executions are the same.

Cross-Environment Visual Comparisons: One Baseline, Many Environments

Ensuring parity across environments—staging vs. prod, dev vs. QA—or locales is critical. Parameterized visual baselines allow test engineers to define and run tests using variable data while still maintaining deterministic baseline comparison.

For example, you can run the same test in different plans—one with {env}=integration, another with {env}=staging—and compare visual differences across each environment without changing a single line of test logic.

• Parameters and datasets handled automatically
• Custom flows and URL List tests supported
• Visual baselines set per unique parameter set
• Abort prevention and value prompts to ensure test validity

Parameter handling is enforced at both test and plan levels—tests abort cleanly if required values are missing, ensuring reliable execution outcomes.

Tunneling Enhancements: Instant Feedback, Zero Guesswork

Tunneling just got easier and more reliable. With tunneling enhancements, Applitools Autonomous now includes improved diagnostics, real-time tunnel status, actionable error codes, and visibility for team admins—not just account owners

Users now get real-time diagnostics:

• Is the tunnel connected?
• Which hosts is it routing?
• Are there errors, and what do they mean?

Admins now get access to error codes, logs, host mapping, and verification checks—all without reaching out to support.

The Bottom Line

Applitools Autonomous 2.2 turns plain English into production-grade automation. Whether you’re testing UI, APIs, internal systems, or staging vs. production, it removes friction that slows QA teams down.

Explore the new features in the product documentation or dive into Autonomous with a free trial.

Quick Answers

The post Applitools Autonomous 2.2: AI-Driven Testing That Thinks Like You appeared first on AI-Powered End-to-End Testing | Applitools.

TL;DR — Applitools brings visual, functional, and autonomous testing together in a single AI-powered platform. Backed by 11+ years of refinement and a dataset of 4 billion real-world images, our Visual AI delivers unmatched accuracy and reliability for enterprise-grade software testing.

Testing today isn’t just about coverage—it’s about confidence, speed, and scaling quality across teams. Whether you’re a developer chasing faster feedback, a QA lead reducing maintenance overhead, or a product owner focused on release velocity, Applitools helps modern teams deliver software that looks right, works right, and evolves with ease.

Here’s how Visual, Functional, and Autonomous Testing all come together in one powerful platform.

Trusted Visual AI with Proven Accuracy

Applitools sets the standard in Visual Testing. Our Visual AI engine delivers 99.9999% accuracy, eliminating false positives and catching bugs others miss.

• 5.8x more efficient than pixel-based tools
• Detect both functional and visual bugs in a single test
• Works with all major frameworks: Selenium, Cypress, Playwright, and more

We didn’t just add AI—we’ve spent 11+ years perfecting it.

A Complete Platform for End-to-End Testing

Applitools goes far beyond screenshots. Our Intelligent Testing Platform includes Autonomous Test Creation, Visual Validation, Cross-Browser + Device Testing, and Accessibility Testing—all in one cloud-based solution.

• Run tests across browsers, devices, and screen sizes in parallel
• Built-in accessibility and compliance testing
• Fully scalable with enterprise-grade performance

Less Test Maintenance with Self-Healing, Smart Grouping & Predictive Analytics

Spend less time fixing broken tests and more time delivering value. Applitools minimizes test upkeep so your team can focus on building.

• Self-healing locators reduce test flakiness and manual updates
• Root cause analysis, smart grouping, and predictive analytics streamline debugging
• Tests automatically adapt as your UI evolves—no babysitting required

Collaborative Testing: How Developers, PMs, Designers & Marketers All Work Smarter with Applitools

Testing shouldn’t be a bottleneck—or limited to just QA. Applitools empowers developers, designers, product managers, and even marketers to collaborate with ease.

• Intuitive UI for reviewing results and managing baselines
• Seamless sharing of results and issue tracking
• Codeless and code-based authoring, no deep technical expertise needed

More than a Decade of AI Leadership

AI isn’t new to us—it’s the foundation of our platform. Unlike newer tools making AI promises, we’ve been building, training, and refining Visual AI to solve real testing challenges at scale for more than a decade.

• Mature, battle-tested AI that improves with scale
• Trusted by engineering teams at Microsoft, Tesla, Salesforce, eBay, and 400+ more
• Over 1 billion visual tests run with our platform

Seamless Integrations & Dev Experience

Great testing fits into your workflow—not the other way around. Our AI-powered test automation works with your tools, languages, and CI/CD pipelines to scale quality without slowing you down. Applitools integrates with:

• Every major framework: Selenium, Cypress, Playwright, Puppeteer, WebdriverIO
• CI/CD tools: GitHub Actions, Jenkins, GitLab, Azure DevOps
• SDKs for Java, JavaScript, Python, C#, and more

Whether you’re in code or no-code workflows, we plug into your stack and scale with you.

24/7 Support That Doesn’t Disappear

Whether you’re mid-sprint or troubleshooting a release, help is always within reach. Get expert guidance anytime—no hoops, no waiting.

• Around-the-clock global technical support
• Extensive documentation, how-tos, and real-time guidance
• Active community forum and dedicated Customer Success Managers (not just for enterprise)

Compare that to competitors with limited support, slow response times, or no dedicated resources unless you’re a top-tier customer.

Smart Investment, Real Value

Our pricing is flexible, predictable, and scales with your needs. You’ll see ROI fast:

• Save hours of test maintenance per sprint
• Eliminate manual bug hunts and false positives
• Deliver faster releases without compromising quality

Explore our current pricing structure, or speak with a testing specialist to build a package that’s right for your team.

“We reduced our testing time from days to hours. Applitools changed how we think about QA.”
— QA Lead, Global Retail Brand

Visual, Functional, and Autonomous Testing—The Applitools Advantage

We combine Visual AI, Autonomous Testing, and a developer-friendly platform into one powerful, scalable solution. With Applitools, your team gets:

• Smarter test creation
• Less maintenance
• Better collaboration
• Faster releases
• And trusted results every time

See What’s New with Applitools Autonomous and What’s Coming with Applitools Eyes

Ready to Test Smarter?

In a crowded automation landscape, it’s not enough to have “AI-powered” features. You need real results. With over a billion visual tests run and trusted by leading enterprises across industries, Applitools isn’t experimenting with AI—it’s already delivering.

Whether you’re starting fresh or looking to scale smarter, Applitools gives your team the tools to automate with confidence and speed.

Ready to see it in action? Start your free trial, book a personalized demo, or explore the platform today.

Applitools helps you test like it’s 2025. Join the world’s top teams already doing it.

The post Visual, Functional, and Autonomous Testing—All in One appeared first on AI-Powered End-to-End Testing | Applitools.

Testing workflows just got an upgrade! Autonomous 2.1 simplifies end-to-end testing by offering faster test creation and maintenance while expanding mobile support. This release focuses on improving the efficiency and flexibility of your testing processes with features designed to simplify workflows, enhance modularity, and provide greater control.

Let’s explore the highlights of this release and how they can benefit your end-to-end testing. 

Key Features in Autonomous 2.1

Modular Test Design

Create a test once and reuse it across multiple workflows, eliminating the need to duplicate steps. This not only saves time but also ensures consistency and reduces the risk of errors. By enhancing reusability, this feature significantly accelerates test creation and simplifies maintenance, particularly for workflows shared across teams.

Use case example: Faster test authoring in Banking

For financial institutions, reusing a shared “User Login” test across workflows like “Fund Transfer,” “Loan Application,” and “Account Overview” simplifies test maintenance and ensures consistency. Autonomous 2.1 empowers teams to avoid recreating login steps for each flow, saving time and enhancing reliability.

Simplify Test Maintenance

Easily modularize your testing process by extracting repeated steps into standalone tests. This feature simplifies maintenance and improves by allowing your team to maintain one test and apply those updates to wherever you may be reusing extracted test flows. With fewer errors and a more streamlined test design, your team can focus on delivering quality faster.

Learn how to build no-code, autonomous end-to-end tests and explore some of these new features in our upcoming webinar, Building No-Code Autonomous End-End Tests

Record Assertions

Record assertions directly within your tests to ensure critical content is displayed accurately, without requiring manual scripting. This capability is especially valuable for localization efforts, enabling teams to validate translated content on multilingual websites. By reducing setup complexity, testers can achieve faster and more accurate validations.

Use case example: Maintain compliance with localization

On multilingual websites, recording assertions ensures translated content (e.g., terms and conditions, error messages) is displayed correctly. This is crucial for maintaining legal compliance and providing a seamless user experience in different languages.

Make Responsive Testing Easier

Ensure cross-device compatibility by configuring display viewport sizes—such as mobile, tablet, or even a custom size—directly in your custom flow tests. This ensures accurate validations across devices, making it ideal for e-commerce businesses and other industries prioritizing multi-device compatibility. Streamlining these configurations reduces setup time and ensures your users have a seamless experience across platforms and devices.

Pro tip: While Applitools Ultrafast Grid lets you run the same test across multiple browsers and devices, we recommend creating separate tests for specific screen sizes when unique screen elements, like a hamburger menu, appear only on certain viewports.

Flexibility in Test Configuration

We’ve decoupled the application and plan from individual tests, offering greater flexibility and a more intuitive workflow for configuring tests independently. You can now run tests ad-hoc—even trigger test execution via the REST API—and configure run properties like parameters, browsers, devices, and concurrency limits. This change not only enhances the user experience but also lays the groundwork for advanced capabilities in future releases, ensuring a scalable and adaptable testing environment.

And There’s More…

Autonomous 2.1 lets you navigate more intuitively with an updated interface reflecting application hierarchy and copy tests across applications while preserving reusable flows. For added security, sensitive test data like passwords is now encrypted and masked, and TOTP support for 2FA enables secure workflows with Time-Based One-Time Passwords.

Try Autonomous 2.1 for Free With Your Team

With Autonomous 2.1, you’ll experience faster test creation and simplified maintenance, particularly for workflows reused across multiple teams or applications. This release represents a significant step toward more efficient, scalable, and user-friendly testing processes.

Try out Autonomous 2.1 for free with your team and see how it can revolutionize your testing efforts.

The post Introducing Autonomous 2.1: Speed Up Testing with Modular Test Design appeared first on AI-Powered End-to-End Testing | Applitools.

Efficient, reliable visual testing is essential for teams working with Playwright. Applitools’ updated Playwright SDK simplifies integration, reduces setup time, and offers more powerful reporting. Let’s check out the new features and how they streamline your testing.

What’s New in Applitools Playwright SDK?

The updated SDK introduces improvements that let you set up and run visual tests more efficiently:

• Test Fixtures: Minimizes repetitive setup code
• CLI Onboarding: A new CLI that speeds up initial setup, and an example Visual AI test
• Config Object Setup: Auto-inserts Eyes configuration in playwright.config.js/ts
• Custom HTML Reporter: Extends Playwright’s report to include Eyes checkpoint images

Join the Playwright Visual Testing Best Practices webinar led by software architect and international speaker Cory House. Discover best practices for visual testing in Playwright to enhance UI consistency, swiftly resolve issues, and ensure seamless user experiences across platforms.

Using Test Fixtures for Simplified Visual Testing

Test fixtures streamline visual testing by automating many of the functions necessary for setup. The SDK now automatically handles Eyes.open() and Eyes.close() functions as well as the collection of all test results. With these automatic integrations, you can focus directly on creating test cases without the need for redundant code.

Enhanced Reporting with the Custom HTML Reporter

The HTML reporter is designed to make analyzing test results more intuitive. It integrates Eyes checkpoint images directly into Playwright’s report. You can approve or reject baselines all within the report without having to navigate to the Eyes dashboard. This enhanced reporting setup provides clear visual insights that make it easy to understand test outcomes without extra steps.

Advanced API Usage for Custom Testing

The SDK also supports advanced API usage for complex testing needs. This lets you create custom configurations and expand test cases for specific UI components. As your project grows, this flexibility enables you to scale visual tests seamlessly and ensure thorough visual validation across different scenarios.

Backward Compatibility and Migration Tips

The SDK also maintains backward compatibility, making it easy to transition from the previous SDK while retaining existing configurations. You are welcome to start running a few tests in both SDKs to verify functionality and gradually implement the new SDK on simpler tests before migrating critical ones.

Getting Started with the Playwright SDK

Getting started with the SDK is straightforward. First, install the SDK with npm install @applitools/eyes-playwright. Next, use the CLI tool to enter your API key with npx eyes-playwright setup, automatically updating the environment. The SDK sets up configurations and imports for you, even adding a Visual AI demo test in Applitools Eyes that you can execute right away.

The latest Applitools Playwright SDK provides a faster, simpler, and more insightful visual testing experience. Download the SDK, try the demo test, and see firsthand how it can enhance your Playwright testing workflow.

The post How to Use the Updated Applitools’ Playwright SDK for Efficient Visual Testing appeared first on AI-Powered End-to-End Testing | Applitools.

Applitools knows that you know how crucial it is to deliver flawless user experiences without spending time managing unnecessary test failures or constant updates. 

The latest Applitools Eyes release introduces new features designed to make your visual testing more efficient and faster. These features will make it easier to manage your tests, reduce manual intervention, and improve your test coverage–whether you’re part of a QA team, a developer, or a test engineer. 

Let’s dive into the top three features of Applitools Eyes 10.20.

Dynamic Match Level

Smart Handling of Variations

With Applitools Eyes 10.20, managing visual test results just got easier thanks to the new dynamic match level. This feature allows users to specify certain patterns—like dates, numbers, or email addresses—that can change without triggering test failures. It identifies specific text patterns that commonly vary, such as timestamps or transaction IDs, and ignores them during test execution.

By default, the system provides patterns like dates, phone numbers, and currency values, but users can also create custom patterns using RegEx. This level of flexibility is especially beneficial for those of you dealing with extremely dynamic content, such as real-time stock market data or dynamic ad targeting, where some elements should not cause a test to fail.

Example Use Case: Insurance policy numbers often follow specific formats but vary between users or transactions. During visual testing, these dynamically generated numbers can trigger false positives. With the new dynamic match level, you can now ignore the variability in policy numbers while still validating the rest of the content and UI.

For instance, a health insurance company has an online portal where customers can view their policies. Each policy is identified by a unique policy number formatted as “POL-XX-YYY” where “XX” and “YYY” are randomly generated for each customer. Testing tools that cannot handle identifying content patterns would cause visual tests to fail unnecessarily every time the policy number changes. However, using Dynamic Match Level lets this health insurance company’s visual testing ignore the “POL-XX-YYY” format in tests ensuring the system validates only significant UI changes.

Dynamic Region Selection

Precision with Less Effort

In addition to manually drawing regions, visual validation can now be anchored directly to DOM elements. As the page content changes now, Applitools Eyes adapts the validation region, ensuring tests don’t break due to layout shifts or content variations. Dynamic region selection allows you to set visual test regions by simply selecting elements on a web page instead of manually drawing regions, saving you time and improving accuracy.

The new dynamic method uses the underlying DOM structure, allowing for automatic region adjustments as the page content changes. If the layout or size of the elements shift, Applitools Eyes automatically adapts to the change without breaking the tests.

Why it matters: This feature is particularly useful for those of you who have apps with extremely dynamic content, where visual elements often change. Enterprise SaaS to media outlets will see the benefits of using dynamic region selection since they no longer have to worry about small shifts in UI elements, reducing the need for constant manual updates and cutting down test maintenance time significantly.

Insights Dashboards

Quantify Your Testing Success

One of the more analytical features added to Applitools Eyes 10.20 is the new Insights Dashboards for testing ROI, which provide insights into the effectiveness of your automated maintenance efforts. These dashboards display critical data on how much time you’ve saved using Applitools’ automated visual testing and maintenance tools.

The dashboards break down the number of visual validation results automatically accepted by Applitools and track the time saved through automated maintenance. This is based on the assumption that manually reviewing a page takes about two and a half minutes. By quantifying this, the dashboard helps you understand the real-world impact of automating your visual testing workflow.

Pro tip: With Insights Dashboards, you can highlight specific wins, such as reducing manual test reviews or cutting test maintenance time. If you notice test maintenance time decreasing steadily, it’s a good sign your visual testing strategy is becoming more efficient. This data can be shared during quarterly business reviews with leadership or when advocating for further automation resources.

Additional Improvements

The 10.20 release also introduces faster load times on the “Tests Requiring Attention” page—especially beneficial for teams working with large test suites. The enhanced GitHub integration means you can track baseline merges directly within the baseline history page, minimizing manual effort and improving workflow efficiency. Visit the Applitools Eyes 10.20 release notes to see everything that’s included.

To Wrap Up…

One of the biggest hurdles in the day-to-day work for anyone involved in QA is dealing with flaky tests caused by constantly changing text, like dates or order numbers, and shifting UI elements, like buttons that move slightly depending on screen size. Your users expect flawless experiences. 

The Applitools Eyes 10.20 release is packed with features that simplify and streamline the visual testing process, from dynamic region selection to enhanced match levels and improved performance. These updates will help your team reduce manual test maintenance, increase test coverage, and measure the ROI of your testing efforts more effectively. Whether you’re managing complex web applications or handling high volumes of test data, these features are designed to make your workflow faster and more efficient.

The post Easier Test Maintenance for Dynamic Content with Applitools Eyes 10.20 appeared first on AI-Powered End-to-End Testing | Applitools.

We’re excited to announce a major upgrade to the Applitools Intelligent Testing Platform: Autonomous 2.0! Packed with powerful new features and enhancements, Autonomous 2.0 enables any team member – regardless of coding skills – to create, execute, and analyze automated tests.

One of our goals with our AI-powered end-to-end testing platform is to provide a flexible test authoring experience that ranges from fully autonomous to describing steps in plain English with AI assistance to no-code recording to coding in your preferred language and framework. This gives your teams the most comprehensive test creation options of any tool on the market while enabling them to leverage any existing tests and automation they’ve built out. We believe utilizing AI in test creation, validation, maintenance, and analysis is the only way to maximize test coverage for complex, modern apps and keep pace with new code deployments – especially now with AI coding assistants.

Autonomous 2.0 is delivering on that goal in a way that no other AI-powered testing platform can: by combining new GenAI technology and proven no-code approaches with our own Visual AI that we’ve iterated on for over 10 years and trained with over 4 billion application images. It’s proven AI testing technology that’s been catching and pinpointing visual and functional bugs for our customers for years. Add in self-healing and ultrafast, stable execution over thousands of combinations of browsers, devices, and screen sizes, and you see why Applitools Intelligent Testing Platform is unmatched in AI-powered end-to-end testing.

What’s New in Autonomous 2.0?

AI-Assisted Interactive Custom Flow Authoring

With AI-assisted interactive custom flow authoring, you can write test steps in plain English, record them in an interactive browser, and debug in real-time – all on the same screen (no browser extension needed). Test steps are output in plain English that can be edited later, and all written steps are checked by our  auto-correcting language model, ensuring smooth, efficient test authoring without the hassle of syntax errors.

Expanded Functional and API Testing Capabilities

Everything you can do with coded tests can now be done by describing the test steps in plain English. That includes Visual AI assertions, comprehensive functional assertions, HTTP request initiations, and effortless dynamic data handling. This upgrade significantly boosts your functional and API testing capabilities, all without having to write a single line of code.

Easier Results Analysis and Test Maintenance

Analyzing test results and maintaining tests is now easier than ever. Our improved UX provides a seamless experience, from high-level analysis of complete test plans to detailed breakdowns of individual test steps. Plus, our platform automatically adjusts baseline regions following application changes, reducing the need for manual adjustments.

Feature Highlights of Autonomous 2.0

Interactive Custom Flow Test Authoring

• No-Code Test Authoring: Record UI interactions in an interactive browser and describe them in plain English.
• Real-Time Debugging: Identify and fix issues on the fly with our interactive debugging tool.
• No Local Installation: Author and debug tests on the same infrastructure they’ll execute on.

Language Model Enhancements

• Auto-Correct and Simplify: Our language model auto-corrects and simplifies step descriptions for better readability and consistency.
• Break Down Complex Commands: Simplifies complex commands into more manageable steps.

Functional Data Assertions

• Verify Dynamic Data: Combine visual and functional assertions (non-visual) to verify text, numeric values, element visibility, and more.
• Boolean Operators: Use logical operators to create more robust test conditions.

API Call Initiation

• HTTP Requests: Initiate HTTP requests with custom headers and cookies, and store responses for use in later test steps.
• Application State Management: Reset application states before or after test execution without complex UI flows.

Enhanced Results Review Experience

• Improved UX: Enjoy an interactive summary of test statuses, detailed issue breakdowns, visual diffs, and more.

Ready for an AI-assisted testing challenge?

We’re confident that Autonomous can enable any of your team members to create, execute, and analyze tests. Don’t believe us? Have any member of your team who doesn’t write automated tests today sign up for a free trial of Autonomous (e.g. manual testers, designers, product owners, business analysts), and see what they can contribute to your test coverage. Guaranteed you’ll be amazed!

The post Autonomous 2.0 is here! AI-Assisted Interactive Authoring and More appeared first on AI-Powered End-to-End Testing | Applitools.

We recently announced the launch of the Applitools Intelligent Testing Platform. Comprised of three powerful solutions – Autonomous and Eyes – our platform redefines the future of AI-powered test automation.

Alex Berry, Applitools CEO, sat down with Alan Shimel of TechStrong TV to share more about the Applitools Intelligent Testing Platform and what drove him to join the company as CEO last year. Most notably? Alex was drawn to the strength of our vision and mission to create an end-to-end testing platform and his belief that our technology can be a game-changer in the test automation market.

As for the Intelligent Testing Platform, Alex notes that unlike traditional testing providers where you have to be a developer with advanced coding skills to use their tool – our latest offering, Autonomous, opens up the opportunity for greater collaboration and opens up testing to a new cohort of users like marketing, finance, security, etc. that may not be as tech-savvy.

Learn more about Alex and the latest from Applitools by watching the full interview:

The post NLP-Driven Test Automation with Applitools’ Alex Berry | Techstrong Interview appeared first on AI-Powered End-to-End Testing | Applitools.