Compare Desktop and enterprise GUI tools

    AskUI vs Tricentis Tosca

    Model-based test automation with Tosca or agentic test automation with AskUI: what a test is made of, who writes it and what happens when the UI changes.

    Tricentis Tosca · by Tricentis

    What it is.

    Tosca is a model-based, scriptless test automation tool. XScan reads the application's controls into reusable Modules, and testers compose test cases from them. Tricentis Agentic Test Automation writes such test cases from natural language, and Vision AI recognizes controls from the image, for example on remote desktops.

    Where Tricentis Tosca is strong

    • Prebuilt models for around 200 ERP and packaged applications, such as SAP, Oracle and Workday.
    • A large enterprise install base and a broad partner ecosystem.
    • Test management, data and risk-based testing in one platform.

    Two approaches

    Model first.
    Or intent first.

    Both automate the same test case. They differ in what a test is made of, and in who has to know what.

    Model-based test automation

    The test is built on a model of the application.

    The tool scans the user interface and stores each screen as a model: its controls and the technical properties that identify them. Testers compose test cases from these models and set what each value does, for example input or verify. At run time, the engine finds each control by its properties and does exactly what the step says.

    Strong when the application is stable, its technology is supported and the same flows run thousands of times.

    Agentic test automation

    The test is the requirement, in plain language.

    There is no model of the application. At run time, an agent built on a large language model looks at the screen, decides the next action, does it and checks the result against the expected result. What the team knows about the application, for example its terms and what counts as correct, is written down as reviewable rules in Cortex.

    Strong when tests start from requirements, the UI changes often or there is no control tree to scan.

    One requirement, two tests

    Same requirement.
    Different work.

    REQ-112 A clerk creates an invoice for customer 4711. The total includes 19% VAT.

    Model-based Tricentis Tosca

    1. 01
      Scan

      XScan reads the invoice screen. Tosca stores it as the Module “Invoice” with the controls Customer, Amount and Total.

    2. 02
      Design

      A test case is built from the Module. Customer = 4711 (Input), Amount = 100 (Input), Total = 119.00 (Verify).

    3. 03
      Run

      The engine finds each control by its technical properties and steers it exactly as designed.

    4. 04
      UI changes

      If a control's properties change, someone updates the Module. Every test case that uses it follows.

    Agentic AskUI

    1. 01
      Write

      “Create an invoice for customer 4711 with amount 100. Expected: the total shows 119.00.”

    2. 02
      Run

      The agent looks at the screen, finds the fields, types the values and reads the total.

    3. 03
      Check

      A verdict per step: expected and actual result, a screenshot and the agent's reasoning.

    4. 04
      UI changes

      The step still describes the intent, so a moved field needs no update. If the meaning changes, you edit a sentence.

    Simplified. Tosca terms from the Tosca 2026.1 documentation: Modules, XScan, ActionModes.

    Who needs to know what

    Tool knowledge,
    or test knowledge.

    With a model-based tool, automation is a specialist skill. With an agent, the person who knows the requirement writes the test.

    Skills needed for model-based and agentic test automation.
    TaskModel-basedTricentis ToscaAgenticAskUI
    To write a testKnowledge of Modules, ActionModes, buffers and test case design in Tosca Commander.Knowledge of the requirement and the application. Steps in plain language.
    When the UI changesRescan or edit the Module. One change updates every test case built on it.Usually nothing. Dreaming proposes edits to steps and rules for review.
    To read a failureThe step, and the control that was not found or the value that did not match.A report with a screenshot, the expected and actual result and the agent's reasoning per step.
    TrainingTricentis Academy runs role-based learning paths, for example Automation Specialist, that end in a certification exam.None to write tests. A technical person sets up devices, custom tools and Cortex rules once.

    Tosca has agents too

    Write the test,
    or run it.

    Tricentis Agentic Test Automation writes Tosca test cases from a natural-language description. The result is a model-based test case, and Tosca's engine runs it. The AI works at design time.

    In AskUI, the agent runs the test itself. There is no generated script or model in between. The AI works at run time, on every step.

    The trade-off, plainly

    • A model-based run is deterministic and fast per step. An agentic step is a model call and takes seconds.
    • An agent's decisions can vary between runs. AskUI limits this with two attempts per step, In-Flight Guidance and a report for every step.
    • A model needs upkeep when the UI changes. An agent needs clear steps and expected results.
    • Many teams use both: models for large, stable packaged apps, the agent for the screens and tests around them.

    Side by side

    How they work.

    Architecture, not adjectives.

    Tricentis Tosca compared with AskUI across 9 questions.
    QuestionTricentis Toscaby TricentisAskUIComputer-use agent
    How a test finds the UITechnical models of the application, built by scanning its UI controls.An agent reads the screen like a tester does. No selectors, no object repository, no recordings.
    How tests are writtenScriptless: tests are composed from modules in the Tosca workspace.Plain language. Your manual test cases, often written from requirements.
    SurfacesWeb, desktop, mobile, APIs and packaged enterprise applications.Desktop and remote computers, web browsers, Android emulators and phones, iOS simulators, several computers in one test, and embedded screens with no DOM.
    Access needed to the appReads the application's UI technology through Tosca engines.None. No source code, instrumentation or accessibility tree. AgentOS gives the agent screen, keyboard and mouse.
    When the screen is not as expectedRuns the modelled steps as designed. When a control's properties change, the Module is updated and every test case on it follows.The agent decides each next action from the screen. It closes unexpected pop-ups and corrects its own misclicks. Two attempts per step; In-Flight Guidance stops runs that loop; Dreaming proposes fixes for review.
    End to end across systemsEnd-to-end flows across web, desktop, APIs and packaged applications in one test case.One test can drive several computers and check APIs and databases in between, with one report. Combining desktop, Android and web in one run is on the roadmap: profiles connect today.
    Integrations beyond the UIAPI testing, test data and service virtualization in the Tricentis platform.Tool Store: SQL over ODBC, HTTP, shell and file checks, off until enabled. Custom C# tools and MCP servers, for example Vector CANoe or dSPACE, called from plain-language steps.
    Test formatTests and models live in the Tosca repository.Markdown, CSV or JSON files in your own Git repository.
    Role of AIAt design time: Agentic Test Automation writes Tosca test cases from natural language, and the model-based engine runs them. Vision AI recognizes controls from the image.The engine. A computer-use agent performs every step.

    Based on public information from the vendor's website and docs.askui.com, checked October 2026. Products change; check the current documentation. Tricentis Tosca is a trademark of its owner.

    Which one fits

    Both are good at something.

    Choose Tricentis Tosca when

    Your estate is SAP, Oracle or Workday, and you want prebuilt models for those applications.

    Choose AskUI when

    Your tests start from requirements and should be written by the people who know them, not by tool specialists. Or the screen has no control tree, for example an embedded HMI, a head unit or a kiosk, or tests must run air-gapped on your own model.

    Questions

    What is the difference between model-based and agentic test automation?
    In model-based automation, a test is built on a technical model of the application: its controls and the properties that identify them. Someone builds and maintains that model. In agentic automation, a test is the requirement in plain language, and an agent decides each action from the screen at run time. There is no model to maintain, but each step is a model call.
    Do we need Tosca specialists to use AskUI?
    Not to write tests. Testers write the steps in plain language from the requirement. A technical person sets up devices, custom tools and Cortex rules once. Tosca specialists often become fast AskUI authors, because they know test design.
    Is Tricentis Agentic Test Automation the same as AskUI?
    No. Tricentis Agentic Test Automation uses AI to write Tosca test cases, which then run on Tosca's model-based engine. AskUI's agent runs the test itself and decides each action from the screen. One uses AI at design time, the other at run time.
    Can AskUI import Tosca test cases?
    Not directly, because Tosca test cases are bound to Modules. Teams start from the manual test cases or requirements behind them, for example as a spreadsheet or CSV export.
    Can AskUI replace Tosca for SAP testing?
    Tosca has prebuilt models for SAP that AskUI does not have. AskUI can drive SAP GUI and SAP Fiori from the screen, but for large SAP estates Tosca's models are often the faster route.
    Where does AskUI fit in a Tosca shop?
    On screens outside a model-based setup, such as embedded HMIs, infotainment and kiosks, and on tests that start from requirements and change often. Both report into your CI.

    Send us ten test cases.
    We'll run them on your system.

    Or download AskUI Desktop. No sign-up.