> ## Documentation Index
> Fetch the complete documentation index at: https://docs.glood.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Tools reference

> Every tool the Glood MCP server exposes, what it answers, and what it needs

Fourteen tools. Your assistant picks between them; this page is for when you
want to know what it actually has access to, and why a call was refused.

Every tool is scoped to **the organizations you ticked at consent** and runs
with **your own role** in each. A tool your role does not permit is refused,
exactly as the dashboard would refuse it.

## All fourteen

| Tool               | What it answers                                                                                                                                  | Needs                                            |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------ |
| `whoami`           | Which organizations this connection reaches, your role in each, the stores available, and which of your organizations are **not** shared with it | a valid connection                               |
| `describe_reports` | Which reports exist, and which a given store can answer                                                                                          | `analytics:read`                                 |
| `run_report`       | One named report, over one or more stores, in a window, with an optional comparison window                                                       | `analytics:read`                                 |
| `describe_query`   | Every measure and dimension a store's data can answer, what each means, and which may be grouped together                                        | `analytics:read`                                 |
| `query`            | A breakdown no named report covers: measures by dimensions, filtered, bucketed by time                                                           | `analytics:read`                                 |
| `stores`           | The stores this connection reaches, which Glood apps each has, and their settings                                                                | `store:read` / `store:write`                     |
| `explore_catalog`  | Products and collections as Glood sees them, with Glood's own behavioural metrics                                                                | `analytics:read`                                 |
| `explore_events`   | Row-level storefront events: one shopper's path, the sessions in a window, one session's timeline                                                | `analytics:read`                                 |
| `agents`           | What an agent watches, the instructions in force, its schedules, where it is deployed, its version history                                       | `agent:read`                                     |
| `activity`         | An agent's record on one store: runs, findings, what a run read, what it believes                                                                | `agent:read` / `alert:read`                      |
| `manage_agent`     | Create an agent or change one — instructions, schedules, deployments, mode — and record a verdict on a finding                                   | `agent:write`                                    |
| `skills`           | Your organization's written procedures, plus the platform library beneath them                                                                   | `skill:read` / `skill:write`                     |
| `org`              | Members and their roles, the roles an organization has, and what is connected to it                                                              | `member:read` / `role:read` / `integration:read` |
| `shopify_graphql`  | Read-only GraphQL against your own Shopify Admin API, for records the reports do not cover                                                       | `shopify:query`                                  |

## Reports and queries

`run_report` runs one of roughly **fifty named reports** — revenue, conversion,
AOV, attribution, funnels, top products, collection performance, returns, orders
by channel or gateway or province, customer cohorts, data integrity. These are
the same reports the dashboard shows, computed by the same code, so a figure in
chat and a figure on the page cannot disagree.

`query` composes instead: any measure by any dimension, filtered and bucketed.
Reach for it when the question is a notch off a named report — *"revenue by
country by week for the last 90 days, mobile only"*.

<Note>
  Which reports a store can answer depends on **which Glood apps it has
  connected**. A store with Glood Search but not Glood Personalization answers a
  different set. That is what `describe_reports` and `describe_query` are for, and
  why asking what exists beats guessing at a name.
</Note>

## Tools that look alike

<AccordionGroup>
  <Accordion title="explore_catalog or shopify_graphql?">
    They answer different halves of a catalogue question.

    `explore_catalog` returns **Glood's behavioural metrics** — recommendation
    rank, click-through, collection-to-product-page movement. "Which products
    convert best" is this one.

    `shopify_graphql` returns **Shopify's own records** — inventory levels,
    fulfilment status, metafields, order detail. "Which of them are out of
    stock" is this one.

    A question like *"which of my best-converting products are out of stock"*
    needs both, in that order.
  </Accordion>

  <Accordion title="run_report or query?">
    `run_report` runs one of the fifty named reports. Prefer it when one fits,
    because those are what the dashboard shows.

    `query` composes a breakdown no report covers. It has a larger vocabulary
    and more ways to answer a subtly different question than the one asked,
    which is why the `glood-query` skill exists.

    Comparisons belong to the tool either way: both take a comparison window and
    compute it. A trend should never be two calls subtracted.
  </Accordion>

  <Accordion title="agents, activity, or manage_agent?">
    `agents` is what an agent **is** — its instructions, schedules, deployments
    and versions. Read this before proposing any change.

    `activity` is what it **did** — runs, the findings it raised and how often
    each recurred, what it read during a run, and what it currently believes.
    "What did it find last night" is this one.

    `manage_agent` **changes** things. Every write reads back a sentence naming
    the agent, the store and the organization.
  </Accordion>
</AccordionGroup>

## Shopify access is read-only

`shopify_graphql` runs against your own Shopify Admin API, and **mutations are
refused** — checked on the parsed document, not guessed at from the text. There
is no way to write to Shopify through this connection.

Customer identifiers are refused by name: email, phone, names and addresses are
not returned.

If something needs changing in Shopify, the assistant will tell you what and
where. You make the change in Shopify admin.

## Writes that ask twice

Three actions are two-step by design. The first call changes nothing and returns
a review of what would happen; nothing happens until you confirm:

* **Archiving** an agent
* **Stopping** a deployment
* **Removing** a schedule

Everything else that changes an agent reads back a sentence naming exactly what
changed, on the store and organization it changed it on. That sentence is your
confirmation the right target was hit — read it.

## Creating an agent is not deploying one

Creating makes the agent and its instructions. It then **runs nowhere and
recurs never** until you deploy it to a store and give it a schedule. Cron runs
in each store's own timezone.