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

# Ions

> Understand the three Ion categories, the capabilities they carry, and how they form runtime Sequences.

An **Ion** is a composable unit that performs one job inside an [Aion](/docs/what-is-aion).

Each Ion groups the agentic primitives and configuration needed for that job. An Ion might connect the application to
a network, control how the application handles work, or make a live implementation available. You arrange Ions in
[Composer](/docs/composer) and connect them into runtime flows called **Sequences**.

An Ion is not the same thing as an AI agent. An agent is one capability an Ion can provide.

## The three Ion categories

Choose an Ion category by the responsibility it has in the application:

| Ion category                                         | Use it to                                                |
| ---------------------------------------------------- | -------------------------------------------------------- |
| [Distribution Ion](/docs/concepts/distribution-ions) | Connect an Aion to a network and anchor a Sequence.      |
| [Behavior Ion](/docs/concepts/behavior-ions)         | Interpret, transform, route, or answer work.             |
| [Deployment Ion](/docs/concepts/deployment-ions)     | Make a runnable implementation available to the Project. |

The category describes the Ion's job, not every interface it exposes. Adding an agent, MCP, or event capability does
not create another Ion category.

## Ions and Sequences

A **Sequence** is the ordered list of Ions used when work enters through a Distribution Ion. Connections between Ions
define which Ions participate in that flow.

```mermaid actions={false} theme={null}
flowchart LR
  DS["Slack<br/><small>Distribution Ion</small>"] --- P["Policy<br/><small>Behavior Ion</small>"]
  DA["A2A<br/><small>Distribution Ion</small>"] --- P
  P --- S["Support<br/><small>Behavior Ion</small>"]
  S --- D["Support service<br/><small>Deployment Ion</small>"]
```

Read the graph from either Distribution Ion:

* **Slack Sequence:** Slack → Policy → Support → Support service
* **A2A Sequence:** A2A → Policy → Support → Support service

Each Distribution anchors its own Sequence. The shared Policy, Support, and Support service Ions let both entrypoints
reuse the same application flow.

This separation lets you:

* add a Distribution Ion for another network without duplicating application behavior
* reuse a Behavior Ion across several Sequences
* update a Deployment Ion without redesigning the application's network entrypoints

An Ion's position belongs to the Sequence, not its category. An Ion that finishes one flow can participate earlier in
another; there is no separate terminal-Ion category.

## Capabilities

A capability is a service surface an Ion can make available as part of its job. Do not think of an Ion as an AI agent
itself. The Ion is the building block; agent, MCP, and event interfaces are capabilities it can carry.

| Capability    | What it lets an Ion do                                         |
| ------------- | -------------------------------------------------------------- |
| Agent and A2A | Participate in agent-to-agent communication.                   |
| MCP           | Offer tools or resources to authorized clients and other Ions. |
| Events        | Publish or subscribe to application events.                    |

An implementation declares the capabilities it supports. The Ion's runtime configuration determines which supported
capabilities are enabled and supplies any settings or authentication they require.

An Ion can carry one capability, combine several, or expose none. Its category still describes the goal it serves:
Distribution, Behavior, or Deployment.

## Ions, Projects, and Aions

Ions live in Project graphs. A Project stores the Ions, their connections, and the configuration used to work on them
together.

A Project is not an Aion. An Aion follows its [Identity](/docs/concepts/identities), while Projects organize the Ions
used to implement it:

* One Project can contain Ions serving several Aion Identities.
* One Aion can use Ions and Sequences assembled in more than one Project.

## What to do next

* To create and connect Ions, follow [Build an Aion](/docs/usage/building-an-aion).
* To understand the visual editing workflow, read [Composer](/docs/composer).
* To design network ingress, read [Distribution Ions](/docs/concepts/distribution-ions).
* To add reusable application logic, read [Behavior Ions](/docs/concepts/behavior-ions).
* To make an implementation available, read [Deployment Ions](/docs/concepts/deployment-ions).