Native UI tests.
Generated by AI.
Actually stable.
Public release coming soon. Assertum will record your UI flows and generate production-ready native tests — complete with Screen Objects, Step functions and self-healing — for Android, Compose Multiplatform, iOS and Web.
Features
Beyond prompt-and-pray testing
Traditional AI-generated tests are brittle because they describe the UI from the outside. Assertum understands your app from within — and generates code you'd actually write yourself.
MCP for AI Agents
Expose your full UI element tree to AI agents via MCP. Agents inspect, interact, and generate tests autonomously — far beyond screenshot-based approaches.
Lower Agentic Costs
Agents work with a structured UI tree and reusable steps instead of screenshots and thousand-line scripts. Fewer tokens per run, fewer retry loops — and a visibly smaller bill at the end of the month.
Runs on Smaller Models
The heavy lifting — element resolution, structure, code generation — happens in Assertum, not in the prompt. So a mid-tier model produces the same quality of tests as a frontier one, and you are no longer locked into the most expensive LLM available.
UI Recorder
Record user flows directly in your app. Assertum captures every interaction and maps it to real UI elements — no manual script writing needed.
Best Practices by Default
Every generated test comes as Page / Screen Object classes with high-level step functions on top — the industry standard patterns that keep logic reusable and decoupled. Semantic IDs over XPath, proper assertions, isolated test state: code you'd be proud to review.
Self-Healing Tests
When your product UI changes, Assertum detects broken selectors and repairs them automatically — keeping your test suite green without manual intervention.
// ✦ Assertum generates Screen Objects automaticallyobject CartScreen : Screen<CartScreen>() { // <assertum-generated> val checkoutButton = hasTestTag("checkout_button") val promoCodeField = hasTestTag("promo_code_field") val applyPromoButton = hasText("Apply") val cartItem = hasTestTag("cart_item") val totalAmount = hasTestTag("total_amount") fun applyPromoCode(code: String) { promoCodeField.inputText(code) applyPromoButton.click() } fun proceedToCheckout() { checkoutButton.click() } fun assertItemInCart(productName: String) { cartItem.assertContainsText(productName) } // </assertum-generated>} // ✦ Step functions compose into readable test flows@Test fun checkoutWithPromoCode() { ProductScreen { addToCart(productName = "Wireless Headphones") } CartScreen { assertItemInCart(productName = "Wireless Headphones") applyPromoCode(code = "SAVE20") proceedToCheckout() } OrderConfirmationScreen { assertOrderPlaced(productName = "Wireless Headphones") }}
Code quality
Tests written to
industry standards
Assertum doesn't just record clicks and replay them. It generates structured, maintainable test code following the same patterns senior QA engineers use: Page Objects, Step functions, and proper assertion layers.
Screen Objects — not raw selectors
Assertum generates a full Screen Object class per screen. UI selectors are defined once and reused everywhere — change an ID in one place, all tests adapt.
Step functions for human-readable flows
High-level steps wrap multi-action interactions into named functions. A QA engineer reads `fillListNameAndFirstTaskAndSave()` and knows exactly what it does — no deciphering needed.
Zero duplication
Step functions are composable building blocks shared across tests. Adding a new scenario means calling existing steps, not copy-pasting element lookups.
Lower agentic development costs
Native test code with proper abstractions is cheaper for AI agents to maintain. An agent updating a Screen Object fixes all dependent tests in one pass.
Maintenance
Tests that keep up
with your product
The biggest hidden cost in UI testing isn't writing tests — it's maintaining them as the product evolves. Assertum automates that too.
Self-Healing Tests
When your product UI changes — buttons move, IDs rename, flows restructure — Assertum detects the breakage and repairs selectors automatically. Your CI stays green without a manual fix cycle.
Lower Agentic Costs
Native tests with Screen Objects give AI agents a clean, structured surface to work with. An agent maintaining Assertum-generated tests spends far fewer tokens and iterations than working with raw, flat scripts.
AI-Assisted Maintenance
New feature? Assertum's MCP integration lets your AI agent record the new flow, extend the relevant Screen Object, and add step functions — a full test update in minutes, not days.
Human Override Always Available
Every self-healed change is shown as a diff. You approve, reject, or tune. Automation handles the toil; engineers stay in control.
Without Assertum
~40h / sprint
writing + fixing broken tests
With Assertum
< 2h / sprint
review + approve auto-generated tests
Native test structure + self-healing + AI agent integration = drastically lower cost per feature tested.
Your AI agent can
see and control
your app
Most AI test generation tools work from screenshots — they're blind to the actual UI structure. Assertum exposes a full semantic element tree via the Model Context Protocol, giving AI agents direct access to element IDs, accessibility roles, text content, and interaction state.
The result: tests that understand what the UI does, not just what it looks like. No more broken selectors after a redesign.
Read UI element tree
Full semantic hierarchy with roles, labels, and states
Interact with UI
Tap, type, scroll — agent controls the app directly
Generate test assertions
AI verifies app state and writes assertions automatically
Multi-step flows
Chain complex interactions across multiple screens
Claude / Cursor / Copilot
compatible
< 3s
Average test generation time
0
Brittle XPath selectors
100%
Native test code ownership
3
Platforms at launch
Platforms
One tool, every platform
Coming soon
Assertum is rolling out platform by platform.