> ## 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.

# Deployment Ions

> How Deployment Ions connect runnable implementations to Projects and manage Stable and Beta releases.

A **Deployment Ion** makes a live application implementation available inside a Project.

It defines where the implementation comes from, who hosts it, and how Aion makes its released versions available.
[Behavior Ions](/docs/concepts/behavior-ions) can then follow the Stable or Beta release from the Deployment Ion.

## What a Deployment Ion manages

| Concern            | What it represents                                                                              |
| ------------------ | ----------------------------------------------------------------------------------------------- |
| Source or endpoint | The repository, Aion runtime, or A2A service that provides the implementation.                  |
| Hosting            | Whether Aion or your own infrastructure runs the service.                                       |
| Configuration      | Source-specific values such as a branch, source directory, or server URL.                       |
| Versions           | Builds or remote service revisions available to the Project.                                    |
| Release channels   | The versions currently designated Stable and Beta.                                              |
| Capacity           | Instance size, replica limits, and warm-runtime settings for GitHub Deployments hosted by Aion. |

These controls describe how the implementation becomes available. They do not define how network traffic enters the
Aion or what responsibility the implementation has inside a Sequence.

## Deployment Type

The right Deployment type depends on where the application runs and how it describes the implementation to Aion.

| Deployment type | Use it when                                                                                     |
| --------------- | ----------------------------------------------------------------------------------------------- |
| GitHub          | Aion should build and run application source from a connected GitHub repository.                |
| Aion Hosted     | You host an Aion SDK runtime and want Aion to discover the application endpoints it provides.   |
| A2A Remote      | You want to connect one existing A2A-compatible service without moving it onto an Aion runtime. |

### GitHub

Use **GitHub** when you want Aion to build, deploy, and operate your application from source.

Connect a GitHub account, select a repository and branch, and optionally set a source directory when the application
does not live at the repository root. Repository events can create new versions automatically.

Because Aion runs this Deployment, you can configure its instance size, maximum replicas, and warm-runtime behavior.
You can also promote successfully registered versions to Stable or Beta automatically.

### Aion Hosted

Use **Aion Hosted** when you run an [Aion SDK server](/sdk/python) on infrastructure you control. This option keeps
your existing hosting and operations while connecting the runtime to Aion's control plane.

Provide the server's base URL. Aion reads `/.well-known/manifest.json` to discover the application endpoints exposed
by that runtime. One server can describe multiple endpoints, allowing the Deployment Ion to make multiple
implementations available to the Project.

Aion does not build, scale, or restart this server. You are responsible for keeping the URL available and deploying
new revisions. Each remote version receives deployment client credentials; save the client secret when Aion displays
it and configure the runtime to use those credentials.

### A2A Remote

Use **A2A Remote** when an existing service already implements the [A2A Protocol](/a2a) and should remain on its
current infrastructure. The service does not need to use an Aion SDK.

Provide the service's base URL. Aion reads its `/.well-known/agent-card.json` and treats the service as one remote
implementation. Aion can route A2A requests to the endpoint and inspect its health, but it does not build or operate
the service.

Choose Aion Hosted for an Aion runtime that exposes multiple application endpoints. Choose A2A Remote to connect one
standalone A2A service.

## Versions and release channels

A Deployment Ion can produce multiple versions over time. GitHub-hosted deployments create versions from repository
activity, while Aion Hosted and A2A Remote versions are added by registering a new server URL.

Behavior Ions follow one of two release channels:

* **Stable** selects the version intended for normal use.
* **Beta** selects a version being evaluated and falls back to Stable when no Beta version is available.

You can promote a successfully registered version to Stable or Beta. GitHub Deployments can also promote new versions
automatically. Only one version occupies each release channel at a time.

This separation lets a Behavior Ion follow a channel while the Deployment Ion changes the version behind it.

## How Deployment Ions relate to other Ions

```mermaid actions={false} theme={null}
flowchart LR
  P["Support service<br/><small>Deployment Ion</small>"] -. discovers and registers .-> T
  D["Slack<br/><small>Distribution Ion</small>"] --> B["Policy<br/><small>Behavior Ion</small>"]
  B --> T["Support<br/><small>Behavior Ion · terminal position</small>"]
```

The solid arrows show Sequence execution. The dashed arrow shows registration and availability:

* The **Deployment Ion** deploys or connects the service and registers the Behaviors that service exposes.
* When the service first registers, Aion discovers those Behaviors and adds the corresponding Behavior Ions to the
  Deployment's owning Project. Registered Behaviors can also be added to other eligible Projects.
* The **Distribution Ion** starts execution by passing the request into the first Behavior Ion in its Sequence.
* Execution continues only through the Sequence's Behavior Ions. The Behavior Ion in the terminal position handles
  the final step.

Sequence execution never passes into a Deployment Ion. A connection between a Deployment Ion and a Behavior Ion
records where the Behavior came from; it is not an execution edge. **Terminal** describes a Behavior Ion's position
in this Sequence, not a separate Ion category.

Keeping deployment and execution separate lets you update hosting or promote a new version without redesigning the
network entrypoint or the Sequence.

The implementation made available by a Deployment Ion can support agent, MCP, or event capabilities. Those service
surfaces describe what the implementation can offer; they do not create another Ion category. See
[Capabilities](/docs/concepts/ions#capabilities) for the shared model.

## What to do next

* To add a Deployment Ion to a Project, read [Composer](/docs/composer).
* To control how an implementation participates in a Sequence, read [Behavior Ions](/docs/concepts/behavior-ions).
* To run an Aion SDK server, start with the [Python SDK](/sdk/python).
* To connect an existing agent-native service, read the [A2A Protocol overview](/a2a).