npx @kifas/mcp@latest

Take QA automation off your to-do list.

Connect your GitHub repo. Kifas agents read the code, write the tests, and run them on real browsers, emulators, and the Device Farm. Or vibe-test in plain language: describe a flow and it becomes a running test.

Start freeRead the MCP docs

1,000 credits ($10), no card, 14 days. Live now. Not a waitlist.

acme/storefrontmain65 MCP tools
SCANNING REPOkifas.scan
  • P0Checkout with a saved cardcheckout.spec.ts
  • P1Sign up, verify email, reach the dashboardsignup.spec.ts
  • P2Invite a teammate and accept the inviteinvite.spec.ts
Reading routes, components, and the API calls behind them.
Works with the tools you already use
PlaywrightSeleniumCypressClaudeCursorWindsurfGitHubJira
The autonomous loop

Five steps. No babysitting.

Connect a GitHub repository once and Kifas runs the whole testing loop for you, so your engineers can stop maintaining it by hand.

  • 01
    Scan

    Kifas reads your repo: routes, components, API calls, and the flows they form.

  • 02
    Suggest

    A ranked list of tests worth writing, critical paths first.

  • 03
    Build

    Agents write the tests across cloud browsers, emulators, and real devices.

  • 04
    Run

    Tests run on every push. Cold starts land in under three seconds.

  • 05
    Self-heal

    On a failure, Kifas heals the test or flags a real bug.

Flaky, or broken?

Every failed test gets a verdict: stale test, or real bug.

When a test fails, Kifas compares the failure against your code change and decides. A moved selector gets healed, with the diff. A real regression gets flagged, with the repro. You set how easily a test is allowed to break.

healedThe login button moved from #submit to [data-test=submit]. Kifas heals the selector and shows you the one-line diff. Green again, no bug.
real bugCheckout returned 500 after the pricing refactor. Nothing to heal. Kifas stops and flags it with the failing request and a repro. That is a regression.
Six differentiators

What makes Kifas different.

Kifas speaks Model Context Protocol end to end and runs on real browsers, emulators, and physical devices. Every one of these is a tool your agent can call.

01
MCP-native, end-to-end

Kifas speaks Model Context Protocol from the first call to the last. 65 MCP tools cover spawning, navigation, assertions, state, and teardown. Your agent talks to Kifas the way it talks to everything else.

65 tools · STDIO · HTTP
02
Auth Catalog

Logging in is where most E2E suites go to die. The Auth Catalog turns common login flows into one line. Google, GitHub, Okta, email-and-password, magic links: pick the flow, pass your test credentials, move on.

Google · GitHub · Okta · TOTP
03
Vibe testing

Describe a flow in plain language, like "sign up, add two items, check out with a coupon", and Kifas turns it into a running test. No selector archaeology.

04
Hybrid engine

First run, the AI explores your app and figures out the flow. Then Kifas compiles it down to deterministic Playwright, so every run after that is fast and repeatable. Exploration when you need it, determinism when you ship.

🔒 deterministic by default
05
Named, persistent state

Save a logged-in session, a seeded cart, or a configured workspace as a named handle. Reuse it across tests and runs instead of rebuilding state every time.

06
Visual workflow builder

A node-and-edge canvas for people who would rather see the flow than read it. Branch, loop, and fan out across devices without writing glue code. Non-engineers finally audit coverage.

Kifas vs the usual options

Half the price. The only one that tells flaky from broken.

 
BrowserStack
Sauce Labs
Kifas
Comparable monthly plan
$379
$399
$199
Connect GitHub, get suggested tests
✕
✕
✓ Yes
Self-heal vs real-bug discrimination
✕
✕
✓ Yes
MCP-native (65 tools)
✕
partial
✓ 65 tools
Cloud browsers, emulators, and real devices
browsers + limited devices
browsers only
✓ all three
Cold start p50 under 3s
✕
✕
✓ Yes
One-line auth (Auth Catalog)
✕
✕
✓ Yes
Standard Playwright export
✕
Yes
✓ Yes
Drive any piece standalone
partial
partial
✓ Yes

Like-for-like monthly comparison as of June 2026. BrowserStack Automate Parallel and Sauce Labs comparable published list prices. Your invoice will differ with usage.

Try it on your own GitHub repo.
1,000 credits ($10), no card, 14 days.
Start free →
Composable by design

The loop leads. You keep the controls.

The autonomous loop is the fast path, not a cage. Every piece of Kifas is still yours to drive directly.

  • MCP server

    Point Claude Code, Cursor, or Windsurf at any device.

  • Run a flow by hand

    Spin up one browser, poke at it, tear it down.

  • Run from your CI

    Kifas writes the CI config for you. Drop it in and tests run on every push.

  • Self-heal by agent

    When a test breaks, an agent heals it and tells you what changed.

MCP-first, not MCP-bolted-on

Built MCP-first, not bolted on.

Most tools added an MCP server after the fact. Kifas was built around it. The same 65 tools the autonomous loop uses are the ones you get when you connect your own agent: spawn a device, navigate, assert, save state, tear down. Whatever your agent can reason about, it can now test.

~/acme-web · claude-code
// Install Kifas's MCP server
$ npx @kifas/mcp@latest --install cursor
→ Installed 65 tools. Authenticated as maya@acme.dev
 
claude > "Test our checkout with a new Gmail user, apply promo GUMBO20, verify the total."
 
→ Kifas: workflow.create("checkout-promo")
→ Kifas: workflow.add_node(type: "auth", primitive: "gmail")
→ Kifas: workflow.add_node(type: "action", ai_explore: true)
→ Kifas: workflow.run() · 14 nodes · 3.1s start · passed
 
// Compiled to /tests/checkout-promo.spec.ts
Already have a suite?

Import it. Kifas makes it fast.

Point Kifas at the suite you already run. It converts the tests that never needed a browser into API checks, and keeps the rest on real browsers. One production suite we imported went from 36 minutes to 9.

01
Import runs your suite as-is

Point Kifas at your Playwright, Cypress, or Selenium suite. It runs first exactly as it does in your CI, so nothing changes until you decide it should.

02
It watches the real traffic

Kifas captures every network request and response behind each step. Auth tokens are managed in the platform, so it can verify backend calls directly.

03
Each step gets classified

Safe to convert to an API-level check, or genuinely browser-dependent. Visual checks and client-side logic stay in the browser. Everything else drops a layer.

04
You approve the diff

The proposed conversion lands as a reviewable diff. Nothing converts silently. Approve what you trust and keep the rest running in the browser.

One production suite we imported went from a 36-minute run to 9 minutes. Import and see your own number on the free tier: 1,000 credits ($10), no card.

Start free. Scale when it pays off.

1,000 credits ($10), no card, 14 days. Pay for what you run, not for seats. Pro is $199/mo.

Free
$0
$10 in credits (1,000 credits) · no card · 14 days
  • Cloud browsers, emulators, Device Farm
  • MCP server and 65 tools
  • Community support
Start free
Pro
$199/mo
The autonomous loop, self-healing, and the full device range.
  • GitHub-connected autonomous loop
  • Self-healing with break thresholds
  • Auth Catalog · vibe testing · hybrid engine
Choose Pro
QA Squad
Custom
A QA team's worth of work, run by agents.
  • Always-on agents across all repos
  • Priority self-heal triage
  • SSO, audit logs, and a DPA
Talk to us

See all plans →

Point Kifas at your GitHub today.

1,000 credits ($10), no card. Connect a repo, or paste npx @kifas/mcp@latest and let the agent drive.

Start freeTalk to us