---
description: Execute Katalon True Platform/TestOps tests when the input is an existing test case, manual test case list, test suite, suite collection, execution request, or "run with AI" instruction. Use when you need to create a manual test run, start Run with AI, poll AI session results, schedule automated suites, read execution/test results, or summarize pass/fail/blocked outcomes. For full requirement-to-test-design-to-execution workflows, combine with or defer to true-platform-testing. Written for the manual tester who has cases and needs a result, by hand or through Run with AI. A coded suite driven from a framework starts at playwright-execute or upload-report.
alwaysApply: false
---

<!-- GENERATED by scripts/build-adapters.mjs from skills/. Do not edit by hand. -->

# Katalon Execute Test

Use this skill for running already-selected Katalon test cases or suites and reporting execution outcomes. Keep the larger `true-platform-testing` skill as the end-to-end orchestrator; this skill is the focused execution workflow.

## Availability Boundary

State the execution boundary before running:

- Available: read AUT environments, create manual test runs, start Run with AI, poll AI sessions, schedule automated suite runs, and read execution/test results.
- Not directly available: guarantee AI completion, inspect the live AUT UI through Katalon MCP, or run manual test cases through the automated scheduler.
- Use Browser/Playwright only when AUT exploration or visual verification outside Katalon MCP is needed.

Read `references/capability-boundaries.md` when capability scope is unclear.

## Resolve Context First

Before creating or scheduling any run:

1. Call `list_projects`.
2. Call `list_repositories`.
3. Resolve the repository/Test Project from the user's wording or unique available repository.

Ask only when multiple equally valid repositories remain, required credentials are missing, or the next action is destructive.

## Choose Execution Type

Use manual execution when:

- The user provides manual test cases.
- The user asks for Run with AI.
- The test cases were just created in Katalon.
- The input is a manual suite.

Use automated execution only when the input is an automated suite or suite collection.

If the user only says "run tests" and the type cannot be inferred, ask whether they want manual or automated execution.

## Manual Run With AI

Always follow this order:

1. Call `read_auts` immediately before `create_manual_test_run`.
2. Resolve the manual cases or suites.
3. If a suite is provided, call `read_test_suite` before creating the run.
4. If individual cases are provided, call `read_test_case` for unclear or risky inputs.
5. Create the manual run with `create_manual_test_run`.
6. Start Run with AI automatically with `create_manual_ai_session` unless the user explicitly says not to run AI.
7. Poll `read_manual_ai_session` until all items leave TODO/IN_TESTING, or the platform returns an external timeout/error.
8. Read available execution/test result details before responding.

AUT rules:

- Never reuse AUT environment selection from an earlier turn or earlier run.
- Choose the AUT/environment whose URL or name clearly matches the target AUT.
- If no AUT exists and a URL is known from the user, requirement, or test data, use it as `default_aut_environment_url`.
- Ask only when multiple AUTs are equally plausible or no target URL can be resolved.

Read `references/execution-workflow.md` before creating manual executions.

## Automated Execution

Use automated execution only for automated suites:

1. Find automated suites or suite collections with `find_test_suites`.
2. Find execution profiles with `find_execution_profiles`.
3. Find TestCloud environments with `list_test_cloud_environments`.
4. Build the run configuration with `build_run_configuration`.
5. Optionally build a schedule with `build_schedule`.
6. Run with `schedule_test_run`.
7. Read execution and test results with `read_execution`, `read_execution_test_results`, and `read_test_result` as needed.

Do not call `create_manual_test_run` for automated suites, and do not call `schedule_test_run` for individual manual test cases.

## Report Results

After execution, report:

- Run name and link when returned.
- Final status.
- Passed, failed, blocked/incomplete, and not-run counts.
- Failed cases with concise failure reasons.
- Defects created or recommended.
- Gaps, skipped cases, and manual follow-up required.

Ask before creating ALM-linked defects unless the user explicitly requested defect creation for failures.

---

## Bundled references

_The reference material the skill points to is inlined below so this file is self-contained._


### references/capability-boundaries.md

# Katalon MCP Capability Boundaries

## Available

