---

name: antseed-connect description: Connect coding agents, AI SDKs, and LLM tools to the AntSeed buyer proxy. Use when configuring Claude Code, Codex, OpenCode, Pi, OpenClaw, Hermes, GenLayer Studio, Vercel AI SDK, LangChain, or raw HTTP to route inference through AntSeed at localhost:8377.

AntSeed — Integration Skill

This file is the agent-readable companion to https://antseed.com/integrations. It tells any AI agent (Claude, Codex, OpenClaw, Hermes, custom) exactly how to wire its tool of choice up to the AntSeed peer-to-peer inference network.

What is AntSeed?

AntSeed is a peer-to-peer marketplace for AI inference. Buyers run a small local daemon (the buyer proxy) that exposes an HTTP API at http://localhost:8377 speaking the three caller-facing LLM API protocols: Anthropic Messages, OpenAI Chat Completions, and OpenAI Responses. Legacy OpenAI Completions is supported internally for adapter translation. The proxy discovers providers on a DHT, routes the request to a peer, translates between protocols when needed (via @antseed/api-adapter), and settles in USDC on Base.

Important: AntSeed is for value-added AI services (specialized models, agents, TEEs, fine-tunes, managed workflows), not raw resale of API keys or subscription access. Providers must comply with upstream terms of service.

From the perspective of any tool, SDK, or agent, AntSeed is just a local OpenAI/Anthropic-compatible endpoint — point a base_url at it and you are done.

Glossary (mental model)

• Buyer proxy — the local server on localhost:8377 that accepts API calls from your tools and forwards them to AntSeed peers. It is the only thing your editor / agent / SDK ever talks to.

• Peer — someone selling inference. Each peer has a peerId (40-char hex), a display name, and a list of services. List with antseed network browse.

• Service — a single model id like claude-sonnet-4-6 or deepseek-v4-flash. This is what you pass as model in your tool's config. Each service has its own native protocol list and its own in / cachedIn / out pricing.

• Protocols (per service) — the wire formats a service accepts natively, advertised on each peer in providerServiceApiProtocols[provider].services[service]. Values are anthropic-messages, openai-chat-completions, openai-responses, openai-completions. This is the field to match your tool's wire format against. If your tool's wire format is in this list, the request passes through untouched; if not, the api-adapter translates on the fly.

• Cached input pricing — services charge a separate, much lower rate (typically 4–10×) for tokens that are reused across requests: system prompts, tool schemas, prior conversation turns, long files you keep referencing. The CLI exposes it as cachedInputUsdPerMillion. For long-running agents and chatbots, this is often the dominant cost line.

• Pin — telling the buyer proxy "route requests to this peer." In the default manual flow, there is no peer auto-selection; you must choose a peer, send a per-request pin header, or start the proxy with a router plugin that performs selection. Common explicit routes:

  • Session pin: antseed buyer connection set --peer <peerId>. Persists in ~/.antseed/buyer.state.json and applies to every request until you change it.
  • Per-request header: x-antseed-pin-peer: <peerId> on each call. Overrides the session pin for that request, and works without any session pin at all.
  • Model prefix: set model to <peerId>@<service>. The proxy uses the prefix as the peer pin and forwards only <service> to the seller.

  If both header and model-prefix pins are present, the header selects the peer; the model prefix is still stripped before routing. Until at least one of these is in effect, every request returns no_peer_pinned.

Universal setup (do this once)

Option A — VPR desktop app (easiest)

Download from https://antseed.com — it ships the buyer proxy, a wallet, and a peer browser in a GUI. While the app is open the proxy is reachable at http://localhost:8377.

Option B — CLI (headless / servers / agents)

# 1. Install
npm install -g @antseed/cli

# 2. Identity (an EVM private key — 64 hex chars). Save this somewhere safe;
#    you will reuse it across machines and it controls your USDC deposits.
export ANTSEED_IDENTITY_HEX=$(openssl rand -hex 32)
# SECURITY: never paste this key into chat, logs, GitHub issues, or a file
# committed to git. It controls the buyer identity and access to deposits.

# 3. Start the buyer proxy on :8377
antseed buyer start &

# 4. Browse the network and list every service (= model) each peer offers,
#    along with its native protocols and USD-per-1M-tokens pricing.
#    `service` is the model id you pass to your tool. `protocols` is the
#    wire format(s) the service accepts natively — match it against your
#    tool. `in` / `cachedIn` / `out` are fresh-input / cached-input / output.
antseed network browse --json --top 5 \
  | jq '.peers | map({
      peerId, name: .displayName,
      services: [
        (.providerServiceApiProtocols | to_entries[]) as $p
        | ($p.value.services | to_entries[]) as $s
        | {
            service:  $s.key,
            protocols: $s.value,
            in:       (.providerPricing[$p.key].services[$s.key].inputUsdPerMillion       // .providerPricing[$p.key].defaults.inputUsdPerMillion),
            cachedIn: (.providerPricing[$p.key].services[$s.key].cachedInputUsdPerMillion // null),
            out:      (.providerPricing[$p.key].services[$s.key].outputUsdPerMillion      // .providerPricing[$p.key].defaults.outputUsdPerMillion)
          }
      ]
    })'

# 5. Inspect one peer in detail. Use `matchingServices[]` for pricing/tags and
#    `peer.providerServiceApiProtocols` for native protocol support.
#    `cachedIn` is typically 4–10× cheaper than `in` and often dominates the
#    cost line for long-running agents and chatbots — always include it when
#    comparing peers.
antseed network peer <peerId> --json \
  | jq '{
      peer: (.peer | { peerId, name: .displayName,
                       sessions: .onChainChannelCount,
                       ghosts:   .onChainGhostCount }),
      services: [
        (.peer.providerServiceApiProtocols | to_entries[]) as $p
        | ($p.value.services | to_entries[]) as $s
        | (.matchingServices[] | select(.provider == $p.key and .service == $s.key)) as $m
        | {
            provider: $p.key,
            service: $s.key,
            protocols: $s.value,
            in:       $m.inputUsdPerMillion,
            cachedIn: $m.cachedInputUsdPerMillion,
            out:      $m.outputUsdPerMillion,
            tags:     $m.tags
          }
      ]
    }'

