SmartBear MCP for Zephyr: Connect your testing system of record to your AI tools 

Your SmartBear Zephyr test data holds the answers you need before you ship: what’s covered, what passed, where the risk sits. That data has always lived one context switch away, behind the Jira UI. The SmartBear MCP Server changes that. It brings your Zephyr test data into any MCP-compatible AI client, so quality keeps pace with how fast your team builds. This guide covers where testing sits in the AI age, what MCP is, and how it unifies data visibility within your Zephyr workflow. 

Key takeaways 

• The SmartBear MCP Server connects AI assistants and MCP-compatible tools to your Zephyr test data through the Model Context Protocol, an open standard. 

• It serves anyone using an MCP-compatible AI client, while the Zephyr Agent for Rovo serves QA teams working inside Jira. Both work on the same Zephyr data from different surfaces. 

• Because MCP is an open standard, SmartBear, Atlassian Rovo, and GitHub servers can run in one agentic workflow, giving you work items, tests, and code in a single connected view. 

• The server handles read and write actions and runs within Zephyr’s existing permissions and SmartBear’s governance. 

Testing in the AI age requires measurable assurance for shipping at AI speed 

With AI as the accelerant, teams write more code, applications change more often, and new releases ship it faster than testing practices were built to keep up with. For quality, that means confidence has to keep pace with the speed of change. When those answers live behind a UI no one opens, testing becomes the step that slows everything else down. 

This is what application integrity means in practice: continuous, measurable assurance that your software just works as intended, at AI speed and scale. Zephyr is the Jira-native testing system of record that holds that assurance: your test cases, executions, coverage, and results, connected with full traceability. The question the AI age asks is, how to make that record reachable wherever the work happens. For teams working through AI clients, the answer is MCP. 

What is MCP? 

The Model Context Protocol (MCP) is an open standard that lets AI tools connect securely to external data sources. It’s not a SmartBear product, in the same way REST and OAuth are protocols rather than products. Here’s a useful way to picture it: MCP is a standard outlet your Zephyr test data plugs into once, and any MCP-compatible tool can draw from it. There’s no custom integration built for each one. 

Because it’s an open standard, MCP belongs to no single vendor. That means you’re not locked into one AI tool, and you’re not stuck getting Zephyr data on its own either. 

Open Claude, GitHub Copilot, or Cursor, connect the SmartBear MCP Server, and your Zephyr test data is right there in the conversation. Ask what’s covered, what’s still open, or whether a release is ready to ship, and the answer comes from your actual data, not a guess. 

If you’ve already got another MCP server connected in the same client, your project tracker or your codebase, it’s sitting right alongside Zephyr’s. You don’t have to set anything up specially for this. Ask a broader question, and you get an answer pulling from all of it at once. 

What is the SmartBear MCP Server for Zephyr? 

The SmartBear MCP Server for Zephyr lets AI tools read and act on your Zephyr test data without opening Jira. It uses the Model Context Protocol, an open standard for connecting AI clients to external data, so anyone working in an MCP-compatible tool like Claude Code, GitHub Copilot, or Cursor can query test coverage, read and update execution status, and surface release-readiness data in plain language. MCP works on Zephyr Standard and Advanced. 

How MCP unifies your test data visibility where you work 

Zephyr test data earns its value the moment someone acts on it, and that moment usually happens where the work is, in an editor, a pipeline, or an AI chat. Picture the everyday version: you’ are about to merge a release branch and you want to know whether it has coverage gaps. Without MCP, that means leaving what you’re doing, opening Jira, navigating Zephyr, reading the answer, and carrying it back in your head. The data you needed was in your system of record, just not where you were working. 

MCP closes that gap. The SmartBear MCP Server makes your Zephyr test data reachable through the open protocol, so any MCP-compatible client can pull coverage, executions, and results directly. That could be a coding assistant like GitHub Copilot, an agentic environment like Claude Code or Cursor, or another AI tool that supports the protocol. The data comes back structured for a tool to act on rather than formatted for a person to read. Your coverage, your test runs, and your release risk stop being a place you visit and become context your tools can reach on their own. 

What you can do with your Zephyr test data through MCP 

Once your Zephyr data is reachable through MCP, these items below become part of your normal flow, none of them requiring you to open Jira. None of this is automatic and you stay in control: the server exposes the data, but a useful answer still means telling the AI what to look for, the same way you would scope any prompt. 

• Answer “are we good to ship?” Ask about release readiness and point the AI at the right release or work items. It pulls Zephyr execution status and coverage into the answer, so a go or no-go call starts from current data, not a screenshot in a channel. 

• Catch coverage gaps early. Ask which requirements or user stories have no tests against them, and with the right prompt the AI surfaces the blind spots before the branch merges. 

• Reason about release risk. Bring your Zephyr test data together with other signals in one agentic session, so your pipeline can weigh deployment risk on real evidence instead of a manual review. 

