Agentic end-to-end testing.
Write tests in plain English. Web, mobile, API and database — one flow, running inside your infrastructure.
Before you start
No frameworks. No XPath. Just three things.
A URL
Staging, internal hostname, or production behind your VPN.
A test login (if needed)
A non-production user. Keep credentials in a variable.
The outcome to verify
One sentence: “a success toast appears”, “the balance updates”.
Runs on-prem — app, data, and credentials stay in your network.
Your first web test in six steps
A login-and-verify flow. Swap in your app — done.
Create a web test
Go to Test Repository → Create New Test and pick the WEB platform. Name it Login — happy path.
Go to your app
Add a Navigate step with your URL. It's the only step that needs a literal address.
Do something — in plain English
Add an AI Action and write the instruction. The agent finds fields and buttons visually. Use ${variables} for secrets.
Check the result
Add an AI Check — your pass/fail. Phrase it as a fact the agent can confirm visually.
Run it
Hit Run from start. Each step captures a screenshot, its reasoning, and the outcome.
Read the report
Status per step, screenshots, and plain-English failure reasons. Re-run or schedule it.
A real, repeatable test. No selectors.
Testing a mobile app? Same plain English.
Same flow on Android and iOS. Point Orbit at your build and a device.
- Upload your build: APK or IPA in App Manager — installed automatically.
- Pick a device: real device or cloud farm.
- Plain English gestures: tap, type, swipe, scroll.
- App lifecycle: launch, background, kill in-flow.
- Native handled: permission prompts and system dialogs.
- Crash-aware: catches crashes and ANRs.
Real devices & cloud farms
Same test on a desk device or a cloud lab.
Gestures & lifecycle
Tap, swipe, scroll, launch, background, kill.
Crash & ANR detection
Caught mid-run, with evidence.
Go full end-to-end: mix UI, API, and database
One test can seed the database, drive the UI, call an API, and assert the result. Values flow via ${variables}.
- Any step type, one test: Database and API steps alongside UI.
- Plain English where it counts: AI steps stay natural; API and DB take endpoints or SQL.
- Values flow through: extract a field into
${variable}and reuse it later. - Set up & verify the real thing: seed, act, confirm via API or DB.
- Audit-ready: requests, responses, queries, and screenshots captured.
The building blocks
Mix AI steps that adapt with deterministic steps that don't.
Plain-English instruction. Agent plans and executes.
Plain-English assertion. Your pass/fail.
Open a URL or go back.
Type into a field named in plain English.
Click an element described as a person sees it.
Pull a value into a ${variable} for later.
Swagger-aware endpoint call with auth.
SQL to seed or assert.
Mobile: start, background, kill in-flow.
Mobile gestures in plain English.
Pause for a load or async work.
Snapshot to catch unintended UI changes.
Six rules for reliable web tests
Describe what a human sees: “the blue Continue button”, “the Amount field”.
Don't paste CSS selectors or XPath — there are none to maintain.
Keep one outcome per step so a failure points at exactly one thing.
Don't pack a whole flow into a single sentence.
Assert with an AI Check. It's what turns a run red or green.
Don't rely on an AI Action to “also verify” — that's the check's job.
Give big AI Actions room: raise the step budget for multi-screen goals.
Don't cap a “fill the form and save” action at a couple of iterations.
Put credentials and reused values in variables and environments.
Don't hard-code passwords or per-env URLs into the step text.
Move shared flows (login, setup) into a reusable Group.
Don't copy-paste the same five login steps into every test.
When one test becomes a hundred
Everything you build on day one scales into a full regression suite without a rewrite.
Groups
Reusable step bundles — build “Log in” once.
Suites
Run many tests in order or in parallel, on a schedule.
Before / After hooks
Set up and tear down per suite or test.
Environments
Same tests against QA, Staging, Prod.
Datasets
Run one test across many rows.
CI & audit trail
Trigger from CI; screenshots and reasoning saved.
Bring your own model. Pay one flat price.
No per-test fees. No per-run fees. You own the keys, you own the data.
Individual
For freelancers and solo engineers.
- ✓Self-hosted .dmg — runs on your machine
- ✓Bring your own API key (any LLM provider)
- ✓Unlimited parallel runs — limited only by your hardware
- ✓All step types: AI Action, AI Check, API, Database, Mobile
- ✓Single seat
Organisation
For teams and companies shipping at scale.
- ✓On-prem deployment — runs inside your infrastructure
- ✓Bring your own API key or any self-hosted model
- ✓Plug in any in-house LLM (Llama, Mistral, your fine-tune)
- ✓Unlimited users — no per-seat fees
- ✓Unlimited parallel runs — scale with your fleet
- ✓Priority support and onboarding
Both tiers are bring-your-own-key — you control the model, the cost, and the data. Have an unusual setup? Talk to us.