Skip to content

English · 日本語

Future vision

The overall direction Bajutsu is heading, and the one constraint every direction must respect. This page gives the strategic overview across the individual roadmap items, including how far each axis has already progressed and not only what is planned. The granular, prioritized backlog is in roadmap, and the rationale behind today's design is in DESIGN.md. Read this page to see how the pieces fit together, then follow the links for each plan.

Related: concepts · drivers · selectors · roadmap · roadmap dashboard → Hosting


The invariant: what never changes

Every future direction is evaluated against the prime directives (CLAUDE.md · concepts · DESIGN §2). The directives stay fixed across every direction below:

  1. AI is the author and the failure investigator, never the judge. No future feature may put a large language model (LLM) into the Tier-2 run / continuous integration (CI) gate. Pass/fail stays machine-checkable, always.
  2. Determinism first. No fixed sleep outside a capped sleep step, and an ambiguous selector fails fast. Every new platform, host, or authoring tool inherits this rule, and neither reach nor convenience can negotiate it away.
  3. App-agnostic / backend-agnostic. Per-app and per-platform differences live in config and behind the Driver / environment seams; the deterministic core stays the same everywhere.

The test of any roadmap item is whether it keeps AI out of the gate and the gate deterministic. An item that fails the test belongs in Tier 1 (authoring) or triage (investigation), outside the gate, or it does not belong in Bajutsu.


Three axes of growth

Bajutsu expands along three independent axes. The axes compose (none blocks the others), and each maps to concrete pages.

Three-axes diagram: the deterministic Bajutsu core expands independently along Reach (more platforms/surfaces — Web, Android, Flutter/hybrid), Scale & collaboration (hosted/self-hosted service, MCP), and Authoring & maintenance (GUI editor, capture, visual regression, self-healing triage).

Mermaid source
flowchart LR
    core(["Bajutsu core<br/>deterministic · app-agnostic"])

    reach["REACH<br/>more platforms / surfaces<br/>Web · Android · Flutter / hybrid<br/>→ below, §1"]
    scale["SCALE &amp; COLLABORATION<br/>hosted / self-hosted service · MCP<br/>→ roadmap: Hosting (BE-0015 / BE-0016)"]
    authoring["AUTHORING &amp; MAINTENANCE<br/>GUI editor · capture ·<br/>visual-regression · self-healing triage<br/>→ roadmap §3, §6, §10"]

    core --> reach
    core --> scale
    core --> authoring

1. Reach — more platforms and surfaces

The Driver / environment / id-convention seams were built to be replaced, not just configured. As a result, the same deterministic core drives iOS, Android, and the Web today, and each platform adds only its own actuator, environment, and stable-id convention. The iOS (XCUITest), web (Playwright), and Android (adb) backends have all landed and are validated end to end (see architecture → implementation status). Flutter now rides those same iOS and Android backends unchanged and needs no new actuator (BE-0008).

The abstraction is already platform-shaped. Only three seams are platform-specific:

  • the actuator, which drives the UI (common/drivers/xcuitest.py, common/drivers/adb.py, …)
  • the environment manager, which boots, erases, and launches (common/backend_cli/simctl.py on iOS, with an Android counterpart)
  • the stable-id convention (accessibilityIdentifier on iOS, resource-id on Android, data-testid on the web; see concepts §4)

Everything else (scenario DSL, selector resolution, machine assertions, the orchestrator, evidence, the reporter) never names a platform. Adding a platform means adding a new triple, not forking the core. The design already made the same move for a second iOS actuator (XCUITest).

The crux is selector portability. A scenario is portable across platforms only to the extent that its selectors use id. Each platform's native equivalent of accessibilityIdentifier maps onto the same Selector field:

Selector field iOS Android Web
id (primary) accessibilityIdentifier resource-id (Compose: testTag) data-testid
label (auxiliary) accessibilityLabel content-desc / text accessible name / aria-label
traits (role filter) UI traits widget class ARIA role

The YAML selector { id: settings.reindex } is already platform-neutral. Only which app-side attribute the backend reads to satisfy the selector differs, and that choice lives entirely inside the Driver, never in the scenario.

