# M00N Report

M00N Report is an AI-native test management platform: manage test cases, manual runs and releases, with real-time automated results and a 55-tool MCP server.

## What is M00N Report?

M00N Report is an AI-native test management platform for QA teams. Author manual and automated test cases in a folder-and-suite repository, plan manual executions, and roll manual plus CI results into release readiness. A 55-tool MCP server lets AI assistants author cases and build runs. Cloud or self-hosted.

M00N Report is a test management system, in the same category as TestRail, Xray, Zephyr and qTest. Four things differ. Automated results stream into the same repository that holds the manual cases, live while the suite is still running, instead of arriving after the run as a batch upload. AI assistants author cases, build manual executions and analyse coverage directly over the Model Context Protocol, under the same roles, permissions and audit log as a human user. An AI agent can also RUN a manual test execution rather than only plan one: it reads each case's steps as data, exercises them against the system under test with its own tooling, and writes pass or fail back step by step, with case, group and execution statuses deriving themselves. And self-hosting costs the same per user as cloud.

- Website: https://m00nreport.com
- Documentation: https://m00nreport.com/documentation
- Pricing: https://m00nreport.com/pricing
- Comparisons with other test management tools: https://m00nreport.com/compare
- Roadmap: https://m00nreport.com/roadmap
- GitHub: https://github.com/m00nreport
- Support: support@m00nreport.com

## Key Capabilities

### Test case management

- Test case repository with rich-text descriptions, ordered steps and expected results, attachments, tags, custom fields, per-project display IDs (TC-1, TC-42) and case-to-case dependencies
- Enforced folder and suite tree, with bulk create, bulk update and bulk clone (dependency chains resolved by topological sort)
- Cases are the single source of truth for manual and automated testing: an automated test can be linked to a manual case, including before that test has ever run
- Configurable per-project statuses, priorities and custom field definitions (text, number, select, multiselect, boolean, date)
- CSV import for bringing an existing case library in
- Archive and restore: cases and folders are archived rather than deleted, and can be restored

### Manual test execution

- Manual Test Executions with assignees, target environment, planned start and end dates, and per-step pass/fail results with an issue note per step
- Case snapshotting at execution time, so editing a case does not rewrite an execution already in flight
- Reusable Test Collections: named sets of cases assembled once and reused across executions
- Execution statuses: not executed, in testing, passed, failed, blocked
- Agentic execution: an AI agent can run an execution end to end over MCP - read each case's steps, exercise them, write per-step pass/fail with an issue note, and close the run, leaving the same evidence a human tester would (see Agentic test execution below)

### Releases and coverage

- Releases aggregate manual execution progress and automated launch results into a single release-readiness view, with optional Jira sprint linking
- Coverage is tracked by linking cases to Jira issues and by linking automated tests to manual cases
- Bidirectional coverage gap analysis: cases with no automation, and autotests in recent launches that no case owns. The reverse gap is only computable because raw automation output lands in the same system
- Composite project health score (0-100) over automation stability, coverage and manual execution, with prioritized recommendations

### Automated results

- Five official reporters: Playwright, Jest, JUnit 5, pytest and NUnit, published on npm, PyPI, Maven Central and NuGet
- Any other language or test runner integrates against a documented OpenAPI 3.0.3 ingest contract, published at https://m00nreport.com/api/ingest/v2/openapi.json
- Runs, tests and steps stream over WebSocket while the suite is still executing
- Automatic screenshot, video and trace file capture; flaky test detection; slowest tests report; pass-rate and failure trends
- CI job triggering for GitHub Actions, GitLab CI, Jenkins and TeamCity

### Platform

- Two-way Jira integration plus a Jira issue-panel app on the Atlassian Marketplace
- Notifications: Slack, Discord, Microsoft Teams, Telegram and email
- Four roles including a non-billable read-only Guest
- Enterprise SSO (OIDC and SAML) with group-to-project JIT mapping
- PostgreSQL Row-Level Security for tenant isolation, AES-256 encryption, project-level API keys
- Self-hosted deployment via Docker Compose or Kubernetes, as a separate plan priced the same per user as Team

## AI and MCP

M00N Report ships a Model Context Protocol server so an AI assistant can operate the test management system itself, not just read a dashboard.

