MCP passthrough · Alpha pilot

Test AI inference through your node.

Connect your MCP client to your own eIOU node and try inference from participating providers. You bring a working node. We help you configure the plugin and provider access, so you can test model calls and how they use eIOU credit.

Apply with a working node. If accepted, we help you prepare your first test call.

You bring the node. We help you test inference.

The pilot tests the path from your MCP client, through your eIOU node, to a model provider. We help you get that connection working; you try model calls and tell us what succeeds or fails.

Applying: the form emails your request to contact@eiou.org for manual review. It does not automatically provision a node, install the plugin, or connect your client. Setup help follows acceptance into the pilot.

Need a node before applying? Set up your own node or request a node hosted by us. Each hosted node in the pilot runs its own MCP passthrough plugin and connects to remote inference providers. Our hosted servers do not run local models or Ollama sidecars. Arrange hosting before applying so you have a working node address.

Client-specific setup belowProvider choice stays with the nodeUsage and balance are inspectablePlugin in testing

From your client to a provider

How a model call works

Your client sends a request to the plugin on your node. With automatic routing enabled, your node can find a model provider through its contacts and return the result to your client. You enable routing and set spending limits in the plugin’s Network settings; routing is off by default.

  • Connect once: your client keeps a key for your own node; your node manages provider connections.
  • Inspectable: list models, check balance, and review usage before or after a call.
  • Know who receives your prompt: your node, the chosen provider, and any upstream model service process it. A retry can involve another provider; read about inference privacy.

Set up your connection

Set up your pilot connection

After acceptance, work through node preparation with the pilot team, then open the instructions for your client. These steps use eIOU MCP Passthrough v0.29.3 on eiou-docker v0.1.21-alpha. Use your node’s HTTPS address and the client key arranged during setup.
1. Prepare your node with the pilot teamPilot setup

Install MCP Passthrough v0.29.3

Start with a running node you administer. This checklist covers the plugin and inference connection; use the node documentation if you still need to create a node before applying.

Every participating node needs its own MCP passthrough plugin, including nodes we host. Our hosted nodes connect to remote inference providers; they do not run local models or Ollama sidecars.

  1. Check that your client can reach the node’s hostname over HTTPS with a certificate it trusts. The basic Docker setup starts with EIOU_HOST=eiou and a self-signed certificate; a reachable hostname and trusted HTTPS still need to be configured.
  2. Verify and upload mcp-passthrough-v0.29.3.zip using the installation guide.
  3. Enable the plugin, approve its permissions, and turn on Public routes.
  4. Arrange client access with pilot support. In the default pilot mode, customer keys must be bound to an accepted contact. Owning the node does not automatically provide a self-use key, and you cannot add your own node as its own contact.
  5. For billed client calls, the key needs sufficient prepaid balance or available credit extended to its bound contact. Separately, your node needs an accepted credit route to fund network providers.
  6. To buy inference through contacts, enable Network → Automatic routing, set spending limits, and connect to participating providers. Routing is off by default. Review eligible offers and use Warm the best sellers now to prepare provider credentials; routed funding may take time to arrive before a provider is ready.

The installation guide includes the ZIP, SHA-256 checksum, and publisher-signature verification steps.

Open the versioned install and verification guide →

2. Connect your MCP client

Once your node, client key, and credit are ready, open the instructions for the client you use.

CursorDirect HTTP

Use your personal MCP configuration

Open ~/.cursor/mcp.json on macOS/Linux, or %USERPROFILE%\.cursor\mcp.json on Windows. Merge this server into mcpServers if the file already contains other servers.

{
  "mcpServers": {
    "eiou-passthrough": {
      "url": "https://YOUR-NODE/p/mcp-passthrough/mcp",
      "headers": {
        "Authorization": "Bearer mcp_REPLACE_WITH_YOUR_NODE_KEY"
      }
    }
  }
}

Replace the URL and bearer key, save, and enable the server in Cursor’s MCP settings. Reload Cursor if it does not appear. A project’s .cursor/mcp.json is also supported, but a personal config avoids putting a live key into the project.

Confirm that chat.list_models and balance.check are available before making a billed call.

Cursor’s MCP configuration guide ↗
Claude DesktopLocal bridge

Launch an authenticated HTTP bridge

Install Node.js 18 or newer with npm, then open Settings → Developer → Edit Config. On macOS the file is ~/Library/Application Support/Claude/claude_desktop_config.json; on Windows it is %APPDATA%\Claude\claude_desktop_config.json.