One wrinkle: a platform's native id syntax may not reproduce the SPEC id verbatim. Android's android:id (Views) allows neither . nor -, so stable.refresh surfaces as stable_refresh. Instead of a hidden driver-side rewrite, the scenario keeps the difference explicit with a list of id candidates (id: [stable.refresh, stable_refresh], matched as an OR). The explicit list lets the showcase's shared scenarios run unchanged on both Android UI toolkits (BE-0221; see scenarios).

Phase Scope Status
Shared abstractions Platform-aware backend registry + Environment Protocol Implemented (BE-0042, BE-0009)
Web Playwright; runs on the existing Linux gate, no Mac / emulator Implemented (BE-0041, BE-0054)
Android adb + UI Automator, a coordinate-driven backend Implemented (BE-0007, BE-0208, BE-0209)
Flutter / hybrids An id convention on the existing iOS / Android backends, not a new actuator or a semantics bridge Implemented (BE-0008)

Web landed before Android, even though Android is architecturally closer to a coordinate backend. Web needed no macOS and no device emulator, so it fit inside the make check / CI gate from day one and proved the core platform-neutral at the lowest possible cost. Android then confirmed the same lean, coordinate-driven path on an already-generalized core, on its own emulator-backed gate.

Full per-platform detail is in drivers and the roadmap dashboard → Platform support.

2. Scale & collaboration — from local tool to shared service

bajutsu serve started as a local, single-user launcher and now also runs as a shared service. A cheap Linux control plane (auth, history, queue, report viewer) is split from an expensive device-worker pool, so a team runs and reviews from a browser.

  • BE-0015 — public / cloud hosting and BE-0016 — self-hosting are both implemented: the control-plane ⇄ Mac-worker-pool split, a job queue, multi-org support, and the security hardening that public exposure mandates. self-hosting explains how to run the service yourself, on your own hardware, today.
  • Model Context Protocol (MCP) server (BE-0017) is implemented. run and doctor are MCP tools and run evidence is an MCP resource, so agents drive Bajutsu directly. The MCP server stays on the Tier-1 side of the boundary: agents author and investigate, and the gate stays deterministic.

3. Authoring & maintenance — lower the cost of owning tests

The scenario is plain YAML owned by humans. This axis makes writing and maintaining scenarios cheaper without softening the gate.

  • Graphical user interface (GUI) editor & non-AI action capture (BE-0012, BE-0013) are implemented in bajutsu serve: visually edit scenarios, pick selectors on a screenshot, and capture real taps/types into a scenario with no LLM involved.
  • Visual-regression assertions (BE-0029) are implemented: a deterministic assertion type (baseline diff, approve promotes a new baseline). It fits the directives because a machine checks it and no AI judges it.
  • Self-healing triage (BE-0021) is implemented: AI reads failure evidence and proposes a minimal diff, which a human reviews and applies with --write. The guardrail (never auto-soften a committed test) keeps self-healing triage inside the directives.

This axis keeps extending, for example with the ongoing work cataloged under roadmap dashboard → Authoring experience. The foundational capability (edit visually, capture without AI, self-heal a failure) is already in place on all three fronts.


What stays fixed across all three

Everything in the table below is shared, deterministic, and platform- and host-neutral, and none of it forks as Bajutsu grows. This shared core makes the three axes independent, because the axes extend the edges and not the core.

Fixed core Where
Scenario domain-specific language (DSL) & grammar scenarios · dsl-grammar
Selector model & deterministic resolution selectors
Machine assertions (the only judges) assertions/ · concepts
observe → act → verify orchestrator run-loop
Evidence subsystem (capturePolicy / manifest) evidence
Reporter (manifest / JUnit / HTML) reporting
Config layering (defaults × targets) configuration

New platforms add backends behind the Driver seam. New hosting changes where run is invoked, not what run does. New authoring produces the same YAML. The core stays constant.


Where each axis stands

Web (Playwright), the MCP server, and visual-regression assertions, the near-term sequence this page once recommended, have all landed. So have both the public and self-hosted topologies of the scale axis and the GUI editor / non-AI capture piece of the authoring axis. Reach's last open item, Flutter (BE-0008), has since landed too, as an id convention on the existing iOS and Android backends rather than a new actuator. All three axes therefore keep extending incrementally, with no single big piece left to converge on.

For what comes next, the roadmap is the prioritized, living backlog. This page explains the rationale and direction, not the sequencing. When a roadmap item ships, it moves to the architecture status table. Keep the three in sync.