# 6. Pin a peer (session-wide). Until you do, every request returns
#    `no_peer_pinned` UNLESS the request includes an `x-antseed-pin-peer`
#    header (see Per-request peer selection below).
antseed buyer connection set --peer <peerId>

# 7. Verify the proxy advertises the services you expect
curl -s http://localhost:8377/v1/models | jq '.data[].id'

# 8. (Optional) Deposit USDC on Base for paid services
antseed payments  # opens portal at 127.0.0.1:3118?token=<hex> — connect a wallet, deposit USDC

Security notes for agents and deploys

• Treat ANTSEED_IDENTITY_HEX / ~/.antseed/identity.key as a hot wallet key. Never print it, paste it into chat, commit it, or copy it off the buyer host.
• Keep the buyer proxy bound to 127.0.0.1 / localhost. Do not expose :8377 directly to the public internet; use SSH tunnels or a private network if another process must reach it remotely.
• Start with small USDC deposits and conservative reserve caps for autonomous agents. The funding wallet does not need to stay connected after depositing.
• If a tool requires an API key, use a non-secret placeholder such as antseed; the buyer proxy authenticates with the local identity key instead.

Endpoints exposed by the buyer proxy

| Path | Wire format | Common callers | |------|-------------|----------------| | POST /v1/messages | Anthropic Messages | Claude Code, Anthropic SDKs, OpenClaw | | POST /v1/chat/completions | OpenAI Chat Completions | Codex, Hermes, OpenAI SDKs, Vercel AI SDK, LangChain, most tools | | POST /v1/responses | OpenAI Responses | Codex (newer builds), tools using the Responses API |

All four protocols (including legacy openai-completions) are supported by @antseed/api-adapter for translation, but only the three endpoints above are exposed to callers. Translation is automatic: a request that arrives in one format and is routed to a peer whose service advertises a different protocols value is transformed both directions (request and streaming response).

No Authorization header is required by the buyer proxy. It authenticates and pays peers using the local node's identity key and on-chain USDC deposits.

Per-request peer selection (no session pin needed)

Two ways to tell the proxy which peer to use:

1. Session pin — antseed buyer connection set --peer <peerId>. Persists in ~/.antseed/buyer.state.json (pinnedPeerId) and applies to every request until you change it. Best for single-tenant setups (laptops, dedicated agents).
2. Per-request header — send x-antseed-pin-peer: <peerId> on each call. Overrides the session pin for that one request. You do not need to call antseed buyer connection set at all if every request includes this header — the proxy will accept and route them. Best for scripts, schedulers, and multi-tenant deployments that need to fan out to different peers per call.

Example (per-request, no session pin):

curl http://localhost:8377/v1/chat/completions \
  -H 'content-type: application/json' \
  -H 'x-antseed-pin-peer: 4668854ba3e8b094e6f48fbeb59cec1cfde162f2' \
  -d '{ "model": "minimax-m2.7", "messages": [{"role":"user","content":"hi"}] }'

Other optional headers:

• x-antseed-provider: <providerName> — when a peer exposes the same service through more than one seller-plugin (rare), force a specific one. Most tools never need this.

Files the CLI creates in ~/.antseed/

Knowing what lives in ~/.antseed/ matters for backups, container deploys, and debugging. The directory is created on first antseed buyer start (or first run of any antseed command that needs it).

| Path | Purpose | Survives restart? | Safe to delete? | |------|---------|--------------------|------------------| | identity.key | Raw 32-byte EVM private key for the buyer wallet. Fallback when ANTSEED_IDENTITY_HEX is not set. | yes | NO — deleting loses access to your USDC deposits. Back this up. | | identity.enc | Encrypted copy of identity.key (when the desktop app sets a passphrase). | yes | only if identity.key is also intact | | config.json | Static settings: chain id, proxy port, max-pricing caps, bootstrap nodes, payments preferences. Hand-editable. | yes | yes (defaults are sane) | | buyer.state.json | Live runtime state: pinnedPeerId, the discovered-peers cache (discoveredPeers), on-chain stats, the proxy pid and port. Re-built from the network on next start. | yes (the pin survives restart) | yes (you lose the pin and the cached peer list — next browse will repopulate) | | metering.db | SQLite log of every request the proxy served (model, peer, tokens, USDC). Used by antseed buyer status and the payments portal. | yes | yes (you lose request history; settlement is unaffected) | | payments/ | Per-channel state used by the seller-side settlement flow (only relevant if you also run antseed seller). | yes | only if you do not run a seller | | plugins/ | Cache of downloaded provider plugins. | yes | yes (re-downloaded on next use) | | chat/, projects/ | Used by the desktop app for local chat history. Empty