> ## Documentation Index
> Fetch the complete documentation index at: https://conto.finance/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Choose Your Integration
> Compare Hermes, OpenClaw, the Conto SDK, x402, and MPP to choose the right integration path for your agent.
# Choose Your Integration
If you are deciding between the Conto SDK, the OpenClaw skill, the Hermes skill, x402, and MPP,
start here. The right path usually comes down to three questions:
1. Where does your agent run?
2. Who holds the wallet keys?
3. Are you making one-off payments or repeated protocol-native API payments?
## Quick Decision Matrix
| Situation | Best fit | Why teams pick it | Start here |
| ------------------------------------------------------------------------- | -------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| You are building your own backend, tool runner, or agent service | **Conto SDK / REST API** | Maximum control over payment, policy, and approval flows | [/sdk/installation](/sdk/installation) |
| You already run agents in OpenClaw or Nous Hermes | **Agent Skill** | Fastest path to policy enforcement inside the OpenClaw and Hermes ecosystems | [/sdk/skills](/sdk/skills) |
| You want operator workflows from Claude or another MCP client | **MCP Server** | Gives humans and assistant tools a shared control center for agents, policies, and trust checks | [/mcp/overview](/mcp/overview) |
| Your agent pays for APIs one request at a time | **x402** | Best fit for pay-per-call API commerce with explicit `402 Payment Required` flows | [/guides/x402-api-payments](/guides/x402-api-payments) |
| Your agent will make many charges against one service in a single session | **MPP** | Better economics and ergonomics for repeated or streaming usage | [/guides/mpp-session-payments](/guides/mpp-session-payments) |
| You need human review, dual control, or escalation | **Approval workflows** | Adds four-eyes review without blocking every low-risk payment | [/guides/approval-workflows](/guides/approval-workflows) |
| You need to route based on recipient risk and reputation | **Trust scoring** | Adds counterparty-aware controls before money leaves the wallet | [/guides/trust-scoring](/guides/trust-scoring) |
| You need to prove the human behind an agent is compliant before purchase | **Conto SDK + AgentScore** | Adds verified-human, KYC, sanctions, and jurisdiction gating before settlement | [/guides/recipes#accept-agent-payments-through-a-merchant-gate](/guides/recipes#accept-agent-payments-through-a-merchant-gate) |
## Choose the Control Surface First
### Conto SDK / REST API
Choose the SDK or REST API when you own the agent runtime and want the most direct integration.
* Best for custom backends, agent orchestration services, LangChain/OpenAI wrappers, and custom tools.
* Works well with both managed wallets and agent-held external wallets.
* Gives you the cleanest path to custom approval handling, policy creation, analytics, and audit automation.
### OpenClaw Skill
Choose OpenClaw when your agent already lives inside OpenClaw and typically uses an external wallet or
wallet MCP tools.
* Install is fast through ClawHub (`npx clawhub install conto`), which installs the helper script with the skill.
* The most common pattern is `approve -> transfer -> confirm`.
* Requires `curl`, `jq`, and `python3` on `PATH` for the helper; invoke it with `bash skills/conto/conto-check.sh`.
* Best when you want Conto to be the policy gate while your existing OpenClaw wallet stack keeps execution.
### Hermes Skill
Choose the [Nous Hermes](https://hermes-agent.nousresearch.com/) skill when your agent is already
running on Hermes and you want Conto policy enforcement to feel native in that workflow.
* Installs through Hermes well-known skill discovery (`hermes skills install well-known:... --force`) after you review the install scan.
* Good fit for natural-language policy management and wallet-aware agent operations.
* Requires `curl`, `jq`, and `python3` on `PATH` for the helper; invoke it with `bash ~/.hermes/skills/conto/conto-check.sh`.
* Supports the same underlying Conto approval and policy engine as the SDK flow.
### MCP Server
Choose MCP when a human operator, analyst, or assistant needs to inspect trust, policies, alerts, and
agent state alongside the runtime integrations above.
* Good fit for finance, ops, and security teams.
* Complements SDK, OpenClaw, and Hermes rather than replacing them.
## Then Choose the Payment Rail
| Rail | Best for | Typical execution pattern | Primary controls |
| ---------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------ | -------------------------------------------------------------------------- |
| **Standard onchain payment** | Vendor payouts, treasury actions, direct wallet transfers | `request -> execute` or `approve -> confirm` | Spend limits, approvals, trust rules, time windows |
| **x402** | Paid APIs where each request is separately priced | `402 challenge -> pre-authorize -> pay -> retry -> record` | Price ceilings, service allowlists, endpoint velocity, service budgets |
| **MPP** | Repeated requests to one service, streaming, session-based work | `pre-authorize -> open session -> charge -> close -> record` | Session budgets, max concurrent sessions, max duration, service allowlists |
You can mix these choices. For example, a Hermes or OpenClaw agent can still use x402 or MPP; the
framework choice decides the control surface, while x402 and MPP decide the payment rail.
For x402 and MPP record calls, send aggregate settlement fields at the top level and per-call
details in `batchItems`. Session budget checks use the recorded `sessionId`, so use a stable session
identifier for the lifetime of one paid API session.
## Wallet Model: Integrated vs External
| Wallet model | Best fit | What changes | Can Conto block a direct spend outside Conto? |
| ------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------- |
| **Integrated wallet** (`PRIVY` or `SPONGE`) | Teams that want Conto to orchestrate execution after policy approval | Usually one Conto call can both authorize and execute | **Yes** |
| **External wallet** (`EXTERNAL`) | Agents that already control their own keys or use external wallet tools | Agent asks Conto for approval, executes transfer itself, then confirms back | **No** |
If your agent already has wallet tools in OpenClaw or Hermes, the external model is often the fastest
adoption path. If you want fewer moving parts, integrated wallets are usually the cleanest production
setup.
External wallets can still use the same policy engine, approval workflows, and audit trail. The
difference is that Conto governs the flow that goes through Conto. It does not cryptographically
block a direct transfer your signer makes outside Conto.
## Canonical Examples
### 1. Custom agent with managed execution
* Runtime: custom backend
* Wallet model: integrated
* Rail: standard onchain payment
* Flow: `POST /api/sdk/payments/request` with `autoExecute: true`
* Best for: vendor payments, infra spend, low-latency production flows
### 2. OpenClaw agent with external wallet controls
* Runtime: OpenClaw
* Wallet model: external
* Rail: standard onchain payment
* Flow: `POST /api/sdk/payments/approve -> transfer -> POST /api/sdk/payments/{id}/confirm`
* Best for: teams that already have wallet MCP tools and want to add guardrails without re-architecting
### 3. Hermes agent paying APIs with x402
* Runtime: Hermes
* Wallet model: usually external
* Rail: x402
* Flow: `402 challenge -> /api/sdk/x402/pre-authorize -> pay -> retry -> /api/sdk/x402/record`
* Best for: controlled pay-per-call API buying
### 4. SDK integration for high-frequency MPP sessions
* Runtime: custom backend
* Wallet model: integrated or external
* Rail: MPP
* Flow: `pre-authorize deposit -> open session -> repeated charges -> close session -> record settlement`
* Best for: repeated calls to the same service where per-call onchain settlement would be wasteful
### 5. AgentScore-gated merchant checkout
* Runtime: custom backend or skill-driven agent
* Wallet model: usually integrated
* Rail: standard onchain payment
* Flow: `request -> VERIFICATION_REQUIRED (if needed) -> human verifies -> auto resume -> execute`
* Best for: agent purchases that must prove the human behind the agent passed merchant compliance checks
## Decision Tree
```mermaid theme={null}
flowchart TD
A["Where does the agent run?"] --> B["OpenClaw"]
A --> C["Hermes"]
A --> D["Custom runtime"]
A --> E["Operator assistant / MCP client"]
B --> F["Use OpenClaw skill"]
C --> G["Use Hermes skill"]
D --> H["Use Conto SDK or REST API"]
E --> I["Use MCP server"]
F --> J["Who holds keys?"]
G --> J
H --> J
J --> K["Integrated wallet"]
J --> L["External wallet"]
K --> M["Prefer request + autoExecute"]
L --> N["Prefer approve + confirm"]
M --> O["Need paid API calls?"]
N --> O
O --> P["One request at a time: x402"]
O --> Q["Many requests in one session: MPP"]
O --> R["Direct transfers: standard onchain flow"]
```
## Related Guides
See the core payment, approval, x402, and MPP diagrams
Copy-paste commands for SDK, OpenClaw, Hermes, x402, MPP, approvals, and trust
Add four-eyes review and escalation paths
Understand counterparty risk, verification, and trust-based controls