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

# What is Aion?

> Build Once, Distribute Everywhere.

Aion, or the All-In-One Network, is a network harness, event fabric, and meta-orchestration tool that allows you to:

* implement modular AI agents in your framework of choice
* standardize on a single, normalized messenging protocol (A2A)
* link agents to identities for addressing and permissions
* connect agents both to each other and to other networks

Aion treats the agent as the core primitive in what we call an Agentic Application, where the application itself is simply a subnetwork of specialized agents that know how to discover and communicate with each other. Think of it like a microservices architecture where we replace services with agents and APIs with A2A, MCP, and other agent-native surfaces.

In the following sections we'll illustrate this concept from the bottom-up so you can see how it works.

<div className="aion-what-is-aion">
  <section className="aion-split-row">
    <div className="aion-split-copy">
      <h3>The Core Primitive: Agents</h3>

      <p>
        The fundamental unit of Aion is the agent. However, we are neither an agent-builder nor orchestrator.
        Instead, you build agents using your preferred framework or tooling, and we provide the network infrastructure to connect them.
        Our SDKs currently support agents built in Python using LangGraph or Google's ADK, and the Aion control plane can dispatch
        to any agent exposing an A2A endpoint.
      </p>
    </div>

    <div className="aion-split-visual">
      <img src="https://mintcdn.com/terminalresearch/U5b_gYmF7c3DqmoT/assets/what-is-aion/agent-primitive.png?fit=max&auto=format&n=U5b_gYmF7c3DqmoT&q=85&s=60b83d131af7cd08e020130bf2914a55" alt="Diagram showing the Aion agent primitive across frameworks, SDKs, and the A2A network." width="816" height="254" data-path="assets/what-is-aion/agent-primitive.png" />
    </div>
  </section>

  <section className="aion-split-row">
    <div className="aion-split-copy">
      <h3>Defining an Agent</h3>

      <p>
        In Aion, an agent is composed of three key components:

        * Behavior - an agent's static logic; it's source implementation
        * Environment - the agent's runtime configuration
        * Identity - the agent's unique identifier and permissions

        Your agent's *Behavior*, such as a LangGraph implementation, is what gets deployed into Aion, and its packaged `aion.yaml` allows you
        to specify what configuration options you'd like to expose. In the Aion control plane, a *Behavior*
        is paired with an *Environment* so you can optionally configure runtime configuration and an *Identity*
        to define how the agent is addressed and authorized.
      </p>
    </div>

    <div className="aion-split-visual">
      ```mermaid theme={null}
      flowchart TD
        B[Behavior] --> A[Agent]
        C[Environment] --> A[Agent]
        D[Identity] --> A[Agent]
      ```
    </div>
  </section>

  <section className="aion-split-row">
    <div className="aion-split-copy">
      <h3>Agent Capabilities</h3>

      <p>
        Agents may expose multiple *capabilities* used to independently interact with them:

        * A2A - an Agent-to-Agent protocol endpoint for natural language communications
        * MCP - an Model Context Protocol endpoint for direct tool access
        * Events - a subscription-based event stream for real-time updates
      </p>
    </div>

    <div className="aion-split-visual">
      ```mermaid actions={false} theme={null}
      flowchart TD
        A[Agent] --> B[A2A]
        A --> C[MCP]
        A --> D[Events]
      ```
    </div>
  </section>

  <section className="aion-split-row">
    <div className="aion-split-copy">
      <h3>Agentic Applications</h3>

      <p>
        An agentic application is a collection of agents that work together to achieve a common goal.
      </p>

      <p>
        In the Aion control plane, a *Project* is the unit of organization for an agentic application.
        Projects are composed of nodes, each of which is an *agent*.
      </p>

      <p>
        Nodes representing a deployed behavior are called *Behavior Nodes*. These shouldn't be confused as
        only containing an agent's *Behavior*. In a project, every node also contains *Environment* and *Identity* configuration.
      </p>
    </div>

    <div className="aion-split-visual">
      ```mermaid actions={false} theme={null}
      flowchart TD
        subgraph seq ["Project"]
          direction TB
          C["GitHub<br/><small>Deployment</small>"] --> D["Support Agent<br/><small>Behavior</small>"] 
          C--> E["CRM Agent<br/><small>Behavior</small>"]
        end
      ```
    </div>
  </section>

  <section className="aion-split-row">
    <div className="aion-split-copy">
      <h3>Integrating With Other Networks</h3>

      <p>
        Behavior Nodes can be connected to other networks by connecting them to a Distribution Node.
      </p>

      <p>
        Distribution Nodes act as normalized bridges to different networks, allowing agents to communicate
        across heterogenous network boundaries.
      </p>
    </div>

    <div className="aion-split-visual">
      ```mermaid actions={false} theme={null}
      flowchart TD
        subgraph seq ["Project"]
          A["Support Agent<br/><small>Behavior</small>"] <--> B["Email<br/><small>Distribution</small>"]
          A <--> C["Telephone<br/><small>Distribution</small>"]
          A <--> D["Telegram<br/><small>Distribution</small>"]
        end
      ```
    </div>
  </section>

  <section className="aion-split-row">
    <div className="aion-split-copy">
      <h3>Connecting Agents in Sequences </h3>

      <p>
        Aion allows you to connect agents in sequences to define the request/response path from a
        *Distribution* node to a terminal *Behavior* node.
      </p>

      <p>
        Agents defined in *Behavior* nodes can act as middleware for other agents to enable specialization and reuse through decomposition.
        In this example, a request follows this path:

        * Distribution Node: Telegram
        * Behavior Node: Brand Policy Agent
        * Behavior Node: x402 Agent
        * Behavior Node: Stock Portfolio Agent
        * Behavior Node: x402 Agent
        * Behavior Node: Brand Policy Agent
        * Distribution Node: Telegram
      </p>

      <p>
        At each step, a request or response can be augmented or rejected.
      </p>
    </div>

    <div className="aion-split-visual">
      ```mermaid actions={false} theme={null}
      flowchart TD
        subgraph seq ["Project"]
          A["GitHub<br/><small>Deployment</small>"] --> B1["Stock Portfolio Agent<br/><small>Behavior</small>"]
          B1 <--> B3["x402 Agent<br/><small>Behavior</small>"]
          B3 <--> B4["Brand Policy Agent<br/><small>Behavior</small>"]
          B4 <--> C["Email<br/><small>Distribution</small>"]
          B4 <--> D["Telegram<br/><small>Distribution</small>"]
        end
      ```
    </div>
  </section>

  <section className="aion-split-row">
    <div className="aion-split-copy">
      <h3>Connecting Agents through Discovery</h3>

      <p>
        Agents are not required to follow a strict request/response flow.
        Since agents expose a set of *Capabilities* (A2A, MCP, Events) and a unique *Identity*,
        other Application agents can communicate with them in a few ways:

        * Direct Addressing: `a2aMessage("@s3", "store this file", fileContent)`.
        * Events: `subscribe("@bug-recon", "critical-error-detected")`
        * Discovery: `toolSearchTool("file storage")` or `a2aSearchTool("linear")`
      </p>
    </div>

    <div className="aion-split-visual">
      ```mermaid actions={false} theme={null}
      flowchart TD
        subgraph seq ["Project"]
          A["GitHub<br/><small>Deployment</small>"] ~~~ Z1["S3 Agent<br/><small>Behavior</small>"]
          A --> B1["Bug Recon Agent<br/><small>Behavior</small>"]
          B1 <--> C["Slack<br/><small>Distribution</small>"]
          B1 <--> D["Sentry.io<br/><small>Distribution</small>"]
          A ~~~ Z2["Linear Agent<br/><small>Behavior</small>"]
        end
      ```
    </div>
  </section>
</div>