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.
Model-based Tricentis Tosca
- 01Scan
XScan reads the invoice screen. Tosca stores it as the Module “Invoice” with the controls Customer, Amount and Total.
- 02Design
A test case is built from the Module. Customer = 4711 (Input), Amount = 100 (Input), Total = 119.00 (Verify).
- 03Run
The engine finds each control by its technical properties and steers it exactly as designed.
- 04UI changes
If a control's properties change, someone updates the Module. Every test case that uses it follows.
Agentic AskUI
- 01Write
“Create an invoice for customer 4711 with amount 100. Expected: the total shows 119.00.”
- 02Run
The agent looks at the screen, finds the fields, types the values and reads the total.
- 03Check
A verdict per step: expected and actual result, a screenshot and the agent's reasoning.
- 04UI 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.
| Task | Model-basedTricentis Tosca | AgenticAskUI |
|---|---|---|
| To write a test | Knowledge 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 changes | Rescan 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 failure | The 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. |
| Training | Tricentis 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.
| Question | Tricentis Toscaby Tricentis | AskUIComputer-use agent |
|---|---|---|
| How a test finds the UI | Technical 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 written | Scriptless: tests are composed from modules in the Tosca workspace. | Plain language. Your manual test cases, often written from requirements. |
| Surfaces | Web, 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 app | Reads 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 expected | Runs 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 systems | End-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 UI | API 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 format | Tests and models live in the Tosca repository. | Markdown, CSV or JSON files in your own Git repository. |
| Role of AI | At 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.
More comparisons
by SmartBear
AskUI vs TestComplete
Object recognition with record and replay and Vision AI, compared with AskUI's agent that works from the screen alone.
Read →
by Qt Group
AskUI vs Squish
Object-level GUI testing for Qt, QML and embedded HMIs, compared with AskUI's agent that needs no access to the application.
Read →
by Idera
AskUI vs Ranorex Studio
RanoreXPath object identification for Windows desktop apps, compared with AskUI's plain-language tests from the screen.
Read →
Send us ten test cases.
We'll run them on your system.
Or download AskUI Desktop. No sign-up.