Machine View
Choose Your Integration
Source: https://conto.finance/docs/guides/choose-your-integration
# Choose Your Integration
> Compare Hermes, OpenClaw, the Conto SDK, x402, and MPP to choose the right integration path for your agent.
- Human URL: https://conto.finance/docs/guides/choose-your-integration
- Raw Markdown: https://conto.finance/docs/guides/choose-your-integration.md
- Terminal view: https://conto.finance/ai/docs/guides/choose-your-integration
Documentation group: Start
# 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](https://conto.finance/sdk/installation) |
| Your existing Card Access pilot needs recovery or reconciliation | **Card Access (maintenance)** | Historical recovery only; new deployments are not accepted | [/card-access/overview](https://conto.finance/card-access/overview) |
| You already run agents in OpenClaw or Nous Hermes | **Agent Skill** | Fastest path to policy enforcement inside the OpenClaw and Hermes ecosystems | [/sdk/skills](https://conto.finance/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](https://conto.finance/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](https://conto.finance/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](https://conto.finance/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](https://conto.finance/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](https://conto.finance/guides/trust-scoring) |
| A merchant checkout may require an additional user action | **Conto SDK** | Returns one customer action URL and a status that can be checked before settlement | [/guides/recipes#handle-a-required-payment-action](https://conto.finance/guides/recipes#handle-a-required-payment-action) |
## 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.
### Conto Card Access (maintenance reference)
Do not choose Conto Card Access for a new deployment. It is a maintenance-only private fallback for
existing pilots whose customer-owned card path needs recovery or reconciliation. New connected-card
work should use the shared **Cards** product surface instead.
Existing Card Access pilots still run in a customer-hosted payment service, use the external-card
policy overlay, claim an approved intent before the customer executor can run, and reject card
credentials and secrets from purchase context. The path remains `canBypass: true` because the card can
still be used outside the controlled path.
Conto Card Access is separate from issuer integration and credential-gated
checkout relay work. It does not store PAN or CVC and cannot decline at the
card network. See [Card Management](https://conto.finance/guides/card-management) for the forward Cards surface.
### 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.
- Enforces the same agent environment, risk-tier, owner-role, identity-tag, and attestation rules as direct SDK integrations.
- Lets the assigned human owner list, approve, or deny pending payment reviews in the OpenClaw
conversation. A new decision requires the matching one-time token from the owner's independently
delivered approval notification. Final approvals auto-send managed wallets; external wallets
return a constrained send-and-confirm handoff.
### 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, including agent
environment, risk-tier, owner-role, identity-tag, and attestation rules.
- New approve or deny decisions require the matching one-time token from the assigned owner's
independently delivered approval notification; the Hermes agent key cannot decide by itself.
### 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 |
Info:
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`. Use stable `paymentId` values for x402 and stable `credentialId` values for
MPP so an ambiguous record attempt can be reconciled safely.
Carry payment-challenge context into pre-authorization when you use context-dependent controls:
x402 accepts `facilitator`, `scheme`, and `paymentId`; MPP accepts `scheme`, `credentialId`,
`challengeId`, and `paymentMethod`. An MPP `session` intent must use the same non-empty `sessionId`
during pre-authorization and recording. x402 records require a confirmed `txHash`; MPP records reject
unsuccessful receipts, challenge mismatches, and receipt amounts that disagree with the recorded
amount. Because an MPP receipt is caller supplied, a receipt-only record remains pending. Conto
marks an MPP record confirmed only after its `txHash` matches the expected wallet sender, recipient,
amount, and currency.
## Wallet Model: Managed vs External
| Wallet model | Best fit | What changes | Can Conto block a direct spend outside Conto? |
| -------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------- |
| **Managed wallet** (`MANAGED`) | 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, managed wallets are usually the cleanest production
setup.
Note:
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: managed
- 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. Merchant checkout with a required user action
- Runtime: custom backend or skill-driven agent
- Wallet model: usually integrated
- Rail: standard onchain payment
- Flow: `request -> ACTION_REQUIRED (if needed) -> user follows actionUrl -> check status -> execute`
- Best for: agent purchases that may require the user to complete an additional checkout step
## Decision Tree
```mermaid
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["Managed 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
### Architecture Patterns
Link: https://conto.finance/guides/architecture-patterns
See the core payment, approval, x402, and MPP diagrams
### Recipes
Link: https://conto.finance/guides/recipes
Copy-paste commands for SDK, OpenClaw, Hermes, x402, MPP, approvals, and trust
### Approval Workflows
Link: https://conto.finance/guides/approval-workflows
Add four-eyes review and escalation paths
### Trust Scoring
Link: https://conto.finance/guides/trust-scoring
Understand counterparty risk, verification, and trust-based controls