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

# Cloud Deployment Integration

> How Steward powers wallet management for hosted AI agents across a node fleet.

# Cloud Deployment Integration

A hosted cloud deployment can use Steward as the governance layer between its agent containers and the outside world. This guide describes a production topology managing dozens of AI agents across a node fleet with on-chain transactions on Base mainnet.

## Architecture

Each node runs Steward as the governance layer in front of its agent containers:

```
┌─────────────────────────────────────────┐
│                Cloud Node                 │
│                                           │
│  ┌──────────┐  ┌──────────┐             │
│  │steward   │  │steward   │             │
│  │api :3200 │  │proxy:8080│             │
│  └──────────┘  └──────────┘             │
│                                           │
│  ┌────────┐ ┌────────┐ ┌────────┐      │
│  │agent-1 │ │agent-2 │ │agent-3 │      │
│  │(Docker) │ │(Docker) │ │(Docker) │      │
│  └────────┘ └────────┘ └────────┘      │
└─────────────────────────────────────────┘
```

Each node runs:

* **Steward API** on port 3200 — agent CRUD, policy management, vault operations
* **Steward Proxy** on port 8080 — API credential injection (when enabled)
* **Agent containers** — ElizaOS-based agents connecting to Steward

## How Provisioning Works

When a new agent is created:

1. **The cloud provisioner** calls `POST /agents` to create the agent in Steward
2. **Wallet generated** — encrypted EVM + Solana keypairs
3. **Policies applied** — default policy template for the agent tier
4. **Agent token issued** — `POST /agents/:id/token` generates a scoped JWT
5. **Container created** with only `STEWARD_PROXY_URL` and `STEWARD_AGENT_TOKEN`
6. **Container starts** — agent boots, connects to its LLM via the proxy

```typescript theme={null}
// Simplified provisioning flow
const agent = await steward.createWallet(agentId, agentName, platformId);
await steward.setPolicies(agentId, defaultPolicies);
const token = await generateAgentToken(agentId);

// Container gets only these env vars:
const containerEnv = {
  STEWARD_PROXY_URL: "http://172.18.0.1:8080",
  STEWARD_AGENT_TOKEN: token,
};
```

## Production Reference

| Metric       | Value                       |
| ------------ | --------------------------- |
| Tenants      | multiple                    |
| Agents       | dozens                      |
| Transactions | on-chain, Base mainnet      |
| Nodes        | a horizontally scaled fleet |
| Uptime       | multi-day continuous        |

## Container Configuration

Agents use the `@stwd/eliza-plugin` for Steward integration. The plugin is baked into the container image:

```bash theme={null}
# Container environment
STEWARD_API_URL=http://172.18.0.1:3200
STEWARD_AGENT_TOKEN=stwd_jwt_...
STEWARD_AGENT_ID=agent-name
```

The `172.18.0.1` address is the Docker bridge gateway, allowing containers to reach Steward running on the host.

## Network Setup

Steward binds to `0.0.0.0:3200` so Docker containers can reach it via the bridge network:

```bash theme={null}
# On each node
STEWARD_BIND_HOST=0.0.0.0
STEWARD_PORT=3200
```

<Note>
  The `STEWARD_BIND_HOST=0.0.0.0` setting is required in a containerized deployment. Without it, containers cannot reach Steward because it only listens on localhost.
</Note>

## Deploying Your Own

To replicate this setup:

1. Deploy Steward ([Self-Hosting Guide](/guides/self-hosting))
2. Create a tenant for your platform
3. Set up the provisioning flow (agent creation → policy → token → container)
4. Use the ElizaOS plugin or SDK in your agent containers

## Related

* [Architecture](/concepts/architecture) — System design overview
* [Self-Hosting](/guides/self-hosting) — Deploy your own instance
* [ElizaOS Plugin](/guides/eliza-plugin) — Agent integration
* [Docker Guide](/guides/docker) — Container deployment