# Was It Slow on Our Side? A SaaS Support Team Checks Each Slowness Ticket Against Honeycomb

When a ticket says the app was slow, a SaaS support team's agent queries Honeycomb for that customer's requests and drafts what support can say.

[Run this on Rush](https://cloud.getrush.ai/run/check-a-customers-slowness-complaint/honeycomb/). Opens the console with this prompt ready to send. Connect Honeycomb there first.

## What the agent does

This is for the support team of a SaaS company, say a scheduling product sold to field teams, whose services send traces to Honeycomb. A ticket that says "the app was really slow this morning" usually sits until an engineer has time to look, and the customer hears "we're investigating" twice. The engineers already tag every span with the customer's account id, so the answer is in Honeycomb; support just cannot write the query. The agent writes it. An engineer connects Honeycomb once with `POST /me/connections {"type": "mcp", "name": "honeycomb", "url": "https://mcp.honeycomb.io/mcp", "auth": {"mode": "oauth"}}`, signing in as an account that can read the production environment. Honeycomb's docs say the team must have Honeycomb Intelligence turned on.

When a ticket is tagged as a performance complaint, the company's backend starts one run with the account id, the time window the customer gave (widened by an hour each side) and the customer's own words. The agent calls `get_workspace_context` and `get_environment` to find the production environment and its datasets, then `find_columns` to locate the account id and duration columns by intent, since the field might be `app.account_id` in one service and `account.id` in another. It confirms them with `get_dataset_columns`.

With `run_query` it asks for that account's request durations in the window as P50, P95 and P99 broken down by route, and the same for all accounts, so it can tell "slow for everyone" from "slow for this customer". It runs the same breakdown for the same hours a week earlier as a baseline, and counts errors. When one route stands out, it takes a slow trace id from the results and calls `get_trace` to see which span took the time: a database call, a third-party API, a queue wait. It uses `find_queries` first to reuse any query the engineers saved for this.

It drafts two things: a note for the support person with the numbers, the route, the span that dominated and a link to each query, and a short reply to the customer in plain language that says what the data shows and nothing more. The reply is a draft. The support person reads both and decides what to send, and an engineer is pulled in when the data points at the company's own services. The prompt forbids creating or changing boards, triggers, SLOs and recipients.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Support ticket: account 48213 says \"the schedule board took ages to load, maybe 30 seconds, between 8 and 9 this morning\". Their time zone is America/Chicago and today is 2026-11-12. Use the Honeycomb connection. Call get_workspace_context and get_environment to find the production environment; use find_columns and get_dataset_columns to find the account id and duration columns. Call find_queries for any saved query about latency by account. With run_query, for 07:00 to 10:00 America/Chicago today, get P50, P95 and P99 duration and error count by route for account 48213, then the same for all accounts, then the same for account 48213 one week earlier. If one route stands out, open one slow trace with get_trace and name the span that took the most time. Write a note for support with the numbers, the route, the span and each query's link, and a reply to the customer of at most 120 words that states only what the data shows. Do not create or update any board, trigger, SLO or recipient.",
  "connections": [
    "honeycomb"
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

The answer comes back in the session's `result`, and through the key's `run.completed` webhook to the company's handler, which posts the note and the draft reply as a private comment on the ticket. Nothing reaches the customer until a support person sends it.

What the support person checks: that the account id the agent used is the one on the ticket, that the window matches what the customer said, and that the draft reply does not promise anything the note does not support. A result that shows nothing unusual is an answer too: the reply then asks the customer for the time and page again rather than claiming nothing happened, since sampling or a client-side delay can hide a slow page from server traces.

## Run it on every performance ticket

The helpdesk calls the company's own handler when a ticket gets the performance tag. The handler pulls the account id from the requester's organization and sends `POST /o/{org}/sessions` with this body, filled in, and a `request_id` that is a UUID v5 of the ticket id so a retried webhook starts no second run.

On a bad morning, when twenty tickets arrive at once, each gets its own run. Runs past the key's `max_concurrent` limit are created `queued` and start as earlier ones finish, so the handler needs no retry loop.

## Why run it on Rush?

The data to answer a slowness ticket already exists in Honeycomb, and the gap is a person who can write the query at 9 a.m. The agent does the engineer's first look at every ticket: find the columns, compare against everyone and against last week, open one trace. The engineers still own the fix; they just get the ticket with the evidence attached. The Honeycomb sign-in stays in Rush's connection, not a management API key in the helpdesk's settings.

Each ticket's run has its own computer, a record of every query and trace it read, and what its model calls cost, readable later from the session. When an engineer disagrees with a draft, the transcript shows which query it came from.

## Frequently asked questions

### What if our services do not record the account id on spans?

Then Honeycomb cannot split latency by customer and the agent says so instead of guessing. Adding the account id as a span attribute is the engineers' change, and the prompt can name the column once it exists.

### Can the agent create a trigger or a board while it investigates?

Honeycomb's server has tools that create and update boards, triggers, SLOs and recipients when the sign-in grants write access. The prompt forbids all of them, and the transcript would show any such call.

### Will a burst of tickets hit Honeycomb's limits?

Honeycomb's tool reference allows 100 `run_query` calls a minute, and each run makes a handful. Many runs at once share that limit, so a burst can slow; a rate-limited answer says when to retry.

### We use Honeycomb's EU region. Does this work?

Rush lists the US server. Honeycomb's EU server is `https://mcp.eu1.honeycomb.io/mcp`; connect it as a custom MCP server with that URL and name your connection on the request instead.

## More Honeycomb jobs

- [How Did Our API Perform for This Customer Last Quarter? A Customer-Success Team's Honeycomb Report](https://getrush.ai/run/prepare-customer-performance-review/honeycomb/)

## More jobs like this: Run an agent per customer task

- [Check Each Brokerage's Deal Folders in Google Drive for Missing Documents](https://getrush.ai/run/check-deal-files-for-missing-documents/google-drive/)
- [Is This Support Ticket a Known Bug? A Help Desk App Checks Each Customer's Sentry When a Ticket Arrives](https://getrush.ai/run/check-if-a-ticket-is-a-known-bug/sentry/)
- [Are Next Week's Viewings Ready to Go? A Property Management App's Check of Each Leasing Agent's Outlook Calendar](https://getrush.ai/run/check-next-weeks-property-viewings/microsoft-calendar/)
- [Where Are Last Month's Receipts? A Bookkeeping App Collects Each Freelancer's Emailed Receipts From Their Gmail](https://getrush.ai/run/collect-monthly-receipts-from-email/gmail/)
- [Which Supplier Prices Went Up This Month? A Field-Service App's Check of Each HVAC Contractor's OneDrive Price Lists](https://getrush.ai/run/compare-supplier-price-lists/onedrive/)

## Keep reading

- [Connect Honeycomb to Rush once, then name it on any run](https://getrush.ai/integrations/honeycomb/)
- [Start your first run from the developer API quickstart](https://getrush.ai/docs/quickstart/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