- 60 tools: 34 state-changing, 26 read-only, 10 flagged destructive
- 7 data-enriched prompts and 8 resources
- Assistants author real test cases (Markdown is converted into the editor's document model; folders, suites and tags are auto-created), plan a manual cycle (create an execution, then add collections, suites or individual cases), link automation to cases, manage releases, and run coverage and health analysis
- Agent-authored assets go through the product's own roles, permissions and audit log, so AI-written tests are governed rather than scattered
- An agent can RUN a manual execution, not only build one: `run_manual_execution`, `get_execution_cases`, `report_case_result` and `update_execution` walk the case steps and write pass/fail back step by step. See Agentic test execution below
- Agentic-AI-ready: the read-only tools give a business's own AI agent the whole quality state. It can call list_projects, then read runs, trends, coverage gaps and a 0-100 health score per project, roll a portfolio view up across projects, flag which are lagging, and act through the write tools. The agent is the customer's own; there is no built-in AI and no built-in executive dashboard, and nothing is sent to a separate AI service
- `suggest_test_cases` is not an LLM. It supplies project-aware scaffolding from templates; the customer's own model does the generating, and `create_test_case` persists the result
- `get_feature_scan` requires a connected Jira integration
- `delete_release`, `delete_folder` and `delete_test_case` archive (soft-delete) rather than permanently remove
- Two ways to connect: the `@m00nsolutions/mcp-server` npm package over stdio with an MCP key, which works with any MCP client; and a hosted remote connector at `POST /mcp` using OAuth 2.1 with PKCE, whose redirect allowlist currently covers claude.ai and claude.com only

Docs: https://m00nreport.com/documentation/mcp/quick-start

## Agentic test execution (an AI agent runs the manual run)

Most AI in test management stops at drafting: it writes test cases, and a human runs them. M00N Report also exposes the manual run itself as something an agent can operate, so the agent can do the testing and record the result.

The run is data, not a UI. `get_execution_cases` returns every case-run row with its `executionCaseId` and its steps as structured fields - 0-based index, action, expected result, current status - so an agent has a machine-readable procedure to follow. `report_case_result` writes the outcome back atomically and idempotently: a status per step (not_executed, passed, failed, blocked, skipped) with an `issueDescription` on the ones that failed, plus `causedBy`, free-text notes and duration for the case as a whole.

- Start it with the `run_manual_execution` prompt. It lists the project's runnable executions and hands the agent the whole procedure: read the project's status vocabulary, mark the execution in testing, work case by case, close it with a terminal status
- The agent exercises the steps with tooling it already has - a browser MCP such as Playwright, an HTTP client, a terminal, a device farm. M00N Report supplies the run, the vocabulary and the write-back; the customer's own agent supplies the doing. There is no built-in AI and nothing is sent to a separate AI service
- Statuses derive themselves. `status: "auto"` computes the case result from its steps (failed, then blocked, then in testing, then passed). The containing source group rolls up on its own: all cases not executed is not_started, some executed is in_progress, all executed is completed, or blocked when a finished group still holds a blocked case. `update_execution` closes the run
- Statuses are per-project configurable, so an agent reads them with `get_project` first rather than hardcoding them
- Everything the agent writes reads back through `get_execution_cases` and appears in the UI as ordinary execution evidence: the same per-step pass/fail, notes and failure reasons a human tester would have left, on the same execution a human can take over mid-run
- Case snapshotting still applies, so a case edited during the run does not rewrite an execution already in flight
- Failures can be linked out to a Jira, Linear, GitHub or GitLab ticket in the same pass with `add_external_link`
- It is governed, not a side channel: the agent acts as the account its MCP key belongs to, under that account's role and project permissions, and every call lands in the MCP audit log. An agent can never exceed the permissions of the user whose key it holds
- Mixed runs are normal: an agent can execute part of an execution and hand the rest to a human, because both write to the same case-run rows
- Two workloads carry most of the value. REGRESSION TESTING is the strongest fit: the same scripted pass every release, run identically each time because the agent follows written steps rather than habit, and comparable release to release because the evidence has the same shape. EXPLORATORY TESTING is the other: give the agent a charter rather than a checklist and it probes the app like a tester would - and unlike a chat-log exploratory session, what it finds survives, because it writes findings up with `create_test_case`, files them with `add_external_link`, and adds the good ones to an execution. Exploration turns into regression coverage instead of evaporating, and the next regression run is the agent's too

Docs: https://m00nreport.com/documentation/mcp/agentic-testing

## Vocabulary mapping

For readers coming from another test management tool:

| M00N Report | Elsewhere |
|---|---|
| Manual Test Executions | Test Run, Test Plan, Test Cycle |
| Test Collection | Suite, reusable Cycle |
| Release | Milestone, Version |
| Launch | Automated test run / CI run |
| Folder + Suite | Test repository tree |

## Packages

- `@m00nsolutions/mcp-server` (npm) - MCP server for AI assistants
- `@m00nsolutions/playwright-reporter` (npm) - Playwright JS/TS reporter
- `@m00nsolutions/jest-reporter` (npm) - Jest JS/TS reporter
- `m00nreport-pytest` (PyPI) - pytest reporter
- `com.m00nreport:m00n-junit-reporter` (Maven Central) - JUnit 5 and Playwright Java reporter
- `M00nReport.NUnit` (NuGet) - NUnit reporter

## Documentation

**Overview**

- [What is M00N Report?](https://m00nreport.com/documentation): the entity model, the three ways results and cases get in, and who the platform is for.

**Core Concepts**

- [Core Concepts](https://m00nreport.com/documentation/core-concepts)

**Test Management**

- [Test Cases](https://m00nreport.com/documentation/features/test-cases): the case repository, folders and suites, steps, custom fields, dependencies, import, archive and restore.
- [Manual Test Executions](https://m00nreport.com/documentation/features/test-executions): manual execution runs, assignees, environments, per-step results, test collections.
- [Test Collections](https://m00nreport.com/documentation/features/test-collections): reusable, named sets of cases assembled across folders and suites and reused across executions.
- [Releases](https://m00nreport.com/documentation/features/releases): aggregate manual and automated evidence into release readiness.

**AI and MCP**

- [MCP Quick Start](https://m00nreport.com/documentation/mcp/quick-start)
- [Agentic Testing](https://m00nreport.com/documentation/mcp/agentic-testing): let an AI agent run a manual test execution end to end - why, the step-by-step setup, the tools it uses, how statuses roll up, and the limits.
- [Remote MCP Connector](https://m00nreport.com/documentation/mcp/connector)
- [MCP Configuration](https://m00nreport.com/documentation/mcp/configuration)
- [MCP Available Tools](https://m00nreport.com/documentation/mcp/tools)
- [MCP Scenarios and Examples](https://m00nreport.com/documentation/mcp/scenarios)
- [MCP with a Self-Hosted Instance](https://m00nreport.com/documentation/mcp/self-hosted)

**Reporters**

- [Getting Started](https://m00nreport.com/documentation/getting-started): stream your first automated run in about five minutes.
- [Playwright Reporter](https://m00nreport.com/documentation/reporters/playwright)
- [Jest Reporter](https://m00nreport.com/documentation/reporters/jest)
- [JUnit 5 / Playwright Java](https://m00nreport.com/documentation/reporters/junit)
- [Pytest Reporter](https://m00nreport.com/documentation/reporters/pytest)
- [NUnit Reporter](https://m00nreport.com/documentation/reporters/nunit)

**Integration API**

- [Build Your Own Integration](https://m00nreport.com/documentation/integration-api/guide): write a custom reporter against the raw ingest v2 HTTP API for any language or test runner.
- [Ingest API Reference](https://m00nreport.com/documentation/integration-api/reference)

**Results and Analytics**

- [Dashboard](https://m00nreport.com/documentation/features/dashboard)
- [Launches and Trends](https://m00nreport.com/documentation/features/launches-trends)
- [Tags](https://m00nreport.com/documentation/features/tags)
- [Feature Scan](https://m00nreport.com/documentation/features/feature-scan): coverage discovery across features. Requires a connected Jira integration.

**Administration**

- [Integrations](https://m00nreport.com/documentation/features/integrations): Jira, notifications, CI triggering.
- [Settings](https://m00nreport.com/documentation/features/settings): roles, project configuration, API keys, SSO.

**Self-Hosted**

- [Self-Hosted Deployment](https://m00nreport.com/documentation/self-hosted)

**Troubleshooting**

- [Troubleshooting](https://m00nreport.com/documentation/troubleshooting)

## Ingest API (raw HTTP, for custom reporters)

- [OpenAPI 3.0.3 contract](https://m00nreport.com/api/ingest/v2/openapi.json): machine-readable spec for every ingest endpoint, request/response schema, and limit. This spec covers result ingestion only; test case, execution and release management is reached through the app UI and the MCP server.

## Optional

- [Full details for LLMs](https://m00nreport.com/llms-full.txt): Extended product details, integration guides, and configuration references.