Manually reproducing issues slows everyone down—so we re-imagined the process, making it effortless and delightfully fast.

How It Works Simply describe the bug—like "Incorrect phone number in sign up doesn't give a validation message" or "No email when trying to reset password"—and let our AI take care of the rest.

1. Analysis: The AI carefully reviews your bug description, checking it against existing tests and your project-specific context.
2. Test Generation: It then automatically creates the perfect test case tailored precisely to reproduce your bug.
3. Execution Plan: Finally, the AI builds a smart testing plan, determining exactly what's needed—such as login credentials, specific navigation steps, or special conditions—to successfully replicate the issue.

Say goodbye to repetitive bug reproductions. With our AI-powered approach, finding and fixing issues is faster, simpler, and more efficient.

Consistent Testing Across Every Screen Size

Our customers told us testing applications across various device screens can be cumbersome—so we simplified it. Introducing Device Presets, a streamlined way to manage device-specific testing effortlessly.

Why it matters:

• Accurate Device Simulation: Quickly test your app with common presets for desktop, tablet, and mobile—complete with resolution, user agent, locale, timezone, and custom headers.
• Simple Prioritization: Device presets automatically follow a clear hierarchy—from test case revisions, through test cases and test plans, down to your project defaults.
• Centralized Management: Create, customize, and manage your presets directly from your project settings. Keep consistency across your tests while maintaining flexibility.

Preset Highlights:

• Easily select from popular resolutions like 1280×800 (desktop), 768×1024 (tablet), or 375×667 (mobile).
• Customizable locale, timezone, and HTTP headers—no more juggling manual settings for different scenarios.
• Built-in defaults and clear restrictions ensure optimal test execution speed and reliability.

Testing with different device viewports is now as simple as selecting your preset—ensuring your applications deliver a flawless experience on every screen, every time.

Understanding complex test setups can be challenging, especially when tests share browser states and pass information between each other. With this update, we've made it simple to visualize test dependencies and interactions clearly.

How It Works

• Visualize Dependencies: Click on the new graph icon in any previous test result to instantly see a graphical representation of your test's dependency structure.
• Easier Maintenance: Quickly identify dependencies between tests, enabling streamlined updates and efficient troubleshooting.
• Enhanced Understanding: Clearly view how browser states and data are reused and passed between test cases, offering deeper insights into your test flows.

Simply navigate to a test result and click on the graph menu to explore your test dependencies visually.

We've introduced a new feature that lets you preview how your changes would impact the AI agent directly within the edit view. This allows you to quickly retry specific steps without needing to rerun the entire test, saving significant time during debugging and refinement.

How It Works:

• If the AI agent clicks the wrong button or takes an unintended action, simply update your test instructions.
• Use the new "Preview" button in the tracer panel to instantly see what the agent would do differently based on your updated instructions.

Important Note:

• The preview shows the intended action but doesn't actually replay it on the website. This means you'll see precisely what the agent plans to do, but it won't perform the action again live.

Find this feature in the tracer panel within the edit view.

We've introduced a new feature that lets you easily rerun a test along with all its dependencies directly from the test edit view. In situations where running a single test isn't sufficient—such as needing to recreate an item before deleting it—you can now use the "Run w. Dependencies" button. Normally we use the latest execution of the dependency as starting point.

How it Works:

• Convenient Execution: Click "Run w. Dependencies" from the test edit view to automatically execute the current test and all the tests it depends on.
• Ensures Proper Setup: Useful in scenarios where prior tests, like item creation, must be executed first to ensure accurate results for dependent tests, like item deletion.

This enhancement streamlines testing workflows, reducing manual steps and ensuring your tests run in the correct context every time.

Debugging automated tests often involves understanding exactly what data the AI agent is processing. To simplify this, we've enhanced the tracer to show all the data the agent receives—including the current page and agent context - providing clearer visibility into what's happening during test execution.

How It Works

• Complete Visibility: Easily view the exact data being provided to the AI agent, including:
  • Page Data: See exactly what the agent sees on the webpage during each test step.
  • Agent Context: Access insights into the agent's current understanding and state.
• Simplified Debugging: Quickly pinpoint issues and validate data inputs, making it easier to refine test goals and steps.
• Improved Goal Clarity: Understand exactly what data is available for reference, enabling more precise and effective test scripting.

Getting Started

Access these enhanced details directly from your tracer view during any test run. Simply expand the tracer panel to view the complete data provided to your agent.

Now you can add a QA.tech status badge directly to your GitHub README to quickly display the status of your automated tests. The badge clearly indicates whether tests are passing or failing and provides insight into when the last test run occurred. This helps your team easily monitor test health at a glance, streamlining development workflows and improving visibility.

How It Works:

• Live Status: Instantly shows if your tests are passing or failing.
• Recent Activity: Includes a timestamp to indicate when tests were last executed.
• Easy Integration: Quickly add badges with a simple markdown snippet directly into your README.

You find all the instructions you need on Settings -> Integrations

When debugging test automation, tracking events across a full test session can be overwhelming, especially when identifying exactly which actions correspond to each step. With our improved network and console logging, you now have crystal-clear visibility into the flow of events, making it significantly simpler and quicker to pinpoint issues.

How It Works

• Full Session Visibility:
  Easily view network and console events from the entire test session in one comprehensive log, giving you context and continuity.
• Current Step Highlighting:
  Events associated with the currently executed step are distinctly highlighted, letting you instantly spot the relevant actions and responses.
• Future Steps Greyed Out:
  Upcoming events for future steps appear greyed out, keeping your focus firmly on the present step without distractions.

Benefits

• Rapidly locate problematic events, speeding up debugging.
• Clearly distinguish between current, previous, and upcoming actions.
• Effortlessly maintain context as you navigate through test execution logs.

This update makes debugging test automation smoother and more intuitive, allowing you to efficiently zero in on the exact points of interest without getting lost in the noise.

It's frustrating when your automated tests fail because the AI agent misses elements it should interact with. To solve this, we've introduced a simple way to visually confirm exactly what elements your agent sees and can interact with on your site.

How It Works

• Visual Highlights: Simply click the eye icon in the tracer to instantly highlight all interactive elements on the page that the AI agent recognizes.
• Real-Time Debugging: Quickly identify elements the agent might have missed or overlooked, making debugging faster and simpler.
• Under the Hood: We extract these interactive elements using some JavaScript magic combined with precise HTML parsing, ensuring accurate representation of your site's interactivity.

When to Use This

• You're unsure if a button or input field was properly identified.
• The agent misses an important action during test execution.
• You want a quick visual sanity check for complex UI interactions.

Try it out now and see exactly how your AI agent views your site. Debugging interactive tests just got simpler!

Introduced a new feature that tracks all changes made to test cases over time—test steps and configurations. Teams can now review who made changes, when they were made, and what was changed. This addition ensures a complete audit trail for each test and offers a simple way to restore previous versions if needed.

Key Highlights:
• Comprehensive Change Tracking: Every update to a test—be it step revisions, data tweaks, or configuration swaps—is recorded in a historical log.
• Auditable History: View contributor names and timestamps on test modifications. Great for collaboration and accountability.
• Enhanced Collaboration: Teams get deeper insights into when, how, and why a test evolved, creating transparency and reducing test maintenance overhead.

This feature is accessible from the test's detail page, where you'll find a "History" clock icon that provides a chronological list of versions and their modifications.