Sharing the project

A project is plain files, so sharing it is a Git question, not a product question. What changes between teams is only where the repository lives and who owns which part of it.

What travels with the repository

Everything that defines a run is in the folder, so a colleague's clone behaves like yours:

• Testware: test cases, procedures, plans, and each folder's rules.md, setup.md, teardown.md.
• Agent files: the prompts/ folder, so everyone's runs get the same instructions and report format.
• Device profiles: devices.json, so every member sees the same devices list instead of wiring machines by hand.
• The toolbox: utils/tools.json, utils/mcp.json and utils/custom_tools/*.cs, which is what makes every grant reviewable in a pull request (hardening).

What each member adds locally

Three things deliberately do not travel, and a new member has to supply them:

• Secrets: values live encrypted on the machine, never in the project. A fresh clone starts without them, which is the point, everyone uses their own test credentials.
• Access to the machines: a device profile names a host; whether you can reach it depends on your network and on AgentOS running there.
• App settings: sign-in, the model provider choice, the proxy. These are per machine, not per project.

Run artifacts go the other way: agent_workspace/ and .askui_cache/ are excluded by the scaffolded .gitignore, so reports and screenshots stay local instead of bloating the repository. Archive them in CI if you need them long-term.

Who owns which part

Roles, not job titles, one person often wears several:

• Test author: writes cases and expected results, curates plans, keeps ui_information.md current as the application changes.
• Developer: fixes what a run exposes, owns custom tools, wires the suite into CI.
• Lab owner: provisions the machines, keeps sessions unlocked and AgentOS installed (running the lab).
• Workspace admin: seats and members, tokens, and the model provider the team runs on, which is also the cost lever.
• Reviewer: approves changes to the toolbox and device profiles, the same way dependency changes get reviewed.

Where the repository lives

Three arrangements, all with the same project layout:

QA owns the repository

The testing team holds the testware repo, authors in AskUI Desktop, runs against the team's devices, and schedules recurring suites. Failures go to development as run reports, expected vs. actual per step with screenshots, so a developer can act without reproducing first.

• Pick this if QA owns its own environments and release cadence.
• It needs: Desktop per tester, one shared repository, and the environments as device profiles so every tester connects to the same list.

The application repository owns the tests

The project folder lives inside the app repo. Developers author in Markdown next to the feature, run locally with Desktop or the CLI, and CI executes the suite on every pull request (AskUI in CI). A failed UI test blocks the merge like a failed unit test.

• Pick this if UI tests should gate merges and live with the code they cover.
• It needs: the CLI on the runner with ASKUI_WORKSPACE_ID / ASKUI_TOKEN, and a device the runner can reach, a headless browser needs nothing else, desktop targets need AgentOS on a test machine.

One repository, two roles

Testers curate suites, expected results and plans; developers wire the smoke plan into CI and fix against the reports. Git is the collaboration layer: changes arrive as pull requests either side can review, and configuration management of the testware comes for free.

• Pick this if regression belongs to QA but a fast subset should gate CI, the common end state.
• It needs: agreement on which plan gates merges (smoke) and which runs on a schedule, plus who owns the results of each.

Onboarding a new member

1. Clone the repository and open the folder in AskUI Desktop.
2. Add your secrets, the names are already referenced by the tests.
3. Connect a device from the shared profile list.
4. Run one existing test to confirm the setup before writing anything.