• Read and update execution status. Check a run and record its result straight from your client, without switching tools. 

Every one of these works both ways, reading your data and acting on it, and all of it runs within Zephyr’s existing permissions and SmartBear’s governance. 

Zephyr, Atlassian, and your AI tools: Connected context 

Here’s where the Zephyr story becomes powerful. Your test data lives in Zephyr inside Atlassian’s Jira, and because MCP is an open standard, the SmartBear MCP Server and the Atlassian Rovo MCP, Rovo being Atlassian’s AI assistant built into Jira, can run in the same workflow. In one AI client like Claude Code, you can ask about a Jira issue through the Atlassian Rovo MCP and its Zephyr test coverage through the SmartBear server, in one agentic session, without opening either interface. To read Jira data specifically, you connect the Atlassian Rovo MCP alongside the SmartBear server. 

That’s the shift for teams building on Atlassian. Your Zephyr quality data becomes context your tools reach on their own, wherever the work is happening. Add a GitHub MCP server to the same session and you have the issue, its tests, and the code in one connected view, driven end to end by AI. 

Ways to bring AI to your Zephyr testing 

SmartBear has several AI capabilities for Zephyr. This guide focuses on the SmartBear MCP Server, which connects your Zephyr test data to the AI tools you already use outside Jira, like Claude, GitHub Copilot, or Cursor. Worth knowing about too: the Zephyr Agent for Rovo, which works inside Jira itself, through Rovo, Atlassian’s AI assistant built into Jira. 

Both put AI to work on the same Zephyr data, just from different surfaces, so here’s how to tell which one fits where you’re working: 

	SmartBear MCP Server	Zephyr Agent for Rovo
Who it’s for	Anyone using an MCP-compatible AI client: developer, DevOps or QE lead, or stakeholder	Teams in Jira
Where it works	Any MCP-compatible AI tool or IDE, outside any UI	Inside Jira
What it does	Pulls coverage, executions, and results into your AI client Reads and updates execution status Reasons about release risk across combined signals Creates and updates test cases, cycles, and executions Feeds Zephyr results into CI pipelines	Generates test cases from requirements and work items Checks test coverage and flags gaps Assesses release readiness inside Jira Links test cases to Jira work items Answers questions about your Zephyr test data in plain language

If you work through an MCP-compatible AI client, MCP is your entry point. If you want to interact with an agent directly inside Jira’s interface, the Zephyr Agent for Rovo is the better fit, the Zephyr Agent for Rovo is the better fit, and the companion guide covers it in full. The two work on the same Zephyr data from different surfaces, and neither replaces the other. 

You don’t have to pick one. Many teams use both, since they cover different moments in the same workflow.  

Picture a release in flight: a developer in Claude Code asks the SmartBear MCP Server which requirements on the branch have no coverage, then generates and runs the missing tests without leaving the editor. The results land in Zephyr. Over in Jira, the QA lead opens the Zephyr Agent for Rovo, sees the same updated coverage, and asks for a release-readiness summary to share with the team. Same Zephyr data, two surfaces, one connected flow. 

Where it runs and how it’s governed 

The SmartBear MCP Server runs where you need it. You can install and run it locally, or run it in a controlled cloud environment. There’s also a remote, hosted option for teams that prefer zero install, which covers Zephyr among the remote-enabled products. Either way, it works within Zephyr’s existing permissions and SmartBear’s governance, so the data a tool can reach through MCP is exactly the data the user already has rights to. 

Whether you’re a developer, a QE lead, or a stakeholder who just wants a quick read on a release, if you work with an MCP-compatible AI client, you can pull Zephyr coverage, executions, and results into whatever you’re already using. It meets you where you work, whether that’s writing code, checking on a release, or answering a quick question without opening Jira. 

And it doesn’t have to be one tool for the whole team. Someone building in an AI client can use the SmartBear MCP Server, while a colleague managing testing in Jira uses the Zephyr Agent for Rovo. Same Zephyr data, different surfaces, working together across your team. 

Getting started 

Getting started takes three steps: 

• Connect the server. Connect the SmartBear MCP Server to the AI tool you already use, Claude Code, GitHub Copilot, Cursor, or another MCP-compatible client, and point it at your Zephyr data. The getting-started guide walks through the remote and local options, and the Zephyr integration guide covers the Zephyr-specific setup. 

• Ask in plain language. Ask for what you need: coverage on a release branch, execution status for a version, the risk picture before a deploy. 

• Write a clear prompt. A good result depends on how you ask. Name the release, project, or work item you mean, and be specific about what you want back, a list, a status, a risk summary. 

Start with your test data where you build 

New to Zephyr? Start a trial on the Atlassian Marketplace, then connect the SmartBear MCP Server to the AI tool you already use, point it at your Zephyr data, and ask for coverage on the release or work item you’re working on. 

Frequently asked questions