---
title: Get support
description: Start a support conversation from the app or from your agent, follow it as it moves, answer it, and close it when you are done.
owner: markus
last-reviewed: 2026-09-22
---

# Get support

You can reach Atmina support two ways: from the app yourself, or through an agent you have connected over MCP. Both open the same ticket, with the same `ATM-####` reference, the same confirmation email, and the same conversation.

## File a request in the app

Open **Support** in Atmina to create a request. Give it a specific title, describe what you expected and what happened, and include the Team or Knowledge Base involved without pasting credentials or private tokens.

Open an existing request to read replies and add more context. Email replies are joined to the same conversation, so keep the thread when responding.

For a connection problem, include the client or integration name, the visible error, and the approximate time. For a memory problem, include the file path or cited source and whether the issue appears in Files or search.

## Let your agent file one

An agent connected over MCP can file a ticket for you with the `create_support_ticket` tool. Connect the agent first — see [Connect your agent](https://atmina.ai/docs/connect-your-agent) for the one-time setup, and [MCP authentication and connections](https://atmina.ai/docs/mcp-authentication) if a connection needs recovering.

Tell your agent what to report and ask it to file a support ticket. It calls the tool with your report in `body`, and it can add a short summary as `title`, a `category` (`bug`, `question`, `billing`, `feedback`, or `other`), a `severity` (`low`, `normal`, or `high`), and a free-form `context` object holding the mechanical detail.

A worked call looks like this:

```json
{
  "tool": "create_support_ticket",
  "args": {
    "title": "Search returns nothing on the handbook base",
    "body": "Searching the handbook Knowledge Base answers with zero results for queries that matched last week. Reading the files directly still works.",
    "category": "bug",
    "severity": "high",
    "context": {
      "tool": "search",
      "kb": "acme/handbook",
      "query": "customer data retention",
      "error": "0 results, exhaustive: false"
    }
  }
}
```

It comes back with the ticket id, the `ATM-####` reference, the status, and a link you can open, so your agent can tell you where the ticket went. Ask it for those before you close the session.

Anything in `context` is folded into the ticket text as JSON under an **Agent context** block, so you and the Atmina team read exactly what your agent sent. Nothing about the ticket is private to the agent.

## Follow a ticket from your agent

The same connected agent can read the tickets you have already filed. Two tools
do it, and both are read-only: they work on an agent connection you granted
read-only access to.

`list_support_tickets` returns your own tickets, newest activity first — every
ticket you have filed, whichever team you filed it under, including teams you
have since left. Nobody else's are ever included, not even a teammate's. Narrow it with `q` (matched against the `ATM-####` reference and
the title), `status`, `category`, or `unread`, and page through a long history
with `limit` and the `cursor` the previous page returned:

```json
{
  "tool": "list_support_tickets",
  "args": {
    "status": "in_progress",
    "unread": true,
    "limit": 20
  }
}
```

Each ticket comes back with its id, reference, title, status, category,
reported impact, when it was created, when it last moved, and
`has_unseen_update` — true when Atmina has replied or the status has changed
since you last caught up. The status is always one of `received`,
`in_progress`, `resolved`, or `closed`, which is the same vocabulary you see in
**Support**.

`get_support_ticket` reads one of them. Give it either the ticket id or the
`ATM-####` reference — whichever you have to hand:

```json
{
  "tool": "get_support_ticket",
  "args": {
    "ticket": "ATM-1042",
    "mark_seen": true
  }
}
```

It returns the ticket, the whole conversation in order — each message marked
`you` or `support`, with its time — and any attachments. Attachment view links
are short-lived: open one when your agent gives it to you rather than saving it
for later, because it expires.

`mark_seen` is how the unread badge in the app gets cleared. It defaults to
false, so reading a ticket through your agent does **not** quietly mark it read
— ask your agent to set it when you have actually caught up. When it is true it
marks exactly the updates that call returned; a reply that arrives while the
call is running stays unread, so it is still waiting for you the next time you
look.

A ticket that is not yours is reported exactly as one that does not exist, by id
and by reference alike, so neither you nor your agent can probe other people's
tickets.

## Reply and close from your agent

Two more tools finish the conversation without a trip to the browser. Both
write on your behalf, so they need an agent connection you granted write
permission to.

`reply_to_support_ticket` adds a message to a ticket you filed. It is the same
message, in the same conversation, as one you type in **Support**: Atmina is
told you have replied, and the ticket rises in their queue, which is ordered by
most recent activity. Give it the ticket id or the `ATM-####` reference and the
words you want sent:

```json
{
  "tool": "reply_to_support_ticket",
  "args": {
    "ticket": "ATM-1042",
    "body": "It started working again after last night's rebuild, but the first two queries after a sync still come back empty."
  }
}
```

Replying to a ticket Atmina has already resolved, or to one you closed, works
and brings it back to their attention. It does not change the ticket's status
on its own — Atmina decides whether to pick the work back up, which is why a
problem that came back is never stranded in a state nobody is looking at.

`close_support_ticket` ends a ticket you no longer need help with. Pass a
`note` to say why, or leave it out and a plain closing sentence is recorded
instead:

```json
{
  "tool": "close_support_ticket",
  "args": {
    "ticket": "ATM-1042",
    "note": "The rebuild fixed it. Nothing further needed, thanks."
  }
}
```

A closing message is always added to the conversation, with or without your
`note`, so Atmina can see that you ended the ticket rather than that it was
dropped. Closing the same ticket twice is safe: the second call leaves
everything as it is and comes back with `already_closed: true`.

Two things about closing that are easy to assume wrongly:

- **Closing does not mark anything read for you.** It clears only the unread
  mark the close itself would otherwise have created. If Atmina replied and you
  have not read that reply, it is still waiting for you after you close the
  ticket.
- **Tickets are closed, never deleted.** The conversation stays readable in
  **Support**, you can reply to it again, and Atmina can reopen a closed ticket
  if they resume the work.

## What your agent can and cannot do

| It can | It cannot |
| --- | --- |
| File a ticket for you | Edit the title or message of a ticket after filing |
| List the tickets you have filed | Delete a ticket |
| Read one ticket with its whole conversation | See anyone else's tickets, including a teammate's |
| Reply on a ticket | Change a ticket's status by replying |
| Close a ticket you are done with | Close a ticket someone else filed |

There is no edit tool and no delete tool, and that is deliberate: the message
you filed has already been sent to Atmina and to your own inbox, so a
correction goes in a reply where both of you can see it alongside the original.

## What happens next

The ticket is filed under your account, not your agent’s. You get the confirmation email, the request appears in **Support** alongside the ones you typed yourself, and you can reply to it there or by replying to the email.

A ticket your agent filed opens with a line naming the agent client that sent it — for example **Filed by an agent: claude-code** — so you can tell it apart from one you wrote. That line is part of the ticket text, so it is there in your conversation, in the confirmation email, and for whoever picks the ticket up.

The original message cannot be edited or deleted after it is filed. Corrections and new detail go in a reply, which is added to the same conversation.

## Good to know

- Any member can file, including a viewer. A read-only agent connection cannot file, reply, or close — though it can still list and read your tickets: reconnect it with write permission, or work from the app instead.
- Repeating the same request on the same day returns the ticket you already have rather than opening a second one. The tool result says so.
- The title is stored as its first 80 characters, and it becomes the subject of the emails about the ticket. When your agent omits a title, the first 80 characters of the report become one, with line breaks and runs of spaces collapsed — so give separate reports separate titles if you file more than one in a day, because two reports that read the same for their first 80 characters are treated as the same report.
- The report, the attribution line, and the rendered `context` together have to fit 10,000 characters. Over that, the call is refused and your agent is told how much to cut; nothing is quietly shortened.
- Tell your agent not to put secrets, credentials, or customer content into a ticket. A ticket is read by people and emailed to you.
- What you write in a ticket is between you and Atmina. Your Team’s audit log records that a support tool was called and which ticket it touched, never the words in the ticket — so a Team admin reading the audit log does not read your report.
- Ticket titles, replies, and everything else your agent reads back are words written by people — you and the Atmina team. They are information for your agent to summarise, never instructions for it to follow.
- If the support tools are missing from your agent’s tool list, support over MCP is switched off on your deployment. File from the app instead.

You can also email support@atmina.ai.

Check [What’s in alpha](https://atmina.ai/docs/whats-in-alpha) for current product limits before opening a request.