# Atono (oci · docker.io/atonoio/atono-mcp-server:1.1.1)

Give your AI coding tools your team's product context: stories, bugs, epics, and glossary.

- Trust score: 38/100 (low)
- Change this week: +6
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-22

## Components

- oci · `docker.io/atonoio/atono-mcp-server:1.1.1`: 38/100 (this document), [markdown](https://verifymcp.io/servers/io-atono-atono-mcp-server/docker-io-atonoio-atono-mcp-server-1-1-1.md), [page](https://verifymcp.io/servers/io-atono-atono-mcp-server/docker-io-atonoio-atono-mcp-server-1-1-1)

## Channel facts

- Registry: `oci`
- Package: `docker.io/atonoio/atono-mcp-server:1.1.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-22.

- **Supply Chain Security**: 0/100
  - Malware scan not yet available for this package.
  - Known CVEs could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
  - Install-script risk not yet assessed.
  - Dependency health could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
- **Provenance & Transparency**: 35/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: no license is declared.
  - Actively maintained (last published 14 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 65/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 7939 tokens (~189/item across 42 items; 42 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 40/100
  - Stability observed for 12 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Atono MCP server?

Atono runs locally as a container image, launched with docker run --rm -i docker.io/atonoio/atono-mcp-server:1.1.1. Ready-made configuration for Claude, Cursor, VS Code, Codex and 3 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add io-atono-atono-mcp-server -- docker run --rm -i docker.io/atonoio/atono-mcp-server:1.1.1
```

### Cursor

```json
{
  "mcpServers": {
    "io-atono-atono-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "docker.io/atonoio/atono-mcp-server:1.1.1"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "io-atono-atono-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "docker.io/atonoio/atono-mcp-server:1.1.1"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add io-atono-atono-mcp-server -- docker run --rm -i docker.io/atonoio/atono-mcp-server:1.1.1
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "io-atono-atono-mcp-server": {
      "type": "local",
      "command": [
        "docker",
        "run",
        "--rm",
        "-i",
        "docker.io/atonoio/atono-mcp-server:1.1.1"
      ],
      "enabled": true
    }
  }
}
```

### Hermes

```yaml
mcp_servers:
  io-atono-atono-mcp-server:
    command: "docker"
    args: ["run", "--rm", "-i", "docker.io/atonoio/atono-mcp-server:1.1.1"]
```

### Netclaw

```json
{
  "McpServers": {
    "io-atono-atono-mcp-server": {
      "Transport": "stdio",
      "Command": "docker",
      "Arguments": [
        "run",
        "--rm",
        "-i",
        "docker.io/atonoio/atono-mcp-server:1.1.1"
      ]
    }
  }
}
```

### Other

```json
{
  "mcpServers": {
    "io-atono-atono-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "docker.io/atonoio/atono-mcp-server:1.1.1"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-21 (score 38, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-19 (score 37, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-18 (score 36, +4)

- [functional improvement] Stability: unverified → 0.27
- [functional improvement] Security disclosure: fail → pass

### 2026-08-12 (score 32, 0)

- [functional regression] Security disclosure: unverified → fail

### 2026-08-11 (score 32, +2)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-08-10 (score 30)

First indexed and scored.

## MCP tools (42)

### `atono_update_ai_context` (~375 tokens)

Atono: Update AI Context

Creates or updates an AI context resource for a backlog item (story or bug).
These resources provide the shared knowledge agents need to make better decisions across the lifecycle of a backlog item, from authoring through development, bug fixing, and maintenance.
Keeping them current improves the quality of future AI-assisted work on the item.

Always call `atono_get_ai_context` first. Read the current content, then write a synthesized version - do not append or prepend.
Atono retains prior versions automatically; the content should reflect current state, not a running log.
The synthesis approach varies by resource type:

    - DESIGN: Record product and scope decisions made during story authoring. Replace or update entries when decisions are revised or superseded. Written by authoring agents; consumed by all agents before and during implementation.

    - INVESTIGATION: Maintain current discoveries, research findings, and constraints. Remove anything superseded or proven incorrect.

    - SUMMARY: Maintain a current record of implementation changes. Preserve all entries unless a change has been explicitly reverted. Synthesis should organise and deduplicate — not compress or drop detail. The version history handles audit trail needs.

Args:
    story_or_bug_id_or_handle (str): Required. The id or handle of the backlog item (story or bug). Examples: `BUG-123`, `STORY-456`, `087e57c6-9183-47eb-a604-ef10ffbf450c`
    content (str): The synthesized content of the resource.
    kind (str): The resource type to create or update: DESIGN, INVESTIGATION, or SUMMARY.

Returns:
    str: The unique id of the created or updated resource.

Input parameters:

- `content` (string, required)
- `kind` (string)
- `story_or_bug_id_or_handle` (string, required)

Output parameters:

- `result` (string)

### `atono_get_ai_context` (~365 tokens)

Atono: Get AI Context

Fetches the latest version of an AI context resource for a backlog item (story or bug).
AI context resources provide the shared knowledge agents need to make better decisions across the lifecycle of a backlog item, from authoring through development, bug fixing, and maintenance.
Reading this before acting helps avoid redundant work, respect prior decisions, and build on existing knowledge.

Always call this before calling `atono_update_ai_context`.
Read the current content and synthesize it with your new findings into a single updated version - do not append or prepend.
Atono retains prior versions automatically; they do not need to be preserved in the content itself.

Supported resource types:

    - DESIGN: Product and scope decisions recorded during story authoring. Captures rationale, tradeoffs, and deferred items. Consult before and during implementation to understand why the story is scoped the way it is.

    - INVESTIGATION: Discoveries, research findings, and constraints identified during implementation. Consult before beginning or resuming any coding, debugging, or maintenance work.

    - SUMMARY: A record of implementation changes made by AI tools. Consult to understand what has already been built or modified before making further changes.

Args:
    story_or_bug_id_or_handle (str): Required. The id or handle of the backlog item (story or bug). Examples: `BUG-123`, `STORY-456`, `087e57c6-9183-47eb-a604-ef10ffbf450c`
    kind (str): The resource type to fetch: DESIGN, INVESTIGATION, or SUMMARY.

Returns:
    str: The latest version of the requested resource, or an empty string if none exists.

Input parameters:

- `kind` (string)
- `story_or_bug_id_or_handle` (string, required)

Output parameters:

- `result` (string)

### `atono_upload_file_url` (~100 tokens)

Atono: Get URL for Attachment Upload

Retrieves a safe URL to use for the upload of a file.

The caller is expected to perform a PUT HTTP request with the following HTTP headers:

x-amz-storage-class: INTELLIGENT_TIERING
x-amz-tagging: upload=start

The uploaded file will be held in the temporary staging area until it is attached to a Bug or Story with `atono_create_attachment` tool call.

Input parameters:

- `filename` (string, required)

Output parameters:

- `result` (string)

### `atono_create_attachment` (~186 tokens)

Atono: Create an attachment to a Story or Bug

Adds the staged attachment to the specified Story or Bug.

The attachment must be already uploaded to the staging area via the `atono_upload_file_url` tool call and a subsequent HTTP PUT request.

Args:
    id_or_handle (str): Required. The id or handle of the backlog item (story or bug). Examples: `BUG-123`, `STORY-456`, `087e57c6-9183-47eb-a604-ef10ffbf450c`
    position (str): Optional. Parameter that controls where the file appears in the attachment list. `start` - file is added at the beginning of the list, `end` (default) - file is added at the end of the list.
Returns:
    str: Message containing the id of a new attachment

Input parameters:

- `id_or_handle` (string, required)
- `position`

Output parameters:

- `result` (string)

### `atono_get_attachment` (~50 tokens)

Atono: Get Attachment

Returns information about an attachment, including its size and content type.

Most importantly returns an URL that can be used with a simple GET request to download the file.

Input parameters:

- `attachment_id` (string, required)

Output parameters:

- `contentType` (string): The detected content type of the attachment.
- `downloadUrl` (string): The URL for the content of the attachment.
- `id` (string): The unique identifier (UUID) of the attachment.
- `size` (integer): The size of the attached file in bytes.

### `atono_get_bug` (~187 tokens)

Atono: Get Bug

Retrieves the contents of a bug from your Atono workspace by its ID or handle.

After retrieving a bug, call `atono_get_ai_context` for the same item to read its AI context resources.
Reading INVESTIGATION and SUMMARY before acting ensures decisions are informed by prior research and implementation work on the bug.

The response includes key details such as the bug’s title, summary, reproduction steps, expected and actual behavior, workflow step, and related team context.

subtask_summary (dict): A summary of the bug’s subtasks, containing:
    total (int): The total number of subtasks.
    done (int): The number of subtasks in the Done workflow step.
    wont_do (int): The number of subtasks in the Won’t Do workflow step.
Zero values are returned if the bug has no subtasks.

Input parameters:

- `id_or_handle` (string, required)

Output parameters:

- `attachments` (array): The attachments of the bug.
- `content` (array): A description of the bug, including a summary, reproduction steps, and expected and actual behavior. Each chunk must include a type and value. Supports DISPLAY_HTML (HTML-formatted content) or TEXT (…
- `createdAt`: The date and time the bug was created.
- `cycleTimeMode`: Indicates whether the bug is marked as an OUTLIER (excluded) or remains NORMAL (included) in average cycle time calculations, reports, and staleness indicators.
- `deleted`: Whether the bug has been deleted.
- `doneAt`: The date and time when the bug was completed.
- `environments`: The list of affected environments.
- `handle` (string): A unique identifier for the bug, shown in the Atono application as the item ID (e.g., BUG-123).
- `id` (string): The unique identifier (UUID) of the bug.
- `position`: The bug’s vertical order within its current workflow step, where 0 is the topmost item. Position is relative to the step and team backlog.
- `stalenessIndicatorSnoozeUntil`: The date and time until which the staleness indicator is hidden for this bug in its current step and team backlog. Once the date passes, the indicator is shown again if the bug is still stale.
- `subtask_summary`: A summary of the backlog item's subtasks. Contains total (total count), done (subtasks in Done step), and wont_do (subtasks in Won't Do step). All values are zero when the backlog item has no subtask…
- `team`: The team the bug is currently assigned to.
- `title` (string): The title of the bug.
- `updatedAt`: The date and time the bug was last updated.
- `workflowStep`: The ID of the workflow step the bug is currently in.

### `atono_update_bug_step` (~123 tokens)

Atono: Update Bug's Workflow Step

Updates the workflow step of a bug in your Atono workspace.

Args:
    bug_id (str): The unique ID or handle of the bug. Handles will be resolved to IDs. Example UUID: `087e57c6-9183-47eb-a604-ef10ffbf450c`
    step_id (str): The ID of a valid workflow step defined for the team the bug is currently assigned to.

Returns:
    str: A message confirming success.

Input parameters:

- `bug_id` (string, required)
- `step_id` (string, required)

Output parameters:

- `result` (string)

### `atono_update_bug` (~260 tokens)

Atono: Update Bug

Updates an existing bug in your Atono workspace.

It first fetches the current bug details, then applies the provided updates.
If any optional field is provided, it will replace the corresponding field of the bug.

Args:
    bug_id (str): The unique ID or handle of the bug to update.
    title (Optional[str]): The new title of the bug.
    summary (Optional[str]): A brief summary of the bug.
    reproduction_steps (Optional[list[str]]): A list of steps to reproduce the bug.
    expected_behavior (Optional[str]): What should happen when the feature works correctly.
    actual_behavior (Optional[str]): What actually happens (the buggy behavior).
    team_id (Optional[str]): The ID of the team to assign the bug to. Accepted values: string or null. Pass null to unassign; omit to leave unchanged.
    environment_ids (Optional[list[str]]): The IDs of the environments affected by the bug.

Returns:
    str: A message confirming the update.

Input parameters:

- `actual_behavior`
- `bug_id` (string, required)
- `environment_ids`
- `expected_behavior`
- `reproduction_steps`
- `summary`
- `team_id`
- `title`

Output parameters:

- `result` (string)

### `atono_document_bug_fix` (~48 tokens)

Atono: Document Bug Fix Details

Updates a bug’s description in your Atono workspace by adding details of the fix in plain English.

Input parameters:

- `fix_description` (string, required)
- `id_or_handle` (string, required)

Output parameters:

- `attachments` (array): The attachments of the bug.
- `content` (array): A description of the bug, including a summary, reproduction steps, and expected and actual behavior. Each chunk must include a type and value. Supports DISPLAY_HTML (HTML-formatted content) or TEXT (…
- `createdAt`: The date and time the bug was created.
- `cycleTimeMode`: Indicates whether the bug is marked as an OUTLIER (excluded) or remains NORMAL (included) in average cycle time calculations, reports, and staleness indicators.
- `deleted`: Whether the bug has been deleted.
- `doneAt`: The date and time when the bug was completed.
- `environments`: The list of affected environments.
- `handle` (string): A unique identifier for the bug, shown in the Atono application as the item ID (e.g., BUG-123).
- `id` (string): The unique identifier (UUID) of the bug.
- `position`: The bug’s vertical order within its current workflow step, where 0 is the topmost item. Position is relative to the step and team backlog.
- `stalenessIndicatorSnoozeUntil`: The date and time until which the staleness indicator is hidden for this bug in its current step and team backlog. Once the date passes, the indicator is shown again if the bug is still stale.
- `subtask_summary`: A summary of the backlog item's subtasks. Contains total (total count), done (subtasks in Done step), and wont_do (subtasks in Won't Do step). All values are zero when the backlog item has no subtask…
- `team`: The team the bug is currently assigned to.
- `title` (string): The title of the bug.
- `updatedAt`: The date and time the bug was last updated.
- `workflowStep`: The ID of the workflow step the bug is currently in.

### `atono_update_bug_assignee` (~115 tokens)

Atono: Update Bug's Assignee

Updates the assignee of a bug in your Atono workspace.

Args:
    bug_id (str): The unique ID or handle of the bug. Examples: `BUG-123`, `087e57c6-9183-47eb-a604-ef10ffbf450c`
    user_id (str): The ID of a user in the workspace. If user_id is not provided, the bug will be unassigned.

Input parameters:

- `bug_id` (string, required)
- `user_id`

Output parameters:

- `result` (string)

### `atono_create_bug` (~332 tokens)

Atono: Create Bug

Creates a new bug in your Atono workspace.

Bugs are simpler than stories and contain a single HTML body with structured sections for
summary, reproduction steps, expected behavior, and actual behavior.

Args:
    title (str): The title of the bug.
    summary (str): A brief summary of the bug.
    reproduction_steps (list[str]): A list of steps to reproduce the bug. Each list item will become an <li> element.
    expected_behavior (str): What should happen when the feature works correctly.
    actual_behavior (str): What actually happens (the buggy behavior).
    team_id (Optional[str]): The ID of the team to assign the bug to (optional). Use the atono_list_teams tool to retrieve valid team IDs.
        If not provided, the bug will be assigned based on the workflow step's allowNewItems setting.
    assignee_id (Optional[str]): The ID of a user in the workspace (optional). If assignee_id is not provided, the bug will be unassigned.
    environment_ids (Optional[list[str]]): The IDs of the environments affected by the bug (optional). Use the `atono_list_environments` tool to retrieve valid environment IDs.

Returns:
    str: The handle of the created bug (e.g., BUG-123).

Input parameters:

- `actual_behavior` (string, required)
- `assignee_id`
- `environment_ids`
- `expected_behavior` (string, required)
- `reproduction_steps` (array, required)
- `summary` (string, required)
- `team_id`
- `title` (string, required)

Output parameters:

- `result` (string)

### `atono_list_environments` (~35 tokens)

Atono: List Environments

Retrieves the list of environments in your Atono workspace.

Returns:
    list[AtonoEnvironment]: A list of environments.

Output parameters:

- `result` (array)

### `atono_create_epic` (~238 tokens)

Atono: Create Epic

Creates a new epic in your Atono workspace.

Args:
    title (str): The title of the epic.
    stories (Optional[list[dict[str, str]]]): A list of user story objects, each containing:
        content (str): The full user story statement in the format "As a [persona], I want to [action or feature] so that [benefit or reason]."
        persona (str): The role or user type the story is written for (e.g. "product owner", "developer"). Use the atono_list_story_personas tool to retrieve valid personas defined in your workspace. If no reasonable match exists, provide a new persona name and Atono will create it automatically.
    description (Optional[str]): Supplementary content, such as implementation notes or reference material,
        to include in the epic's content field. Each entry supports a limited subset of HTML formatting.
        Defaults to no content when omitted.

Returns:
    str: The handle of the created epic (e.g., EPIC-123).

Input parameters:

- `description`
- `stories` (required)
- `title` (string, required)

Output parameters:

- `result` (string)

### `atono_list_epics` (~205 tokens)

Atono: List Epics

Retrieves the list of epics in your Atono workspace.

Use this to discover the epics in the workspace and resolve an epic's handle
(e.g., EPIC-123) before calling another tool that needs it (such as fetching
epic details or associating a story with an epic). Results are ordered by
most-recently-updated first.

Args:
    keyword (Optional[str]): Optional case-insensitive substring used to
        filter epics by title. When provided, only epics whose title contains
        the substring are returned. When omitted, all epics are returned.

Returns:
    list[AtonoEpicSummary]: A list of epics, each containing the epic's id,
    handle, and title. If the result set was truncated or a page fetch
    failed, returns a dict with a "data" key containing the partial list and
    a "warning" key describing what happened.

Input parameters:

- `keyword`

Output parameters:

- `result`

### `atono_get_epic` (~273 tokens)

Atono: Get Epic

Retrieves an epic from your Atono workspace by its ID or handle.

An epic is a container that groups related stories under a shared goal. This
tool returns the epic's title and description, the user story statements that
define it, and a lean summary of its constituent stories in their defined
order.

Args:
    id_or_handle (str): The unique ID or handle of the epic. Examples: `EPIC-12`, `epic5678-1234-5678-abcd-ef0123456789`

Returns:
    AtonoEpic: The epic, containing:
        title (str): The epic title.
        description (Optional[str]): The epic's supplementary description content, or None when absent.
        user_stories (list): The epic's user story statements, each with content and an optional persona.
        stories (list): The constituent stories in their defined order (empty when there are none). Each story has:
            handle (str): The story's handle (e.g. STORY-123).
            title (str): The story title.
            workflow_step (Optional[str]): The name of the story's current workflow step.
            order (int): The story's position within the epic; lower values appear first.

Input parameters:

- `id_or_handle` (string, required)

Output parameters:

- `description`: The epic's supplementary description content.
- `handle` (string): A unique identifier shown in Atono as the item ID (e.g. EPIC-12).
- `id` (string): The unique identifier (UUID) of the epic.
- `stories` (array): Constituent stories in their defined order; empty if none.
- `title` (string): The epic title.
- `userStories` (array): The epic's user story statements.

### `atono_add_story_to_epic` (~223 tokens)

Atono: Add Story to Epic

Adds a story to an epic in your Atono workspace.

The story is appended to the end of the epic's ordered story list. If the
story is already assigned to the specified epic, no changes are made and a
success message is returned (the call is idempotent). If the story is
already assigned to a different epic, it is moved to the specified epic.

Use `atono_list_epics` to find a valid epic handle before calling this tool.

Args:
    story_handle (str): The handle of the story to add (e.g. `STORY-123`).
        A bare UUID is also accepted.
    epic_handle (str): The handle of the epic to add the story to (e.g.
        `EPIC-12`). A bare UUID is also accepted.

Returns:
    str: A message confirming the story was added to the epic, or that it
    was already a member of the epic.

Input parameters:

- `epic_handle` (string, required)
- `story_handle` (string, required)

Output parameters:

- `result` (string)

### `atono_update_epic_title` (~126 tokens)

Atono: Update Epic Title

Updates the title of an epic in your Atono workspace. Epic titles must be unique.

Args:
    epic_handle (str): Required. The handle of the epic to update (e.g. EPIC-12).
        Use atono_list_epics to find valid epic handles.
    title (str): Required. The new title for the epic. Must be unique amongst
        epics, up to 200 characters.

Returns:
    str: A message confirming the update was made.

Input parameters:

- `epic_handle` (string, required)
- `title` (string, required)

Output parameters:

- `result` (string)

### `atono_update_epic_description` (~142 tokens)

Atono: Update Epic Description

Updates the description of an epic in your Atono workspace. The provided value replaces the existing description in full.

Args:
    id_or_handle (str): Required. The unique ID or handle of the epic (e.g. EPIC-12).
        Use atono_list_epics to find valid epic handles.
    description (str): Required. The new description for the epic. Must be a non-empty
        string. Up to 100k characters. Replaces the existing description in full.

Returns:
    str: A message confirming the update was made.

Input parameters:

- `description` (string, required)
- `id_or_handle` (string, required)

Output parameters:

- `result` (string)

### `atono_update_epic_user_stories` (~225 tokens)

Atono: Update Epic User Stories

Replaces all user story statements on an epic in your Atono workspace.

Args:
    epic_handle (str): Required. The handle of the epic to update (e.g. EPIC-12).
        Use atono_list_epics to find valid epic handles.
    stories (list[dict[str, str]]): Required. The complete list of user story objects
        to set on the epic. Replaces all existing user story statements. Each object must contain:
            content (str): The full user story statement in the format
                "As a [persona], I want to [action or feature] so that [benefit or reason]."
            persona (str): The role or user type the story is written for.
                Use atono_list_story_personas to retrieve valid personas. If no reasonable
                match exists, provide a new persona name and Atono will create it automatically.

Returns:
    str: A message confirming the update was made.

Input parameters:

- `epic_handle` (string, required)
- `stories` (array, required)

Output parameters:

- `result` (string)

### `atono_remove_story_from_epic` (~163 tokens)

Atono: Remove Story from Epic

Removes a story from an epic in your Atono workspace.

If the story is not currently assigned to the specified epic, an error is
returned. Use `atono_list_epics` to find a valid epic handle before calling
this tool.

Args:
    story_handle (str): The handle of the story to remove (e.g. `STORY-123`).
        A bare UUID is also accepted.
    epic_handle (str): The handle of the epic to remove the story from (e.g.
        `EPIC-12`). A bare UUID is also accepted.

Returns:
    str: A message confirming the story was removed from the epic.

Input parameters:

- `epic_handle` (string, required)
- `story_handle` (string, required)

Output parameters:

- `result` (string)

### `atono_configuration` (~27 tokens)

Atono: Check configuration

Connects to your Atono workspace using the provided API key and returns basic configuration details.

Output parameters:

- `result` (string)

### `atono_get_glossary` (~22 tokens)

Atono: Get Glossary

Returns the entire product glossary in the TSV format

Output parameters:

- `result` (string)

### `atono_get_story` (~392 tokens)

Atono: Get Story

Retrieves the contents of a story from your Atono workspace by its ID or handle.

After retrieving a story, call `atono_get_ai_context` for the same item to read its AI context resources.
Reading DESIGN, INVESTIGATION, and SUMMARY before acting ensures decisions are informed by the history of authoring and implementation work on the item.

Acceptance criteria are returned as an array of objects. Each object has:
    description (string): The text of the criterion. May contain a limited subset of HTML formatting: <strong> (bold), <em> (italic), <u> (underline), <s> (strikethrough), <code> (inline code), and <a href="URL"> (external links). No other HTML tags are permitted.
    position (integer): The order of the criterion within the list. Lower values appear first.
    level (integer): The depth in the hierarchy. 0 = top-level criterion; 1 = child of the nearest preceding level-0 criterion; 2 = child of the nearest preceding level-1 criterion, and so on. For example, a criterion with position=0, level=0 is the first top-level item (AC #1), and a criterion with position=1, level=1 is its first child (AC #1a).

The fullText field contains a pre-rendered plain text version of the story including an indented, numbered representation of the AC hierarchy suitable for quick reading.

subtask_summary (dict): A summary of the story's subtasks, containing:
    total (int): The total number of subtasks.
    done (int): The number of subtasks in the Done workflow step.
    wont_do (int): The number of subtasks in the Won't Do workflow step.
Zero values are returned if the story has no subtasks.

Input parameters:

- `id_or_handle` (string, required)

Output parameters:

- `acceptanceCriteria` (array): The acceptance criteria of the story.
- `additionalContent` (array): Optional context shown below the acceptance criteria. Often used for background info, technical notes, or decisions. Supports DISPLAY_HTML and TEXT content chunks.
- `attachments` (array): The attachments of the story.
- `content` (array): Displayed at the top of the story and represents the user story statement ('As a... I want... so that...'). The array may include TEXT, PERSONA, and DISPLAY_HTML chunks. Use DISPLAY_HTML when you wan…
- `createdAt`: The date and time the story was created.
- `cycleTimeMode`: Indicates whether the story is marked as an OUTLIER (excluded) or remains NORMAL (included) in average cycle time calculations, reports, and staleness indicators.
- `deleted`: Whether the story has been deleted.
- `doneAt`: The date and time when the story was completed.
- `fullText`: The story’s main content and all acceptance criteria as a single formatted text block (may include minimal HTML). Should be used by AI agents to help with understanding the relationships between diff…
- `handle` (string): A unique identifier for the story, shown in the Atono application as the item ID (e.g., STORY-123).
- `id` (string): The unique identifier (UUID) of the story.
- `position`: The story’s vertical order within its current workflow step, where 0 is the topmost item. Position is relative to the step and team backlog.
- `stalenessIndicatorSnoozeUntil`: The date and time until which the staleness indicator is hidden for this story in its current step and team backlog. Once the date passes, the indicator is shown again if the story is still stale.
- `subtask_summary`: A summary of the backlog item's subtasks. Contains total (total count), done (subtasks in Done step), and wont_do (subtasks in Won't Do step). All values are zero when the backlog item has no subtask…
- `team`: The team the story is currently assigned to.
- `title` (string): The title of the story.
- `updatedAt`: The date and time the story was last updated.
- `workflowStep`: The ID of the workflow step the story is currently in.

### `atono_list_timebox_items` (~218 tokens)

Atono: List Stories and Bugs in a Timebox

Retrieves the list of stories and bugs in a timebox.

Args:
    timebox (str): The timebox identifier. Can be either a UUID or a search string.
        If a non-UUID string is provided, the function will search for matching timeboxes
        and use the unique match, or raise an error if multiple matches are found.
    include_stories (bool): Whether to include stories in the result. Defaults to True.
    include_bugs (bool): Whether to include bugs in the result. Defaults to True.

Returns:
    list[AtonoBacklogItem]: A list containing stories and/or bugs that belong to the
    specified timebox. If the result set was truncated or a page fetch failed for either
    stories or bugs, returns a dict with a "data" key containing the partial list and a
    "warning" key describing what happened.

Input parameters:

- `include_bugs` (boolean)
- `include_stories` (boolean)
- `timebox` (string, required)

Output parameters:

- `result`

### `atono_list_story_personas` (~292 tokens)

Atono: List Story Personas

Retrieves the list of story personas in your Atono workspace.

Use this tool to get valid persona names before creating or updating user
story content. Persona names returned by this tool can be used directly in
the persona field when creating or updating stories.

Prioritize personas in this list when creating or updating stories. Only
use a new persona if no reasonable match exists for the persona you need.
If the user requests a persona that does not exist in this list or if the
persona to use is not clear, ask the user to specify which persona to use.

You do not need to create a new persona first — simply provide the new
persona name directly in the user story text and Atono will create it
automatically.

If the user explicitly requests to create a new persona, go ahead and use
that persona in the story, without asking for confirmation.

If the name of a new persona is misspelled, correct it and ask the user
to confirm the correction.

If the persona name is corrected, make sure to update every instance of
the persona name in the story title, description, and acceptance criteria.

Returns:
    list[AtonoStoryPersona]: A list of personas. If the result set was truncated or a
    page fetch failed, returns a dict with a "data" key containing the partial list and
    a "warning" key describing what happened.

Output parameters:

- `result` (array)

### `atono_create_story` (~563 tokens)

Atono: Create Story

Creates a new story in your Atono workspace.

Story creation and design decision capture are two steps of the same authoring act.
After creating a story, immediately call `atono_update_ai_context` with DESIGN to record the rationale, tradeoffs, and scoping choices made during authoring.
This ensures all agents have the product intent when they pick up the work.

Args:
    title (str): The title of the story.
    stories (list[dict[str, str]]): A list of user story objects, each containing:
        content (str): The full user story statement in the format "As a [persona], I want to [action or feature] so that [benefit or reason]."
        persona (str): The role or user type the story is written for (e.g. "product owner", "developer"). Use the atono_list_story_personas tool to retrieve valid personas defined in your workspace. If no reasonable match exists, provide a new persona name and Atono will create it automatically.
    acceptance_criteria (list[AtonoAcceptanceCriterion]): A list of acceptance criteria for the story. Each criterion has:
        description (string): The text of the criterion. A limited subset of HTML formatting is supported: <strong> (bold), <em> (italic), <u> (underline), <s> (strikethrough), <code> (inline code), and <a href="URL"> (external links). No other HTML tags are permitted.
        position (integer): The order of the criterion within the list. Lower values appear first.
        level (integer): The depth in the hierarchy. 0 = top-level criterion; 1 = child of the nearest preceding level-0 criterion; 2 = child of the nearest preceding level-1 criterion, and so on. For example, a criterion with position=0, level=0 is the first top-level item (AC #1), and a criterion with position=1, level=1 is its first child (AC #1a).
    team_id: The ID of the team to assign the story to (optional). Use the list_teams tool to retrieve valid team IDs. If not provided, the story is added to the Story Refinement.
    additional_content (Optional[lis…

Input parameters:

- `acceptance_criteria` (array, required)
- `additional_content`
- `stories` (array, required)
- `team_id`
- `title` (string, required)

Output parameters:

- `result` (string)

### `atono_update_story_step` (~116 tokens)

Atono: Update Story's Workflow Step

Updates the workflow step of a story in your Atono workspace.

Args:
    story_id (str): The unique ID or handle of the story. Example ID: `087e57c6-9183-47eb-a604-ef10ffbf450c`
    step_id (str): The ID of a valid workflow step defined for the team the story is currently assigned to.

Returns:
    str: A message confirming success.

Input parameters:

- `step_id` (string, required)
- `story_id` (string, required)

Output parameters:

- `result` (string)

### `atono_update_story_assignee` (~116 tokens)

Atono: Update Story's Assignee

Updates the assignee of a story in your Atono workspace.

Args:
    story_id (str): The unique ID or handle of the story. Examples: `STORY-456`, `087e57c6-9183-47eb-a604-ef10ffbf450c`
    user_id (str): The ID of a user in the workspace. If user_id is not provided, the story will be unassigned.

Input parameters:

- `story_id` (string, required)
- `user_id`

Output parameters:

- `result` (string)

### `atono_update_story_ac` (~371 tokens)

Atono: Update Story's Acceptance Criterion

Replaces all acceptance criteria of a story in your Atono workspace.

Always call `atono_get_story` first to retrieve existing AC IDs before updating.
Providing known IDs preserves content associated with each criterion (comments, attachments, usage metrics).
Omitting an ID causes a new criterion to be created, losing any associated content.

If AC changes reflect meaningful scope decisions, update DESIGN via `atono_update_ai_context` to keep product intent in sync.

Args:
    story_id (str): The handle or unique ID of the story (UUID). Examples: `STORY-456`, `087e57c6-9183-47eb-a604-ef10ffbf450c`
    acceptance_criteria (List[AtonoAcceptanceCriterion]): The complete list of acceptance criteria to set on the story. Each criterion has:
        - id (str): The unique identifier (UUID) of the acceptance criterion. Optional; if not provided, a new UUID will be generated. If an ID is known, it is best to provide it to preserve content associated with an AC (Comments, Attachments, Usage Metrics, etc).
        - description: The text of the criterion. A limited subset of HTML formatting is supported: <strong> (bold), <em> (italic), <u> (underline), <s> (strikethrough), <code> (inline code), and <a href="URL"> (external links). No other HTML tags are permitted.
        - position: The order of the criterion within the list (lower values appear first)
        - level: The depth in the hierarchy (0 = top-level, 1 = child of nearest level-0, etc.)

Input parameters:

- `acceptance_criteria` (array, required)
- `story_id` (string, required)

Output parameters:

- `result` (string)

### `atono_update_story_content` (~323 tokens)

Atono: Update Story's Content

Updates the user story content of a story in your Atono workspace.

Important: This tool updates the story content area only. It does not modify acceptance criteria, additional content sections, or any other fields.

The content must be provided as an array of user story objects, each following the standard format: "As a [persona], I want to [action or feature] so that [benefit or reason]." Most stories have a single user story, but multiple are supported.

If story content changes reflect a meaningful shift in scope or persona, consider updating DESIGN via `atono_update_ai_context` to keep product intent in sync.

Args:
    story_id (str): The handle or unique ID of the story (UUID). Examples: `STORY-456`, `087e57c6-9183-47eb-a604-ef10ffbf450c`
    stories (list[dict[str, str]]): A list of user story objects, each containing:
        content (str): The full user story statement in the format "As a [persona], I want to [action or feature] so that [benefit or reason]."
        persona (str): The role or user type the story is written for (e.g. "product owner", "developer"). Use the atono_list_story_personas tool to retrieve valid personas defined in your workspace. If no reasonable match exists, provide a new persona name and Atono will create it automatically.

Input parameters:

- `stories` (array, required)
- `story_id` (string, required)

Output parameters:

- `result` (string)

### `atono_update_story_title` (~145 tokens)

Atono: Update Story's Title

Updates the title of a story in your Atono workspace.

Important: This tool updates the title only. It does not modify the story content, acceptance criteria, additional content, or any other fields.

Args:
    story_id (str): The unique ID or handle of the story. Example ID: `087e57c6-9183-47eb-a604-ef10ffbf450c`; handle: `STORY-123`
    title (str): Required. The new title to set on the story.

Returns:
    str: A message confirming the update was made.

Input parameters:

- `story_id` (string, required)
- `title` (string, required)

Output parameters:

- `result` (string)

### `atono_update_story_additional_content` (~186 tokens)

Atono: Update Story's Additional Content

Replaces the additional content of a story in your Atono workspace.

Additional content appears below the acceptance criteria and is typically used for background info, technical notes, decisions, or context for the team.

Args:
    story_id (str): The unique ID or handle of the story. Example ID: `087e57c6-9183-47eb-a604-ef10ffbf450c`; handle: `STORY-123`
    additional_content (list[str]): Required. A list of supplementary content entries, such as implementation notes or reference material, to include in the story's additional content field. Each entry supports a limited subset of HTML formatting. Pass an empty list to clear the additional content.

Returns:
    str: A message confirming the update was made.

Input parameters:

- `additional_content` (array, required)
- `story_id` (string, required)

Output parameters:

- `result` (string)

### `atono_update_story_team` (~148 tokens)

Atono: Updates the team assignment of a story in your Atono workspace.

Updates the team assignment of a story in your Atono workspace.

Args:
    story_id (str): The unique ID or handle of the story. Example ID: `087e57c6-9183-47eb-a604-ef10ffbf450c`; handle: `STORY-123`
    team_id (Optional[str]): Optional. The ID of the team to assign the story to. Use atono_list_teams to retrieve valid team IDs. If not provided, the story will be unassigned from its current team.

Returns:
    str: A message confirming the update was made.

Input parameters:

- `story_id` (string, required)
- `team_id` (required)

Output parameters:

- `result` (string)

### `atono_link_bugs_or_stories` (~191 tokens)

Atono: Links two backlog items in your Atono workspace.

Links two backlog items in your Atono workspace. Either item may be a story or a bug.

Args:
    item_handle_or_id_1 (str): The unique ID or handle of the story or bug. Example ID: `087e57c6-9183-47eb-a604-ef10ffbf450c`; handle: `STORY-123`, `BUG-456`
    item_handle_or_id_2 (str): The unique ID or handle of another story or bug. Example ID: `087e57c6-9183-47eb-a604-ef10ffbf450c`; handle: `STORY-123`, `BUG-456`

Returns:
    str: A message confirming the update was made.

Input parameters:

- `item_handle_or_id_1` (string, required)
- `item_handle_or_id_2` (string, required)

Output parameters:

- `result` (string)

### `atono_get_subtasks` (~213 tokens)

Atono: Get Subtasks

Retrieves the subtasks for a story or bug in your Atono workspace.

Args:
    id_or_handle (str): Required. The handle or unique ID of the story or bug
        (e.g. STORY-123 or BUG-456).

Returns:
    A list of subtasks, each containing:
        uuid (str): The unique identifier of the subtask. Use this to reference
            the subtask in atono_update_subtask or atono_delete_subtask.
        title (str): The subtask title.
        description (str): The subtask description, if set.
        assignee (str): The UUID of the assigned user, if any.
        workflow_step (str): The current workflow step — one of TODO, IN_PROGRESS,
            DONE, WONT_DO.
        order (int): The position of the subtask within the subtask list.

    An empty list is returned if the backlog item has no subtasks.

Input parameters:

- `id_or_handle` (string, required)

Output parameters:

- `result` (array)

### `atono_create_subtask` (~211 tokens)

Atono: Create Subtask

Creates a subtask on a story or bug in your Atono workspace. The subtask is appended to the end of the subtask list.

Args:
    id_or_handle (str): Required. The handle or unique ID of the parent story or bug (e.g. STORY-123 or BUG-456).
    title (str): Required. The title of the subtask.
    description (str): Optional. A description of the subtask.
    assignee_id (str): Optional. The ID of the user to assign the subtask to. Use atono_list_users to retrieve valid user IDs.
    workflow_step (str): Optional. The initial workflow step — one of To Do, In Progress, Done, Won't Do. Defaults to To Do.

Returns:
    The UUID of the created subtask.

Input parameters:

- `assignee_id`
- `description`
- `id_or_handle` (string, required)
- `title` (string, required)
- `workflow_step`

Output parameters:

- `result` (string)

### `atono_update_subtask` (~193 tokens)

Atono: Update Subtask

Updates a subtask in your Atono workspace. At least one optional field must be provided.

Args:
    uuid (str): Required. The unique identifier of the subtask.
        Use atono_get_subtasks to retrieve subtask UUIDs.
    title (str): Optional. The new title for the subtask.
    description (str): Optional. The new description for the subtask.
    assignee_id (str): Optional. The ID of the user to assign the subtask to.
        Use atono_list_users to retrieve valid user IDs.
    workflow_step (str): Optional. The new workflow step —
        one of To Do, In Progress, Done, Won't Do.

Returns:
    A message confirming the update was made.

Input parameters:

- `assignee_id`
- `description`
- `title`
- `uuid` (string, required)
- `workflow_step`

Output parameters:

- `result` (string)

### `atono_delete_subtask` (~73 tokens)

Atono: Delete Subtask

Deletes a subtask from your Atono workspace.

Args:
    uuid (str): Required. The unique identifier of the subtask to delete.
        Use atono_get_subtasks to retrieve subtask UUIDs.

Returns:
    A message confirming the subtask was deleted.

Input parameters:

- `uuid` (string, required)

Output parameters:

- `result` (string)

### `atono_list_timeboxes` (~132 tokens)

Atono: List Timeboxes

Retrieves the list of timeboxes in your Atono workspace.

Args:
    only_active (bool): apply filter to only return active timeboxes (optional, default false). Active timeboxes are those where the current date is on or before the endDate (i.e. in progress or future).

Returns:
    list[AtonoTimebox]: A list of timeboxes. If the result set was truncated or a page
    fetch failed, returns a dict with a "data" key containing the partial list and a
    "warning" key describing what happened.

Input parameters:

- `only_active` (boolean)

Output parameters:

- `result`

### `atono_list_teams` (~73 tokens)

Atono: List Teams

Retrieves the list of teams in your Atono workspace.

Returns:
    list[AtonoTeam]: A list of teams. If the result set was truncated or a page fetch
    failed, returns a dict with a "data" key containing the partial list and a "warning"
    key describing what happened.

Output parameters:

- `result`

### `atono_get_team_workflow` (~35 tokens)

Atono: Get Team's Workflow

Retrieves the workflow steps defined for a specific team in your Atono workspace.

Input parameters:

- `team_id` (string, required)

Output parameters:

- `result` (array)

### `atono_list_users` (~128 tokens)

Atono: List Users

Retrieves a list of the users in your Atono workspace.
If a team_id is provided, retrieves the members of the specified team.

Returns:
    list[dict]: A list of users with id, fullName, and email. If the result set was
    truncated or a page fetch failed, returns a dict with a "data" key containing the
    partial list and a "warning" key describing what happened. The warning is only
    possible when no team_id is provided, as the team members endpoint is not paginated.

Input parameters:

- `team_id`

Output parameters:

- `result`

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/io-atono-atono-mcp-server/docker-io-atonoio-atono-mcp-server-1-1-1#diagnostics

## Score history

- 2026-08-22: 38
- 2026-08-21: 38
- 2026-08-20: 37
- 2026-08-19: 37
- 2026-08-18: 36
- 2026-08-17: 32
- 2026-08-16: 32
- 2026-08-15: 32
- 2026-08-14: 32
- 2026-08-13: 32
- 2026-08-12: 32
- 2026-08-11: 32
- 2026-08-10: 30

## Common questions

### What is the Atono MCP server?

Atono is an MCP server listed in the public MCP registry as io.atono/atono-mcp-server. Give your AI coding tools your team's product context: stories, bugs, epics, and glossary. This page covers its container image (docker.io/atonoio/atono-mcp-server:1.1.1).

### Is the Atono MCP server safe to use?

Atono scores 38 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Atono MCP server expose?

Atono exposes 42 tools: atono_update_ai_context, atono_get_ai_context, atono_upload_file_url, atono_create_attachment, atono_get_attachment, and 37 more. Their descriptions and schemas cost roughly 7,939 tokens of context every time the server is loaded.

### Is the Atono MCP server still maintained?

Atono is still listed as active in the MCP registry. We last reached this channel on 22 August 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Repository: https://github.com/atono-io/atono-mcp-server
- Website: https://atono.io/
- Changelog RSS feed: https://verifymcp.io/servers/io-atono-atono-mcp-server/docker-io-atonoio-atono-mcp-server-1-1-1.xml
- Changelog JSON feed: https://verifymcp.io/servers/io-atono-atono-mcp-server/docker-io-atonoio-atono-mcp-server-1-1-1.json
- HTML version of this page: https://verifymcp.io/servers/io-atono-atono-mcp-server/docker-io-atonoio-atono-mcp-server-1-1-1