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

# Private Cloud Trust Harness

> The portable trust harness for AI on a laptop, server, private cloud, or confidential VM. Same identity, permissions, proofs, context, and Vault.

Same agent, wherever it runs.

**Do the work**

1. Add `https://mcp.proofable.me/mcp`, click **Connect**.
2. Create or import the agent (`proofable_agent_create`).
3. Open **Connections** if the work needs an app.
4. Chat now, or start a Pro job.

On Proofable, hosted jobs use the Operator engine. For an isolated coding computer (OpenCode, Hermes, Claude ACP), pin that harness on a machine you control. Proofable does not spawn that computer on shared Azure. For Cursor Cloud Agents, connect Proofable MCP inside that client. Proofable does not launch those VMs.

For a laptop, VPS, or confidential VM, deploy below.

The agent keeps one identity, one set of limits, and one history across environments.

## Deploy a private cloud agent with Proofable

### 1. Write your agent runtime definition

Package your agent as a Docker Compose file. Include the system prompt, model config, tool list, and environment variables.

```yaml theme={"dark"}
# docker-compose.yml
services:
  agent:
    image: your-agent-image:latest
    environment:
      - PROOFABLE_MCP_URL=https://mcp.proofable.me/mcp
      - PROOFABLE_ACCESS_KEY=${PROOFABLE_ACCESS_KEY}
```

`PROOFABLE_ACCESS_KEY` is a profile access key from your Proofable Profile. Use it for agents in headless environments. For interactive agents, use OAuth.

### 2. Deploy anywhere

Run the compose file on a laptop, a VPS, on-prem, or a production cluster. The agent connects to `https://mcp.proofable.me/mcp` from wherever it runs. Proofable loads the agent's identity, permissions, and saved proofs. Before any sensitive action, Proofable checks authority and reuses existing proofs.

The agent can call any Proofable MCP tool: `proofable_context`, `proofable_proofs_check`, `proofable_verify`, `proofable_agent_mount`, `proofable_secret_create`, `proofable_secret_list`, `proofable_secret_revoke`.

### 3. Move the agent, keep the trust state

Redeploy the same compose file on a different backend. AWS, GCP, Azure, Phala Cloud, bare metal. The trust state stays the same across all of them.

### 4. Verify the trust chain

* **Proofable** provides the agent identity and permission proofs. Verify with `proofable_proofs_get` or `GET /api/v1/proofs/{qHash}` (proof ID).
* **The access key** ties the deployed agent to a Proofable Profile. The profile owns the identity, permissions, and proof history.
* **The environment** can optionally prove it is genuine (see confidential compute below).

## Optional: confidential compute

If you need to prove the environment itself is genuine before it receives keys, run the agent inside a TEE-attested confidential VM. The hardware quote covers the full app hash: system prompt, model digest, tool list, and environment. Keys are sealed against that hash and released only after attestation passes. No host process sees plaintext keys.

The trust state still lives in Proofable and travels with the agent. Confidential compute adds a proof that the environment matches what you expect.

### Phala dstack

[dstack](https://phala.com/dstack) boots a Docker Compose app inside an Intel TDX confidential VM. The TDX quote covers the full compose hash. Keys are sealed against that hash and released only after attestation passes. Proofable already uses Phala-backed TEE inference for hosted AI.

```bash theme={"dark"}
npx phala deploy
```

Verify the TDX quote with `@phala/dcap-qvl` against the Phala PCCS. Proves the compose hash and hardware.

### Other confidential compute runtimes

If your runtime supports Intel TDX, AMD SEV-SNP, or an equivalent TEE with remote attestation over the app image, point the agent at the Proofable MCP endpoint. The trust chain is the same: hardware quote over the app hash, sealed keys, Proofable identity and authority checked before action.

## Agent framework examples

### Hermes

Hermes ships six terminal backends. Docker is one of them.

```yaml theme={"dark"}
# docker-compose.yml
services:
  hermes:
    image: nousresearch/hermes-agent:latest
    environment:
      - PROOFABLE_MCP_URL=https://mcp.proofable.me/mcp
      - PROOFABLE_ACCESS_KEY=${PROOFABLE_ACCESS_KEY}
      - HERMES_MODEL=deepseek/deepseek-v4-flash-0731
```

Hermes handles planning, memory, and skill creation. Proofable handles identity, permissions, and proof verification before sensitive actions.

### OpenClaw

```yaml theme={"dark"}
# docker-compose.yml
services:
  openclaw:
    image: openclaw/runtime:latest
    environment:
      - PROOFABLE_MCP_URL=https://mcp.proofable.me/mcp
      - PROOFABLE_ACCESS_KEY=${PROOFABLE_ACCESS_KEY}
```

OpenClaw orchestrates channels and subagents. Proofable adds the trust layer that checks who is acting and what they are allowed to do.

### Custom agent

Any agent that speaks MCP can connect. Package it as a Docker Compose, deploy anywhere, point it at the Proofable endpoint.

## Portability

Move the same agent from a laptop to a VPS or production cluster. The trust state stays the same. Confidential compute can attest each environment.

## Related

<CardGroup cols={2}>
  <Card title="MCP overview" icon="plug" href="../mcp/overview">
    The portable trust harness for AI.
  </Card>

  <Card title="MCP setup" icon="code" href="../mcp/setup">
    Install Proofable and click Connect.
  </Card>

  <Card title="Agent setup" icon="robot" href="./verifiable-agents">
    Agent identity and authority.
  </Card>

  <Card title="Proofable × Phala" icon="external-link" href="https://phala.com/posts/neusphalabuildagenttrustlayer">
    Live Private Cloud Trust Harness.
  </Card>
</CardGroup>