Proofable Docs | Portable Trust Infrastructure

Same agent, wherever it runs. Do the work

Add https://mcp.proofable.me/mcp, click Connect.
Create or import the agent (proofable_agent_create).
Open Connections if the work needs an app.
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.

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

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.

# 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

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

MCP overview

The portable trust harness for AI.

MCP setup

Install Proofable and click Connect.

Agent setup

Agent identity and authority.

Proofable × Phala

Live Private Cloud Trust Harness.

​Deploy a private cloud agent with Proofable

​1. Write your agent runtime definition

​2. Deploy anywhere

​3. Move the agent, keep the trust state

​4. Verify the trust chain

​Optional: confidential compute

​Phala dstack

​Other confidential compute runtimes

​Agent framework examples

​Hermes

​OpenClaw

​Custom agent

​Portability

​Related