Using APIs and datasets from local agent harnesses

Most developers building autonomous agent loops run their code locally. Whether you are orchestrating agents in Python with LangChain and LlamaIndex, running custom TypeScript event loops, or working inside IDEs like Cursor and Claude Desktop, your agent needs real-world data and external tools to complete complex tasks.

Historically, giving a local agent access to third-party tools meant managing dozens of separate API accounts, signing up for monthly subscriptions, and hardcoding credit cards into local environment variables. If an agent needed to run three web searches, pull two blockchain state proofs, and download one training dataset, you had to subscribe to three different SaaS vendors and pay upfront minimums.

In an agent marketplace, you connect your local harness to a single Model Context Protocol (MCP) endpoint. Your local agent searches the catalogue, inspects data schemas for free, and pays for API calls and dataset downloads on demand using x402 micropayments in USDC.

Here is the complete guide to initializing Sella inside a local agent harness, finding verified tools, and executing paid calls safely.

How the local harness architecture works#

When an agent runs in a local harness, it interacts with Sella through a standard JSON-RPC interface over MCP.

The interaction pattern divides into two distinct operational phases:

1. Free discovery phase: The agent calls search_catalog, describe_catalog, and get_listing. These tools run in a keyless, rate-limited sandbox and return complete Application Data Contract (ADC) metadata, schema types, and pricing terms without touching your balance.
2. Paid execution phase: When the agent calls call_api or get_dataset, the request is authenticated via the agent's API key. The Sella backend proxy checks operator spend limits and settles the micro-payment in USDC over x402 on Base or Solana.

Because the settlement is machine-native, your local harness does not need to handle invoicing, credit card forms, or vendor onboarding.

Full initialization steps for your local harness#

Connecting your local harness to Sella takes four sequential steps.

1. 1

   Step 1: Onboard your agent and initialize the wallet

   Your agent needs an API key and a local wallet configuration. Choose one of the three supported onboarding methods:

   • Method A (Dashboard Setup Code): Open the Sella dashboard in your browser, generate a one-time setup code (such as SELLA-XXXX-XXXX-XXXX-XXXX), and pass it to your local agent.
   • Method B (In-Band Email Authentication): In your agent code, call sella_auth_start with your email. Check your inbox for the 6-digit verification code, and call sella_auth_complete to receive your credentials.
   • Method C (Command Line): Run npx sella-cli init in your terminal to generate credentials automatically.

   When onboarding completes, save the returned walletConfig to ~/.sella-wallet.json and keep the apiKey in your local .env file.

2. 2

   Step 2: Configure your local MCP client

   Add the Sella MCP server to your local environment. If you are using a configuration file (like in Claude Desktop, Cursor, or a local harness runner), add the server definition:

   {
     "mcpServers": {
       "sella": {
         "url": "https://www.selltoagent.dev/api/mcp",
         "headers": {
           "Authorization": "Bearer YOUR_SELLA_API_KEY"
         }
       }
     }
   }

   If you are using the Python MCP SDK in a custom agent harness, connect to the endpoint using an asynchronous HTTP session:

   import os
   from mcp import ClientSession
   from mcp.client.sse import sse_client
   
   async def init_sella():
       api_key = os.getenv("SELLA_API_KEY")
       headers = {"Authorization": f"Bearer {api_key}"}
       async with sse_client("https://www.selltoagent.dev/api/mcp", headers=headers) as (read, write):
           async with ClientSession(read, write) as session:
               await session.initialize()
               return session

3. 3

   Step 3: Discover endpoints and inspect schemas

   Before spending funds, have your agent search the catalogue for relevant capabilities using search_catalog:

   {
     "jsonrpc": "2.0",
     "method": "tools/call",
     "params": {
       "name": "search_catalog",
       "arguments": {
         "query": "solana rpc archive",
         "kind": "api"
       }
     }
   }

   The agent inspects candidate listings with get_listing. As detailed in our post on what an agent reads on a listing, the response contains the exact column types, endpoint URL format, nullability rates, and unit price in USDC.

4. 4

   Step 4: Verify price with a dry run and execute

   To prevent unexpected token or dollar spend, your local agent runs a dry-run check before the live invocation:

   Preflight price checkRun it

   {
     "jsonrpc": "2.0",
     "method": "tools/call",
     "params": {
       "name": "call_api",
       "arguments": {
         "endpoint_id": "api_solana_rpc_archive",
         "dry_run": true
       }
     }
   }

   The dry-run response confirms the per-call price and verifies that your local wallet policy approves the expenditure. Once confirmed, the agent sets dry_run: false to execute the call and receive the live data payload.

Calling APIs vs. downloading datasets#

Depending on your agent's workload, Sella supports two primary consumption models:

1. Pay-per-call API proxies (call_api)#

For real-time queries, search requests, and inference tasks, your agent uses USDC pay-per-call APIs.

• How it works: Your local agent passes the endpoint_id and query arguments to call_api.
• Payment: Sella handles the upstream authentication and settles the $0.01 to $0.05 USDC fee from your local wallet per call.
• Best for: Real-time market prices, on-demand web search, and dynamic entity enrichment.

2. Full dataset package delivery (get_dataset)#

For quantitative modeling, fine-tuning, or bulk backtesting, your agent buys complete data packages:

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "get_dataset",
    "arguments": {
      "dataset_id": "ds_liquidity_pools_2026_q3"
    }
  }
}

Once the x402 payment clears, Sella delivers the data inline or returns a signed temporary download URL. If a download is interrupted by a local network drop, your harness can call deliver_product with the product_id to obtain a fresh temporary link without paying a second time.

Automated error handling and budget guardrails#

When running unattended agent harnesses in production, implement these four defensive safeguards:

1. Pre-flight wallet balance checks: Call budget_status at the start of every autonomous loop to confirm that your active wallet on Base or Solana has sufficient USDC balance for planned operations.
2. Handle offline providers gracefully: If an upstream vendor goes offline, call_api returns an ENDPOINT_OFFLINE error code. Configure your harness to catch this code and query browse_catalog for alternative verified providers.
3. Enforce hard local spending caps: While Sella's policy_check tool provides server-side policy advice, your local agent code should enforce local per-hour and per-day token and dollar limits.
4. Local result caching: Store deterministic API responses locally in SQLite or Redis. An agent running repeated entity lookups should check its local cache first before issuing a paid API query.