- Project discovery: `list_projects`.
- Repository/Test Project discovery: `list_repositories`.
- Requirement discovery: `find_requirements`, `read_requirement`.
- Requirement coverage: `fetch_requirement_data`.
- Test case operations: `create_test_case`, `read_test_case`, `update_test_case`, `duplicate_test_case`, `delete_test_case`, `move_test_case`, `find_test_cases`.
- Test folder operations: `find_test_folders`, `manage_test_folder`.
- Test suite operations: `find_test_suites`, `read_test_suite`, `manage_test_suite`.
- Requirement links: `link_requirements_to_test_case`, `unlink_requirements_from_test_case`, `find_test_cases_by_requirement`.
- Manual execution: `read_auts`, `create_manual_test_run`, `create_manual_ai_session`, `read_manual_ai_session`.
- Automated execution: `find_execution_profiles`, `list_test_cloud_environments`, `build_run_configuration`, `build_schedule`, `schedule_test_run`.
- Execution results: `read_execution`, `read_execution_test_results`, `read_test_result`, `find_test_results`.
- Quality data: requirement, defect, test case, test stability, and configuration coverage fetch tools.
- ALM defects: `find_alm_integration_projects`, `create_defect`.

## Not Directly Available

- Create requirements in Katalon True Platform. Requirements are synced from Jira/Azure and can be found/read/linked.
- Create a formal Test Plan entity. Use test suites/folders/executions as the executable planning structure.
- Guarantee Run with AI completion. The platform may block, fail, or require AUT/account state.
- Inspect AUT pages through Katalon MCP. Use Browser/Playwright for website exploration.
- Create defects without a failed test result ID and ALM integration details.

## Recommended Workarounds

- Requirement creation: create in Jira/Azure first, then sync/find/link in Katalon.
- Test plan: create a named folder and/or test suite, link to sprint/release, and create execution from that suite.
- AUT exploration: use Browser/Playwright to understand the product, then import manual cases into Katalon.
- AI execution blocked: report blocked state with required fixture, AUT, account, or environment action.

### references/execution-workflow.md

# Execution Workflow

## Manual Run With AI

1. Resolve project and repository.
2. Search existing coverage first, then resolve existing test cases or create only missing cases.
3. Add cases to a manual test suite if grouping is needed.
4. Call `read_auts`.
5. Choose the matching AUT/environment automatically when one clearly matches the target AUT. If none exist and a URL is known, use it as `default_aut_environment_url` for AI execution.
6. Call `create_manual_test_run`.
7. Continue to AI automatically after creating any manual execution unless the user explicitly says not to run AI.
8. Call `create_manual_ai_session`.
9. Poll with `read_manual_ai_session` until every test case leaves TODO/IN_TESTING.
10. Summarize result in chat.

## Manual Run Rules

- Never call `create_manual_test_run` without a fresh `read_auts` first.
- Never reuse AUT environment choices from earlier turns.
- Start Run with AI without asking again after any manual run is created.
- Do not ask whether to continue with AI unless the user explicitly requests a manual run without AI.
- If the manual run contains newly created test cases, they are manual by default.
- Render returned execution paths as markdown links.
- Wait for AI completion before final response. If the platform stays pending/running for an unusually long time, keep polling at practical intervals and only report in-progress status when the user asks or the platform returns a timeout/error.
- Ask for user input only when required data is missing, multiple AUTs are equally plausible, the user explicitly disables AI, or the next action is destructive.

## Automated Run

1. Resolve repository.
2. Find automated test suites or suite collections.
3. Find execution profiles.
4. Select TestCloud environments.
5. Build run configuration.
6. Optionally build schedule.
7. Call `schedule_test_run`.
8. Read execution and results.

## Automated Run Rules

- Use `schedule_test_run` only for automated suites.
- Do not run manual test cases through automated scheduling.
- For mobile native, ensure app details are present.
- For mobile availability filters, clarify automation/manual vs live testing when needed.

## Result Reporting Template

```text
Run:
- Name:
- Link:
- Status:

Summary:
- Passed:
- Failed:
- Blocked/Incomplete:
- Not run:

Findings:
- ...

Next actions:
- ...
```