# Bitpont agent handbook

API 1.30.0

Start at https://www.bitpont.com/help/ai-agents/ or use the remote MCP server at https://www.bitpont.com/api/v1/mcp.

# Connect OpenAI, Gemini or Perplexity to Bitpont | MCP & REST

Configure Bitpont in OpenAI Responses, Gemini CLI or Perplexity. Test public discovery, choose product tools and use REST with custom clients.

Canonical: https://www.bitpont.com/developers/ai-clients/


## Choose a connection

For hosted tools, use https://www.bitpont.com/api/v1/mcp. Add ?product=treasury to narrow the list. For clients that launch a local process, download the [stdio adapter](https://www.bitpont.com/assets/sdk/bitpont-agent-mcp.mjs) and run it with Node 20 or newer. The [tool explorer](https://www.bitpont.com/help/ai-agents/#agent-explorer) lists public access and partner scopes.

## OpenAI Responses API

Add the following tool definition to the tools array of a Responses request. It exposes discovery and asks for approval. Inspect the returned tool list and tool results. [OpenAI MCP documentation](https://developers.openai.com/api/docs/guides/tools-connectors-mcp).

```
{"type":"mcp","server_label":"bitpont","server_url":"https://www.bitpont.com/api/v1/mcp","allowed_tools":["bitpont_findTools","bitpont_describeTool"],"require_approval":"always"}
```

## Google Gemini CLI

Merge this entry into your Gemini CLI settings. Restart the CLI and run /mcp to inspect Bitpont. Ask it to find public Treasury tools on Base. A Gemini application using function calling can also dispatch selected REST operations itself. [Gemini CLI configuration](https://geminicli.com/docs/tools/mcp-server/) · [Gemini function calling](https://ai.google.dev/gemini-api/docs/function-calling).

```
{"mcpServers":{"bitpont":{"httpUrl":"https://www.bitpont.com/api/v1/mcp?product=treasury"}}}
```

## Perplexity remote connector

On a Perplexity account with custom connectors, open Plugins, add a custom MCP connector and enter the HTTPS server URL. Choose the remote HTTP transport and public access for discovery. Ask for the exact Bitpont tool used and its returned workspace URL. Connector availability depends on the client and workspace settings. [Perplexity connector setup](https://www.perplexity.ai/help-center/en/articles/11502712-local-and-remote-mcps-for-perplexity).

## REST and other model hosts

Read [the action directory](https://www.bitpont.com/api/v1/agent). Let your application dispatch only tools it has selected, validate input against [OpenAPI](https://www.bitpont.com/assets/docs/bitpont-openapi.json), and return the HTTP response to the model. Keep credentials and signing inside the host. For offline development, use the [tested examples and tool catalogue](https://www.bitpont.com/assets/sdk/bitpont-agent-kit.zip).

## Verify the first connection

Call bitpont_treasuryTools with {"network":"base","task":"payments","limit":3}. Inspect items, the next tool and each canonical path. If an HTTP client receives 429, wait for Retry-After. For a supported trade, reuse the private workspace and sign using the authorized wallet. Named partner keys also need the scope specified for the operation. [Execution and wallet permissions](https://www.bitpont.com/developers/agent-execution/).

# Treasury Tool API | Safe, Solana Payments and Wallet Conversions

Select Treasury features by network, account type and financial task. Connect discovery to Safe proposal review, Solana batches and receipt checks.

Canonical: https://www.bitpont.com/developers/treasury-directory/


## Match a task to the account

POST /api/v1/agent/treasury/tools or call bitpont_treasuryTools. Filter by network, task, kind and search terms. Choose safe for a multisig, solana for a Solana signing wallet or wrapper for a direct EVM wallet. Each item names its account, supported actions, workspace and next tool.

```
{"network":"base","kind":"safe","task":"payments","page":1,"limit":10}
```

## Read the complete result set

Follow nextPage until it is null. A zero count means no registered match for these filters. Inspect the nextTool with bitpont_describeTool before sending inputs. The [Treasury directory](https://www.bitpont.com/treasury/tools/) also works without an API client.

## Review a Safe proposal

Plan payments, then prepare the next unpaid batch against the current Safe nonce. Open the returned review URL, confirm the network, Safe, action, recipient and amounts, then refresh owner approvals. Verify the specific proposal hash and final receipt before recording payment. [Safe payments and lending](https://www.bitpont.com/developers/treasury/).

## Prepare a Solana payment run

Use distinct recipient addresses and exact atomic amounts. Save the run ID, batch index and signatures. The plan supports up to 500 recipients and prepares up to 20 SOL or four standard SPL transfers per transaction. Reconcile each batch before proceeding. [Treasury walkthrough](https://www.bitpont.com/help/treasury/) · [Treasury integrations](https://www.bitpont.com/business/treasury/).

# Operations API Guide | Discover Outcomes and Review Workflows

Find supported funding, lending, staking and yield workflows by goal and network. Use a canonical review link and recover a partially completed operation.

Canonical: https://www.bitpont.com/developers/operations-outcomes/


## Find a supported outcome

POST /api/v1/agent/operations/outcomes or call bitpont_operationOutcomes. Omit filters to list supported goal and destination network pairs. A filter with zero matches returns an empty list.

```
{"network":"arbitrum","goal":"rate-margin"}
```

## Open the returned workspace

Follow the returned reviewUrl to open the selected goal in [Operations](https://www.bitpont.com/operations/). Select the source asset and wallet there. Rates, spend limits and available balances are checked when preparing the action. The directory link carries no signing authority.

## Draft an exact USDC move

For a same-network USDC move, POST /api/v1/agent/operations/workflow with a human-readable USDC amount. Use the returned steps and reviewUrl. To enumerate valid source and destination pairs read [the operations catalogue](https://www.bitpont.com/api/v1/agent/operations).

```
{"network":"base","source":"aave","destination":"morpho","amount":"1.25"}
```

## Resume a partly completed workflow

Open [saved operations](https://www.bitpont.com/operations/#opSaved) in the browser that kept the run. Match its saved hash and wallet before repeating a step. For a bridge, source confirmation and destination delivery are separate. [Operations walkthrough](https://www.bitpont.com/help/operations/) · [API recovery](https://www.bitpont.com/developers/agent-recovery/).

# Agent Trading API | Wallet Signing, Sessions & Recovery

Execute supported swaps, bridge steps, perpetual orders, Earn actions and treasury transactions. Set customer permissions, review fees and recover a submission.

Canonical: https://www.bitpont.com/developers/agent-execution/


## Use your own wallet

Use the SDK with new BitpontClient(). It creates a private workspace automatically. Save client.workspace on the server and pass it back as {workspace} after a restart. REST and remote MCP clients can call openWorkspace and reuse the secret in X-Bitpont-Workspace or the workspace tool input. The wallet signs every trade or explicitly approves an exact customer session.

Server-side JavaScript
```
import {BitpontClient} from './bitpont-client.mjs';
import {prepareAction, executeTicket} from './execution.mjs';
const client = new BitpontClient({workspace: process.env.BITPONT_WORKSPACE});
// input and requestId come from a persisted, validated intent.
const ticket = await prepareAction(client, 'assetPrepare', input, requestId);
// createAgentWalletSigner in execution.mjs supports EVM, Solana and typed orders.
const result = await executeTicket(client, ticket, yourWalletSigner);
console.log(result.executionId, result.state, result.networkId);
```

## Use your referral programme

Use the referrals MCP product profile or call referralIntent with dashboard, history, accept or request-payout. Sign the returned exact message with your Solana wallet and call referralApply with the same inputs, timestamp and signature. Receipt history supports a source filter and the nextCursor value as after. A payout request enters treasury review.

## Verify a received fee

Unpaid use shares the standard request budget. A finalized, verified Bitpont fee unlocks an hour without the standard request quotas, measured from its on-chain payment time. Call feeAccess on your submitted ticket, sign the returned workspace challenge locally, then send ownerSignature. The same verified payment cannot extend the window on replay. Further qualifying fees renew it. Jupiter, supported Kyber inputs and deBridge affiliate receipts have verifiers. Unsupported receipts, quotes, gas and pending settlements use the standard budget. Provider capacity and concurrency still apply.

## Check a sequence before requesting signatures

Use GET /api/v1/agent/execution/routes for the current action names and schemas. Send up to twelve ordered {action,input} steps to POST /api/v1/agent/execution/plan or call bitpont_executionPlan. Each step reports the exact field path to fix. Planning costs one request unit and creates no tickets.

After validating the inputs, prepare each action with a unique request ID and the same private workspace. Review the fresh fee, amount, network and wallet at preparation. Wait for the required settlement before preparing any dependent step. There is no atomic guarantee across steps. For Derive orders, use the wallet-local Options kit.

## Choose who authorizes the action

Public market reads, quotes and supported drafts require no wallet signature. With a funded agent wallet, the agent signs using its own signer. Customer wallets can [approve and revoke an exact trading session](https://www.bitpont.com/help/ai-agents/customer-trading-sessions/), use a compatible owner-controlled recurring signer or approve a Hyperliquid trading key. Keep private keys in the wallet or signer. Give an agent only the capabilities needed for its job.

## Connect your integration

Read [the execution catalogue](https://www.bitpont.com/api/v1/agent/execution/routes) for action names and input schemas. The REST operation IDs are also MCP tools with the bitpont_ prefix. Use a private workspace to prepare, submit and track wallet-signed trades. Named partner keys retain their configured scopes. Email support@bitpont.com for high-volume access.

## Sign with a funded agent wallet

- Choose an action and call executionPrepare with its input and a persistent requestId UUID. Save the executionId and deadline. Continue to signing only for an unexpired awaiting-signature ticket that includes a signing payload. For no-action, inspect the returned review before continuing. If initialization is required, review the account setup separately and prepare the action again after setup.
- Compare the network, wallet, token addresses, amount, minimum output, fee and destination against your intent. For EVM, populate the nonce and bounded gas fields from the correct chain, then sign the returned transaction locally. For Solana, deserialize the versioned transaction, preserve co-signatures, sign the unchanged message and encode the wire transaction as base64. For venue orders, sign the displayed typed data on the specified domain.
- Submit signed bytes or the signature through executionSubmit. Save the network hash, client order ID, CoW UID or venue reference before continuing. Use executionStatus and the product receipt to verify the outcome.

## Approve and revoke a customer session

Call sessionPrepare with one customer wallet and up to 12 exact unsubmitted ticket IDs. Show the wallet, integration, each action and expiry. The customer wallet signs the listed transaction payloads and the session message. Wallets with batch signing can group this review. Other wallets can prompt for each underlying signature during setup. A session lasts until the earliest ticket deadline, at most 90 seconds. Use sessionActivate inside the trusted customer application. The agent then calls sessionRun with the two IDs. sessionStatus shows the permitted actions and their state. sessionRevoke stops the remaining submissions. The customer can also use ownerRevokeSession without the partner key by signing the revocationMessage returned at setup. Keep the sessionId and this message in the owner’s wallet application. It cannot reverse a transaction already sent. Never expose pre-signed payloads to the model.

## Stop a customer session

Enter the session ID from the application that requested approval. Sign with the same wallet to stop any unused tickets.

Wallet network Ethereum and EVM networksSolanaSession ID 

## Run recurring EVM actions

The downloadable kit includes recurring-evm.mjs for a customer-controlled unattended signer. Use Node 24, ethers 6 and an owner-only persistent SQLite file. Open the module with a trusted Bitpont client, signer and RPC provider. The owner grants one reviewed EVM call with exact calldata, value, recipient, wallet and chain. The grant also fixes inputs, run count, deadline and gas ceilings. A fresh ticket must match on every run. Changed prices, calldata or targets may require new consent. Each attempt consumes one slot, even when it fails. Give the agent access to run and status in a separate process. Restrict grant, revoke, cancelUnsent, the database and signing credentials to the owner. A regular browser wallet may still prompt if used as the signer.

Each run takes a persisted request UUID. The helper records the signed transaction hash before submission. For a lost response, use recover with the same UUID. An uncertain broadcast blocks new sends from that database. cancelUnsent can release an interrupted preparation before transmission. Keep the database on durable storage and use one writer service per wallet.

## Delegate a Hyperliquid trading key

For a supported main account, generate a fresh trading key in the owner-controlled integration, then prepare hyperSession and sign the venue approval as the owner. Choose 1–60 minutes. Supply that signer address to hyperOrder and hyperCancel. Supported perpetual accounts can also use hyperLeverage and hyperMargin after a fresh market and position check. Bitpont rechecks the venue permission before submission. The native key grants venue trading authority. Changing an agent-side setting cannot narrow that key on the venue. End the Bitpont-named permission with owner-signed hyperRevoke. Read venue permissions to confirm replacement. Configure builder fees explicitly and prepare hyperBuilder for the owner’s fee approval when required.

## Authorize a Treasury executor

Where the verified Bitpont Safe module is deployed, use safeRuleStage to prepare enable, authorize, revoke or disable. Each Safe owner approves the same proposal hash. Execute the threshold-approved proposal with its expectedHash. A rule fixes its executor, permitted calls, before and after checks, interval, expiry, gas price and run count. The agent signs safeRuleRun with its own gas-paying wallet and the expected on-chain run index. The module enforces the rule at execution. Confirm the Executed event and balances. Discover configured deployments with the operations tool. Installing this release does not deploy a contract or enable a module on any Safe.

## Follow the product settlement

- Swaps and bridges use the reviewed allowance, spend, minimum output and fee policy. Prepare each required approval and funding step separately and confirm the destination delivery.
- Earn and liquidity calls preserve protocol minimums, additional signers, vault checks, position identities and the order of dependent steps.
- Solana perpetuals require a detached wallet proof on the exact native preparation request, followed by a signed transaction. GMX and Ostium use their respective builders. Hyperliquid orders use venue signatures. A resting or partially filled order can still have remaining size.
- Safe proposals require the configured owner threshold. Inspect safeReceipt after execution. The Operations composition planner describes dependencies. Prepare each supported step only after its input is available.

## Recover a timeout or interruption

Read executionStatus before repeating a write. An unknown response can follow a successful broadcast. Keep the raw transaction hash or venue ID before sending. The server journals request IDs, signature digests and recovery references in its private account database for seven days. It writes the broadcast state before contacting the provider. After a restart, executionStatus can recover a receipt. Unsigned preparations and unspent batch signatures expire with the serving process. Use sticky routing for active sessions. A client can recover the result on the chain or venue even after database retention ends. On-chain inclusion, a fill and destination delivery are separate events. Each fee-bearing adapter reports its own fee terms. Some protocols have no Bitpont fee.

## Trade Derive options from an agent wallet

Download the [agent starter kit](https://www.bitpont.com/assets/sdk/bitpont-agent-kit.zip) and run node bitpont-options-mcp.mjs with Node 24 or newer on the wallet owner’s machine. Set BITPONT_OPTIONS_SIGNER to a local signer module, BITPONT_OPTIONS_POLICY to the owner policy JSON and BITPONT_OPTIONS_STATE_DIR to one durable private directory for this wallet. The kit includes working signer and policy examples. An eligible funded Derive subaccount is required.

Use bitpont_optionsAccount to check positions and margin. Call bitpont_optionsPrepare with a new request ID, exact instrument, side, quantity, limit price and fee limit per unit. bitpont_optionsEstimate requests the venue estimate. bitpont_optionsPlace refreshes it and submits the same locally signed order once. bitpont_optionsStatus reconciles open orders and history. bitpont_optionsCancel targets its open remainder. Use the same request ID after a timeout.

The order uses the same client attribution and fee fields as the Bitpont Options workspace. A separate Bitpont options fee is not added.

The owner policy sets the subaccount, quote currency, named instruments, expiry, maximum order count, size, premium plus fee per order, and fee per unit. A prepared order consumes one slot for the lifetime of the journal. Keep one journal per wallet and back it up with the signer configuration. Premium limits describe the order amount. An opening short can lose more than its premium. Opening shorts require an explicit policy change. The local Options signer is independent of hosted customer sessions.

## Track new tools and permissions

Connect directly to the hosted MCP for current tools. With the downloadable stdio server, run node bitpont-agent-mcp.mjs --live to load the current published contracts at startup. Add --product earn to load the Earn profile. Restart when the contract revision changes.

Read GET /api/v1/integrations/manifest using the same credentials as your agent. Store the ETag and send it in If-None-Match on subsequent reads. A 304 response means the tool schema and effective access are unchanged. A changed schemaRevision signals that the published tool contract changed. Fetch the current tool catalogue and refresh the affected schemas. The manifest lists configured routes and authorization separately. Higher API limits are available from support@bitpont.com.

## Inspect balances before a Solana Earn action

Use solana-earn.providers and solana-earn.products to find configured providers and exact products. Read solana-earn.portfolio for balances and incomplete providers. For Jupiter borrowing use jupiter-lending.vaults, jupiter-lending.vault, jupiter-lending.portfolio and jupiter-lending.position. Continue position scans with both nextCursor and scanId. For Marinade use marinade.state for pool parameters and marinade.account for balances and delayed withdrawal tickets.

## Recover an execution by request ID

If the preparation response is lost, use bitpont_executionLookup with the original request UUID. To resume after a restart use bitpont_executionReceipts with your private workspace or submit-scoped partner key. It lists saved receipts newest first. Pass nextCursor as before to continue. The seven-day journal contains the current integration’s tickets. Use bitpont_executionStatus on the matching execution ID for live settlement checks. Local Options orders use their separate local journal.

## Trace a bridge fee from source order to recipient

Use bridgeFeePolicy for Bitpont’s source recipients. Direct cross-chain DLN quotes use referral 33127 and a 0.40% input fee. A 1,000 USDC input implies 4 USDC before any source asset conversion. Preserve the order ID, source network, source transaction and expected input units. Call bridgeFeeFollow with the source network and order ID to resolve the next step. It checks the source chain and matches receipt evidence where available. For an older Solana claim, supply its withdrawalSignature. The kit includes bridge-fee-status.mjs for this read. Ask bridgeFeeOrders for unlocked candidates. An empty page or a destination delivery says nothing about a recipient credit.

On EVM, call bridgeFeeReceipt with the creation and source unlock hashes. If the fee is deferred, check bridgeFeeBalance, use bridgeFeeWithdraw with an externally signing gas payer and check bridgeFeeWithdrawalReceipt. The payout address is fixed. Deferred withdrawals aggregate fees by token. Native transfers need trace-capable RPC to prove receipt.

On Solana, read solBridgeFeeState for the exact order. Once claimable, the configured Solana beneficiary can authorize solBridgeFeeWithdraw. Use either withdrawal action with executionPrepare, sign in the appropriate wallet, executionSubmit, then executionStatus. Call solBridgeFeeReceipt with the order ID and finalized signature to verify the recipient’s token credit. Same-chain Jupiter referral claims use their own referral key and dashboard. The Solana cross-chain beneficiary is a separate identity.

[deBridge affiliate terms](https://docs.debridge.com/dln-details/affiliates/affiliate-fees) · [Withdrawal reference](https://docs.debridge.com/dln-details/affiliates/withdrawing-affiliate-fees)

## Check recurring swap permissions on a Safe

Use recurringPermissions with the chain, Safe address and owner to check whether the installed module and account qualify. The supported rule targets a configured Base Safe exchanging USDC and WETH through one fixed pool. The authorization binds the input amount, minimum output, Safe recipient, executor, interval, expiry and execution budget. Read the quoted input-token fee in the rule before owner review.

Generate the exact rule with recurringSwapRule. Review proposal in [Base Treasury automation](https://www.bitpont.com/treasury/#trAutomation), then retain ruleId for execution or revocation. Validity and interval values use seconds. Gas price bounds use wei per gas. Only an enabled, verified deployment can authorize execution. Existing signed ticket sessions remain available for individual trades. Borrowing and Multiply require their respective wallet-signed actions. [Review customer session and revocation options](https://www.bitpont.com/help/ai-agents/customer-trading-sessions/).

## Simulate an existing EVM ticket

Read walletTokenBalances for native gas and the exact ERC-20 input balance. Use walletAllowances for the token and spender returned in the quote. In the original private workspace, POST the saved executionId to /api/v1/agent/execution/preflight. Read the call result and gas estimate independently. After signature and submission, follow executionStatus and the supported swap receipt for settlement evidence.

[Check the wallet, spender and execution ticket](https://www.bitpont.com/help/ai-agents/preflight-evm-transactions/)

# Connect an AI Agent to Bitpont | MCP, Codex and OpenAI

Connect to the hosted MCP endpoint or run the downloadable server locally. Choose a product profile, check access and make a first discovery request.

Canonical: https://www.bitpont.com/developers/agent-connections/


## Choose a connection

Use https://www.bitpont.com/api/v1/mcp with a remote MCP client. For a local stdio client, [download the server](https://www.bitpont.com/assets/sdk/bitpont-agent-mcp.mjs) and launch it with Node.js 20 or newer. Standard trading and discovery work without registration. Store your private workspace on the host for recovery after restarts.

Server-side JavaScript
```
import {BitpontClient} from './bitpont-client.mjs';
const client = new BitpontClient({publicAccess:true});
const info = await client.agent('describeTool', {tool:'viewBridgeAssets'});
console.log(info.data.inputSchema);
```

## Load one product or the full catalogue

For a treasury assistant, add ?product=treasury to the remote URL. For stdio, pass --product treasury. Product profiles narrow the tools presented to the model. API scopes control access. Call tools/list until the response has no nextCursor.

## Connect Codex or the Responses API

For Codex, run codex mcp add bitpont --url https://www.bitpont.com/api/v1/mcp. The [starter kit](https://www.bitpont.com/help/ai-agents/#agent-downloads) includes a Responses API tool configuration with an explicit allowlist and approval setting. For local function calling, select definitions from the [OpenAI function catalogue](https://www.bitpont.com/assets/docs/bitpont-openai-tools.json) and dispatch by tool name using the tool directory.

## Verify the connection

Initialize the client and list tools, prompts and resources. Read bitpont://products/treasury for the product’s handoff rules. Open the operations-move prompt for an example on Base. The prompts and product resources bundled with the local download also work offline.

[Run a public example in the browser](https://www.bitpont.com/help/ai-agents/#agent-try) or [integrate Bitpont into an AI product](https://www.bitpont.com/business/ai-platforms/).

# Bitpont Agent Workflows | Assets, Quotes and Market Views

Follow worked examples for exact amounts, route selection, market views, Treasury payment planning and product-to-product Operations.

Canonical: https://www.bitpont.com/developers/agent-workflows/


## Check a multi-tool workflow

Call bitpont_checkWorkflow or POST to /api/v1/agent/workflow/check with up to twelve calls in order. Each call has a tool name and input object. Inspect the returned field-level issues, the transport and the workspace requirement. This checks the input schemas and calls no provider. Recheck live fees, balances and approvals when preparing an actual trade. Follow the workflow validation example.

Server-side JavaScript
```
import {BitpontClient} from './bitpont-client.mjs';
const client = new BitpontClient({publicAccess:true});
const result = await client.view('bridge-assets', {
  sourceChain: 'evm:1', destinationChain: 'evm:8453', symbol: 'USDC'
});
for (const row of result.results) console.log(row.id, row.state, row.pagination);
```

## Choose a task

Call bitpont_recipes with an optional product ID. Open the chosen task with bitpont_recipe. Each result has a concrete start.tool and start.input, the later steps, their access requirements and the outcome to verify. A recipe describes a sequence and only its first request has ready-to-use inputs.

## Resolve identity and amount

Use bitpont_findAssets to find an asset by name, symbol or address. A symbol can resolve to multiple contracts. Use bitpont_resolvePair to see both sides and select an exact address when it returns ambiguous. Use bitpont_convertAmount on that network and address before requesting a quote. Pass amounts as strings to preserve precision.

## Inspect markets and positions

Start with bitpont_viewPerpetualMarkets for Hyperliquid, GMX and Ostium. bitpont_viewLendingAccount combines a reserve read and the specified wallet’s Aave and Morpho vault positions. Each view costs one unit per underlying read. Results retain provider identity, observation time, availability and pagination. Compare like units and timestamps.

## Plan payments

Open the safe-payments or solana-payments recipe. Supply the actual wallet, network and recipient list to the planning operation. For a Safe, record the proposal hash and collect the owner approvals. For Solana, persist the run ID, batch number and exact transaction signature. Resume from the first batch with a verified unpaid outcome.

## Hand off an operation

For a Base USDC move from Aave to Morpho, prepare the human-readable amount with bitpont_workflowDraft. Show the owner the returned steps, costs and review URL. A withdrawal and a deposit have separate results. Use the next step only after the preceding amount and settlement are known.

[Look up input fields by tool](https://www.bitpont.com/help/ai-agents/#agent-explorer).

## Show fees before owner review

For a fee-bearing EVM swap, preserve the quote ID, wallet and selected route, then display the configured fee in the prepared transaction. On the supported deBridge path, compare fee.expectedBaseUnits, the source asset, recipient and minimum output with the original quote. The preparation can reject a changed fee or expired quote. A quoted fee, an unsigned transaction and a received fee are different stages. Keep the transaction hash for reconciliation. [Read the fee policy](https://www.bitpont.com/fees/) and [inspect the swap example](https://www.bitpont.com/developers/quotes/).

## From fee quote to referral reward

Identify the bridge provider first. The direct DLN quote exposes the Bitpont rate, source asset, expected base-unit fee and source-chain recipient. Preparation rechecks those terms. Follow the order ID to the source settlement or manual withdrawal. Only a matching finalized credit proves collection. Bitpont’s partner ledger separately checks an accepted Solana invitation and an eligible fee source. Direct deBridge receipts do not create automatic partner rewards.

On Solana Jupiter swaps, public quote and unsigned preparation expose a typed fee. The public transaction endpoint returns an unsigned Jupiter transaction. To submit through Bitpont, reuse the private workspace and sign the reviewed ticket with the sending wallet. API access, collection evidence and affiliate eligibility are separate checks. [Fee policy](https://www.bitpont.com/fees/) · [Partner coverage](https://www.bitpont.com/referrals/#reward-eligibility).

## Resume a task across Portfolio and MCP

For swap → deposit, withdraw → swap and bridge → deposit, start in [Portfolio Activity](https://www.bitpont.com/portfolio/activity/#portfolioFinancialTasks) or call taskCreate with a persistent request UUID and a private workspace. Save data.task.id as taskId. Read taskStatus before preparing the next step. Each wallet signature authorizes an individual transaction. Preserve the native gas reserve when sizing the remaining deposit.

For the Base example below, obtain a supported WETH vault and its protocol from the live connected vault directory. Load the wallet, workspace and request UUID from your application. Set the minimum output from the reviewed quote. The example prepares a plan for 100 USDC and reserves 0.002 ETH for gas.

```
const {data} = await client.agent("taskCreate", {
  requestId, kind: "swap-deposit", wallet, network: "base",
  inputToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  outputToken: "0x0000000000000000000000000000000000000000",
  protocol, vault, amount: "100000000", gasReserve: "2000000000000000",
  minOutput: reviewedMinimumWei, slippageBps: 50
});
const taskId = data.task.id;
```
Recover the task with taskList in the same workspace. Resume using the step and attempt returned in task status. After a bridge submission, wait for evidence of the intended token reaching the intended destination wallet. An unavailable provider or unknown submitted transaction needs recovery before a further submission. [Follow the task from first signature to recovery](https://www.bitpont.com/help/ai-agents/resumable-portfolio-tasks/).

## Use a token lookup in a second read

For a Base swap, look up the exact source token before converting a display amount. Call batchTools for the eligible reads and output paths. With checkReadBatch, bind /route/source/address from a preceding resolvePair call to the address input of convertAmount. A successful check returns valid: true. Submit the same calls to runReadBatch and inspect each item in results. A blocked dependency carries status 424. Resolve any ambiguous token and rerun the reads before requesting a quote.

[Copy the Base lookup and conversion example](https://www.bitpont.com/help/ai-agents/batch-agent-reads/) · [Resolve a pair and request a live quote](https://www.bitpont.com/help/ai-agents/find-swap-and-bridge-quotes/)

## Compare a yield assumption with an executable offering

Use earnCompareOpportunities to review provider-reported rates and freshness. Use earnYieldScenario with the principal, assumed APY, holding period and round-trip cost to compare scenarios in the same token units. Resolve the intended asset with earnOfferingSearch. Select the connected offering and its deposit or withdrawal adapter before requesting wallet review.

[Work through a 90-day USDC scenario](https://www.bitpont.com/help/ai-agents/compare-earn-yield-and-costs/) · [Check a lending withdrawal on Base or Ethereum](https://www.bitpont.com/help/ai-agents/check-lending-withdrawal-capacity/)

# Bitpont Agent Recovery | Retries, Receipts and Partial Data

Handle schema errors, access restrictions, stale quotes, partial provider reads and uncertain wallet or bridge outcomes.

Canonical: https://www.bitpont.com/developers/agent-recovery/


## Correct a request before sending it

Call bitpont_describeTool for the exact schema and bitpont_checkInputs with the tool name and arguments. A failed check returns JSON Pointer paths, such as /payments/0/amount. This checks field shape and precision rules declared in the schema. Live eligibility, balance and execution simulation occur at the provider step.

Server-side JavaScript
```
import {BitpontClient} from './bitpont-client.mjs';
const client = new BitpontClient({publicAccess:true});
const result = await client.agent('checkInputs', {
  tool: 'convertAmount',
  arguments: {chainId:'evm:1', unit:'display', value:'1.25'}
});
// The address field is missing. No provider was contacted.
console.log(result.data.issues);
```

## Handle access, rate and provider errors

- 401 or 403. Check whether the tool needs a partner key and which scope it requires. Wallet signatures authorize a separate step.
- 429. Honor Retry-After. Batch and market-view calls consume one unit per underlying read. Request higher limits at [support@bitpont.com](mailto:support@bitpont.com).
- 409 on a quote. Refresh the quote with the same network, token identities and owner. Review fees and expiry again.
- Partial read. Keep successful rows, store each resource cursor, and retry the unavailable resource with its original parameters.

## Recover an uncertain outcome

Keep the network, account, request ID, quote or order ID and source transaction hash. After a timeout, inspect the recorded identity first. An included EVM transaction can still need a protocol-specific event. A bridge needs destination delivery, a perpetual order needs a fill, and a Safe payment needs the matching finalized execution and delivery evidence.

## Read the same swap receipt as Portfolio

For a Jupiter swap or fee-bearing KyberSwap, call POST /api/v1/agent/execution/swap-receipt with the original private workspace and executionId. With MCP, call bitpont_swapReceipt. Both use the same receipt data shown in [Portfolio Activity](https://www.bitpont.com/portfolio/activity/#portfolioSwapReceipt). A finalized transaction, an attributable wallet output and a verified Bitpont fee are three separate observations.

Receipt fieldHow to read it

state, transactionId, blockCheck the transaction identity and finality. Refresh the same execution while pending or after an unavailable response.

actualOutput, walletDelta, deltaSourceAmounts are base-unit strings for the identified asset. ERC-20 wallet transfer events report a net transfer. Native currency balance changes can also include gas or rent. Leave an unattributable output unknown.

fee.quotedAmount, fee.receivedAmountUse the quoted amount for review. Use the received amount for reconciliation when fee.state is verified. Keep the token and beneficiary with the amount.

```
const result = await client.agent("swapReceipt", {executionId});
const receipt = result.data;
console.log(receipt.transactionId, receipt.actualOutput, receipt.fee);
```
Restore the original workspace when constructing client. [Read the swap settlement walkthrough](https://www.bitpont.com/help/ai-agents/verified-swap-receipts/).

## Prepare a support report

Include the tool name, request ID, approximate UTC time, HTTP status and observed stage. Exclude API keys, wallet credentials and signatures. The [Business integration brief](https://www.bitpont.com/business/#partner-start) helps size a recurring workload.

## Reconcile workspace activity over a month

Request POST /api/v1/agent/business/report with a UTC month and the original workspace. Retain the next page cursor and reconcile each execution against the wallet, network, asset and transaction identifiers. POST /api/v1/agent/business/events supports replay from a saved event cursor. Save that cursor after the downstream system has processed the event. Keep quoted, claimable and verified fees distinct from wallet-authorized referral payables.

[Open Business settlements](https://www.bitpont.com/business/#settlements) · [Read the integration and delivery guide](https://www.bitpont.com/help/ai-agents/reconcile-settlements/)

## Find the next task that needs attention

Use taskOverview to count recorded tasks by state, kind and destination network in the original workspace. Use taskInbox with the same filters, supplying nextCursor as before for the next page. Refresh the selected task with taskStatus before deciding whether to prepare the current step.

[Recover unfinished financial tasks](https://www.bitpont.com/help/ai-agents/resume-workspace-task-inbox/)

## Investigate a specific settlement exception

Use businessFindReceipt with the exact execution ID, source transaction or payment transaction. Page through businessReceiptHistory with after to review the evidence already observed. Use businessExceptions for an outstanding category in a UTC month and businessFeeTotals for token-level sums. Inspect unidentifiedRows and conflictingGroups before closing the period.

[Investigate missing output or affiliate fee evidence](https://www.bitpont.com/help/ai-agents/investigate-settlement-exceptions/) · [Business settlements](https://www.bitpont.com/business/#settlements)

# Hyperliquid API | Spot, HIP-3, Native Perps and Order Drafts

Use exact Hyperliquid market IDs to read depth, choose an order type, prepare an unsigned handoff and reconcile the outcome.

Canonical: https://www.bitpont.com/developers/hyperliquid/


## Start with the exact market

Search hyperliquid.directory by symbol, pair or protocol identity. Select the row with the intended base token, quote token, kind and venue. Use the returned market key and canonical workspace. The WOW / USDC spot example has protocol coin @109 and market key spot:10109. A base token index and a market key identify different objects.

Server-side JavaScript
```
import {BitpontClient} from './bitpont-client.mjs';
const client = new BitpontClient({publicAccess:true});
const found = await client.read('hyperliquid.directory',{q:'WOW',kind:'spot'});
for (const m of found.data.items) console.log(m.market,m.coin,m.path);
```

## Read the book and compare prices

Use viewHyperliquidSpot or viewHyperliquidVenue for the mark, depth and candles in a single metered request. Supply the deployer name for HIP-3. Depth estimates use one observed book, the selected side and the price tolerance. A reference mark, a last candle and the best available ask can differ. Preserve the venue time and show missing or delayed data explicitly.

## Prepare and open a trade ticket

Call hyperliquidOrderDraft with kind, market, side, type and decimal size. Add price and timeInForce for a limit, trigger for a protective order, or minutes for a TWAP. Gtc rests until cancellation, Ioc cancels the remaining size immediately, and Alo is post only. Open the returned reviewUrl. Size and order options are filled in for the selected market. The wallet owner checks available balance, account state, fees, eligibility and the current price bound before signing.

## Read account activity and recover

Account tools expose order status, funding and fills, wallet trading permissions, TWAP slices and withdrawal proof. For time-based history hold endTime fixed, pass nextStartTime and deduplicate overlap. Stop when the response reports a saturated timestamp. Handle source confirmation and destination delivery separately for withdrawals.

## Check venue and wallet support

Spot supports market and limit orders. USDC-quoted spot also supports eligible TWAPs. On supported perpetual markets protective orders are reduce only. Inspect the collateral, precision, account mode and live market status. Open the venue for owner authorization. [Browse the complete market directory](https://www.bitpont.com/perps/hyperliquid/markets/).

# Bitpont API Coverage | Products, Access and Wallet Handoffs

Find configured adapters and exact tool names across trading, bridging, Earn, liquidity, Portfolio, Treasury and Operations.

Canonical: https://www.bitpont.com/developers/product-coverage/


## Check the deployment first

Start with bitpont_integrationCoverage. Supply a product ID or request the full report. Each product lists its workspace, configured actions, configured reads, typed tools and native route count. Use bitpont_integrationManifest to inspect access for your current connection.

Server-side JavaScript
```
import {BitpontClient} from './bitpont-client.mjs';
const client = new BitpontClient({publicAccess:true});
const report = await client.agent('integrationCoverage',{product:'liquidity'});
console.log(report.data.products[0]);
```

## Choose how to run a task

Use findTools for paginated task search, describeTool for the exact schema and checkInputs before calling the provider. A tool marked public can be used within the free budget when enabled. Ordinary agent tools are keyless. Operator tools require separate permission. A provider can be unavailable. The native directory describes additional website endpoints with their own account and signing requirements.

## Start with a product workflow

- Swap and bridge: resolve both token identities, compare the quote and track delivery.
- Earn and liquidity: open viewEarnNetwork or viewSolanaPairPools, then inspect the exact reserve, pool or position.
- Perpetuals and options: select a venue, then a supported instrument and account.
- Portfolio: plan reads for selected wallets and preserve partial results.
- Treasury: review recipients and proposal hashes. Operations: draft a route and track each step separately.

## Connect with the smallest useful toolset

Add ?product=hyperliquid or another product ID to the remote MCP endpoint, or pass --product to the downloaded server. Use the same REST API for server integrations. The starter kit includes the schemas and worked examples. Contact support@bitpont.com for higher limits.

## Business integrations

List partner integration IDs using GET /api/v1/agent/business. For an estimate, POST to /api/v1/agent/business/plan with integration, callsPerMinute, readsPerCall and activeHours. For 30 calls per minute, three reads per call and eight active hours, sustained peak usage is 90 units per minute and 43,200 units per day. Download a brief at https://www.bitpont.com/business/#partner-start or request higher limits at support@bitpont.com.

## Solana swap fees

`POST /api/v1/agent/swap/solana/quote` returns the fee in `data.fee`. Read `amount` as an integer in base units of `mint`. Both `feeBps` and `bps` are 40 (0.40%). `recipient` is the treasury owner. `account` is its token account for the selected mint. Bitpont checks the output token account first, then the input token account. `amountSource` distinguishes Jupiter’s reported amount from an input or output estimate. A v1 quote may report an output fee even when the prepared route collects the input token.

A walletless quote can return `collectionAccountState` of `ready`, `missing`, `invalid`, or `unavailable`. `feeReady` requires a ready account and a positive quote. Recheck the fee mint, account and amount on each preparation. The unsigned instruction and transaction endpoints require the encoded rate and a successful simulated credit to the initialized Bitpont account. Read `simulatedAmount` and `simulationSlot` in the preparation fee. The signed ticket repeats the credit check before broadcast. A finalized transaction and recipient token balance change establish actual collection.

## Bridge fee evidence and partner rewards

For the direct deBridge agent route, display the returned source asset, recipient, rate and expected amount in source-token base units. Quote and preparation both report `settlementVerified: false`. The preparation names the kind of order evidence in `plan.fee.terms.basis`. Check the order ID and finalized source-chain credit separately. deBridge EVM fees normally transfer at source unlock. Deferred EVM credits and Solana cross-chain fees require a claim.

A Bitpont partner invitation links a Solana wallet on its first signed acceptance. A finalized Jupiter swap by an attributed wallet, including a supported agent-signed swap, can qualify. The ledger also tracks qualifying Velocity settlements. Solana limit orders require operator reconciliation. Bridge receipts and API calls alone do not automatically create partner credit. The partner dashboard reports a 20% share of qualifying received fees and manual payouts in each received token.

## Solana perps for an agent-owned wallet

Call `GET /api/v1/read/solana-perps.accounts?wallet=YOUR_ADDRESS` using the public API. Read the exact index with `POST /api/v1/views/solana-margin-account` and JSON fields `solWallet` and `subAccountId` (string). Check the mint, spot market index, precision, availability and current balance.

To deposit or withdraw, call `POST /api/v1/agent/perps/solana/order-intent` with `wallet`, integer `subAccountId`, `action` (deposit or withdraw), `spotMarketIndex`, `mint` and a human decimal `amount`. Sign the exact UTF-8 `message` locally. Include the returned bodyJson verbatim to preserve the signing bytes even when your client changes object key order. Supply the returned body, native path, timestamp, wallet and base58 signature as the input to the `solPerpTransaction` action at `/api/v1/agent/execution/prepare`. Supply a unique requestId. Keep the private workspace for preparation, submission and status. Review and sign only an unexpired awaiting-signature ticket with a signing payload. Submit against that execution ID and retrieve its status. For no-action, inspect the returned review before continuing. For initialization-required, review account setup separately and prepare the action again after setup. Refresh the subaccount to verify collateral or positions. An uninitialized account may require initialization and a fresh review. A cancel-all with no market index selects all markets in the chosen subaccount. Protective cleanup takes 1–32 distinct, explicitly reviewed order IDs.

Customer sessions require the owner's existing exact-action consent and signed payloads. A public key or a partner API key alone cannot authorize spending. Higher API limits are available by request at support@bitpont.com.

## Compare a Base USDC funding goal

Call `baseFundingGoal` from MCP or POST JSON to `/api/v1/agent/portfolio/base-funding-goal`. Enter the public Base address in `wallet` and use `"500000000"` for `targetUsdc` to compare a 500 USDC target. All USDC amounts use six decimal places. ETH inputs and reserves are in wei. The comparison is read-only.

Set `swapInputWei` for a wallet-bound Kyber comparison. Its minimum proceeds must cover the shortfall after the wallet balance. Set `marketId` for one Morpho Blue market lending native Base USDC. Supply withdrawal capacity is constrained by both the position and the market’s liquidity. Check debt and pledged collateral separately. An unavailable observation stays unknown. Follow the returned next tool for a fresh preparation. A customer or agent wallet still controls the signature. The same comparison is available in Portfolio → Activity → Get USDC on Base.

## Retained platform fees

When no qualifying referral applies, Bitpont retains the entire verified platform fee. With an eligible referral, the inviter earns 20% of qualifying fees actually received, in the token earned. Gas and provider fees are separate. The tradeReceipt allocation object reports bitpontRetained and referralEarned in fee-token base units. Until both the credit and attribution are verified, these values remain null.

## My lending returns

Read one Base Morpho Blue USDC supply market with `lendingReturns` or `POST /api/v1/agent/earn/lending/returns`. Pass wallet and marketId. Optional integer fromBlock and toBlock select a finalized interval up to 2,000 blocks. Opening value is measured immediately before the first included block. Deposits and withdrawals are logged against the position owner. A withdrawal can have a different recipient. Compare the closing claim with available market liquidity. Return after cash flows is shown in USDC base units when share movements reconcile. External incentive claims and network fees remain unknown. Portfolio Earn offers the same reader.

Base Morpho Blue supply, withdrawal, repayment and borrow tickets prepared by this release carry a lending receipt binding. The tradeReceipt lending object checks the original transaction, finalized block, core contract event, market, position owner, actual assets and shares and the wallet's USDC change. A missing match leaves the outcome awaiting evidence. Approval transactions do not produce a position receipt.

## Rehearse a position exit to USDC on Base

Open [Rehearse my exit](https://www.bitpont.com/portfolio/earn/#exit-rehearsal) or call `exitRehearse` with `wallet`, `marketId` and an optional `amountUsdc`. An amount of `"1000000"` requests a preview for one USDC. Use the market ID of the owner's Morpho Blue supply position on Base. The wallet address is public. Keep workspace credentials in request headers. Use `bitpont_describeTool` to retrieve the current input schema for each operation.

| Goal | MCP tool | REST method and path after `/api/v1/agent/portfolio/exit/` |
| --- | --- | --- |
| Preview the withdrawal and review the supported scope | `exitRehearse` | `POST rehearse` |
| Save the preview for a private workspace | `exitTaskCreate` | `POST task/create` |
| Resume the task | `exitTaskStatus` | `POST task/status` |
| Compare the preview with a finalized execution | `exitTaskCompare` | `POST task/compare` |
| Compare plans with the same starting assumptions | `exitPlanCompare` | `POST compare` |
| Check delivery in your private workspace | `exitRouteScorecard` | `POST scorecard` |
| Read pooled public route statistics | `publicRouteScorecard` | `POST public-scorecard` |
| Choose whether to contribute future submissions | `exitScorecardConsent` | `POST scorecard/consent` |

Before signing, compare the spendable wallet balance, redeemable supply, available market liquidity, requested amount, estimated ETH gas cost and destination. Save a fresh rehearsal with the same position and a UUID `requestId`. Retain its `taskId` and reuse the original `requestId` on retry. In the original workspace, request status with `taskId` or send `taskId` and `executionId` to compare a receipt. If the task supplies a preparation, pass its exact request to `executionPrepare`, including its distinct preparation `requestId` and gas limits. The saved task ID grants no permission to spend. On the owner host, `walletReview` checks the configured read-only policy adapter when one is available. An unavailable policy leaves authorization unknown. An owner-controlled signer authorizes the prepared transaction. Preserve the original execution ID if submission times out.

For a route scorecard, send `network`, `destinationNetwork`, `inputToken`, `outputToken` and `inputAmount` in input-token base units. Read the recorded period, sample size and comparable count before interpreting a deviation. Refund reports and unresolved rows are separate. Private records belong to the requesting workspace. `publicRouteScorecard` publishes the most recent complete UTC month that has had seven full days for observation. Each venue and size band needs at least 20 submissions, five consenting workspaces and five source wallets. No single workspace or source wallet may exceed 40% of the sample. Small outcome groups can be suppressed even when the overall count qualifies. `exitScorecardConsent` opts the workspace into future submissions or withdraws its contribution.

A funded comparison requires an actual finalized transaction. Match the Base market, owner, destination, token and USDC amount to the saved rehearsal. Report the receipt's USDC delivery and ETH gas charge separately, with their units. Keep unavailable fee or timing evidence unknown. To export a completed comparison from the offline kit, run `node exit-report.mjs TASK_ID` with the original `BITPONT_WORKSPACE` in the environment. The default report contains comparison amounts, gas and elapsed duration. Identifiers and timestamps are omitted. A transaction hash can identify the wallet on a public explorer. Keep simulations explicitly labelled.

[Inspect a 50 USDC controlled-RPC comparison](https://www.bitpont.com/assets/docs/developers/base-usdc-exit-comparison.json). Its gas measurements and transfer are simulated. It contains no mainnet transaction.

[Read the walkthrough](https://www.bitpont.com/help/ai-agents/rehearse-a-position-exit/) or use the MCP resource `bitpont://guides/rehearse-a-position-exit`.

## AI agent field guides

- [Connect an AI agent to Bitpont with MCP](https://www.bitpont.com/help/ai-agents/connect-bitpont-mcp/index.md)
- [Check a trading wallet before signing and verify its receipt](https://www.bitpont.com/help/ai-agents/check-trade-readiness-and-receipts/index.md)
- [Execute a DeFi trade from an agent wallet](https://www.bitpont.com/help/ai-agents/execute-with-agent-wallet/index.md)
- [Sign wallet actions and recover an agent order](https://www.bitpont.com/help/ai-agents/wallet-signing-and-order-recovery/index.md)
- [Quote token swaps and manage limit orders with an AI agent](https://www.bitpont.com/help/ai-agents/swaps-and-limit-orders/index.md)
- [Quote a cross-chain bridge and verify destination delivery](https://www.bitpont.com/help/ai-agents/cross-chain-bridge/index.md)
- [Find lending markets, vaults and staking actions for an agent](https://www.bitpont.com/help/ai-agents/lending-vaults-and-staking/index.md)
- [Find a liquidity pool and manage its position](https://www.bitpont.com/help/ai-agents/liquidity-pool-positions/index.md)
- [Trade perpetuals and inspect funding-rate markets](https://www.bitpont.com/help/ai-agents/perpetuals-and-funding-rates/index.md)
- [Read the options chain and place Derive limit orders](https://www.bitpont.com/help/ai-agents/options-limit-orders/index.md)
- [Plan Treasury payments and multi-step Operations](https://www.bitpont.com/help/ai-agents/treasury-payments-and-operations/index.md)
- [Build an agent portfolio view across wallets and positions](https://www.bitpont.com/help/ai-agents/portfolio-position-reads/index.md)
- [Verify trading fees and manage an agent’s API limits](https://www.bitpont.com/help/ai-agents/fees-and-api-limits/index.md)
- [Track referral earnings and request payouts through the API](https://www.bitpont.com/help/ai-agents/referral-receipts-and-payouts/index.md)
- [Validate a multi-tool DeFi workflow before execution](https://www.bitpont.com/help/ai-agents/validate-agent-workflows/index.md)
- [Approve and revoke a customer trading session](https://www.bitpont.com/help/ai-agents/customer-trading-sessions/index.md)
- [Build Hyperliquid spot and perpetual orders for the right market](https://www.bitpont.com/help/ai-agents/hyperliquid-spot-and-perpetual-orders/index.md)
- [Initialize a Solana perps account and recover an order](https://www.bitpont.com/help/ai-agents/solana-perps-account-and-order-recovery/index.md)
- [Borrow against collateral and repay a DeFi loan](https://www.bitpont.com/help/ai-agents/borrow-and-repay/index.md)
- [Open and unwind a Solana Multiply position](https://www.bitpont.com/help/ai-agents/multiply-positions/index.md)
- [Compare DeFi liquidity protocols and plan a position exit](https://www.bitpont.com/help/ai-agents/defi-protocol-discovery/index.md)
- [Verify the tokens and fees from an agent swap](https://www.bitpont.com/help/ai-agents/verified-swap-receipts/index.md)
- [Resume a swap, vault or bridge task from Portfolio or MCP](https://www.bitpont.com/help/ai-agents/resumable-portfolio-tasks/index.md)
- [Reconcile partner swap fees and settlement events](https://www.bitpont.com/help/ai-agents/reconcile-settlements/index.md)
- [Find a trading pair and build an exact swap or bridge quote request](https://www.bitpont.com/help/ai-agents/find-swap-and-bridge-quotes/index.md)
- [Batch dependent DeFi reads through the API or MCP](https://www.bitpont.com/help/ai-agents/batch-agent-reads/index.md)
- [Check an EVM execution ticket before the wallet signs](https://www.bitpont.com/help/ai-agents/preflight-evm-transactions/index.md)
- [Compare Earn opportunities after costs for a chosen holding period](https://www.bitpont.com/help/ai-agents/compare-earn-yield-and-costs/index.md)
- [Rehearse a position exit with Portfolio, REST or MCP](https://www.bitpont.com/help/ai-agents/rehearse-a-position-exit/index.md)
- [Check how much USDC a wallet can withdraw from lending](https://www.bitpont.com/help/ai-agents/check-lending-withdrawal-capacity/index.md)
- [Recover unfinished financial tasks after an agent restart](https://www.bitpont.com/help/ai-agents/resume-workspace-task-inbox/index.md)
- [Investigate a missing fee or settlement receipt](https://www.bitpont.com/help/ai-agents/investigate-settlement-exceptions/index.md)