{
  "mcpServers": {
    "eiou-passthrough": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@0.14.3",
        "https://YOUR-NODE/p/mcp-passthrough/mcp",
        "--transport",
        "http-only",
        "--header",
        "Authorization:${EIOU_AUTH_HEADER}"
      ],
      "env": {
        "EIOU_AUTH_HEADER": "Bearer mcp_REPLACE_WITH_YOUR_NODE_KEY"
      }
    }
  }
}

Merge the entry into your existing mcpServers, replace the URL and key, then fully quit and restart Claude Desktop. The pinned mcp-remote bridge translates local stdio to Streamable HTTP and adds the bearer header. Leave the header variable reference in args unchanged; put your key in env. If Desktop cannot find npx, set command to its absolute installed path.

Check for the eIOU tools, list models and check the balance before trying a small paid completion.

Desktop’s Settings → Connectors remote connection runs from Anthropic’s cloud. It cannot reach your localhost or private node merely because your computer can. This plugin uses a static bearer key; use the local bridge recipe above rather than pasting this endpoint into the remote connector flow.

Local Desktop setup ·Remote connector guidance ·Bridge documentation

Claude CodeDirect HTTP

Add the endpoint from your terminal

claude mcp add --transport http \
  eiou-passthrough \
  https://<your-eiou-host>/p/mcp-passthrough/mcp \
  --header "Authorization: Bearer mcp_<CUSTOMER_API_KEY>"
claude mcp get eiou-passthrough

Replace the placeholders and keep the live key out of saved shell history.

Treat each bearer key as a password. These examples store keys in personal configuration; an env entry is not encrypted storage. Restrict access to the file, never commit it, and revoke a key if it leaks.

Use HTTPS for a remote node. Direct .onion access needs a separately configured Tor-capable connection; these client recipes do not configure Tor for you.

Know the boundary

Security and privacy, in plain language

01

Bearer keys are credentials

Store the pilot key in your client's secret or environment facility. The public form never asks for it. Personal client configuration can store it in plain text; protect that file and never commit it.

02

The plugin is sandboxed

It runs in a dedicated process pool with confined filesystem access. The public route does not receive an operator's wallet session cookie.

03

Inference can be billed

Check model prices and balance before a call. Completed output is billed; a partial stream can be billed for the tokens delivered.

04

The tester form is minimal

It collects a node address and optional contact details only for pilot coordination. Review the privacy policy.

Current status

The MCP passthrough plugin is in testing.

There is no uptime or compatibility guarantee. Provider admission, customer access, prices, limits, and available models can change during the pilot.

Pilot information
Public · no login
Tester intake
Open · manual review
Provider network
Open alpha · no SLA

Short answers

Pilot FAQ

Do I need to run a provider node?

You need a basic eIOU node you control, with the MCP passthrough plugin installed, to test discovery through your contacts. The pilot also needs a valid client-key binding and sufficient credit; installing a node alone does not grant inference access. Coordinate that setup with the pilot team using the setup checklist. You do not need a GPU, your own model, or a provider API subscription. Supplying inference is a separate provider role.

Does signing up create a node or connect my client?

The pilot starts with a working node you administer. Applying sends a request for manual review. If accepted, we help you configure the plugin, client connection, provider contacts, and credit. Hosted-node setup is a separate service you can ask about before applying.

How does a hosted node run inference?

We host the eIOU node, and each pilot node runs its own MCP passthrough plugin. The plugin sends inference requests to remote providers or online model APIs. Our hosted servers do not run local models, Ollama sidecars, or other local inference runtimes. Running a local model requires separate infrastructure you operate.

Can I apply before I have a node?

The tester form requires a working node address you control. Set up your own node before applying, or arrange a hosted node first. Hosted pilot nodes use remote inference providers and have separate privacy terms.

Which clients work?

Cursor and Claude Code can connect over Streamable HTTP. Claude Desktop uses a local bridge. Follow the separate client setup instructions; Desktop's cloud-hosted remote connector is a different connection method.

What does a model call cost?

Each node publishes customer-facing input and output rates. Use chat.list_models before spending and usage.recent afterward.

Can I use a production workload?

Not yet. This is an open alpha with no SLA. Keep important data out of prompts and design for interruption.

Where do I report a security issue?

Email mcp-security@eiou.org; do not include live bearer keys, wallet seeds, or provider tokens.

Is the operator dashboard public?

No. These pages contain public pilot information and the tester request form. Operator controls remain authenticated on the node.

Have a node and want to help test?

Request to join the alpha pilot.

Request to join the pilot