Connect your tools

If a tool speaks MCP, it can hand work to your project's donated tokens. If it lets you set a base URL, donated tokens can power its main model. Most current tools do both.

The safest path is moochy run. For any command-line agent (Claude Code, OpenCode, Aider, Goose, …), moochy run -- <agent> starts it in a sandbox already pointed at Moochy, with nothing to configure: inside, the standard variables (ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, OPENAI_BASE_URL, OPENAI_API_KEY) point to Moochy and carry a token made for that run only. Tool calls from donated tokens only reach agents inside moochy run: a tool connected with the settings on this page gets text answers, and each tool call is replaced by a visible [moochy] notice, unless the project allows it (moochy config set allow_unsandboxed_tools owner/repo, with a warning at every start). See Run your agent safely with moochy run. The settings below are for editors and apps that cannot run inside moochy run, for moochy_delegate, and for scripts that need no tool calls.

The quickest path is moochy connect <tool> in your repository: it prints the settings below with your real port, repository, and available models filled in, and --write adds them to the tool's user-level config after showing the change. This page is the same information written out, for review and for tools moochy connect does not know.

Tools change their configuration formats between versions. When a snippet here and moochy connect disagree, trust moochy connect (it is updated with each release of the app) and tell us.

1. The values you need#

moochy up
moochy env --repo owner/repo --json
# {"anthropic_base_url":"http://127.0.0.1:PORT","openai_base_url":"http://127.0.0.1:PORT/v1","token":"…"}
export MOOCHY_TOKEN="$(moochy env --repo owner/repo --json | jq -r .token)"
# or simply: eval "$(moochy env --repo owner/repo)"   # ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, OPENAI_BASE_URL, OPENAI_API_KEY, MOOCHY_MCP_URL

• PORT is chosen once at the first moochy up and then stays fixed, so configs keep working.
• The token is scoped to one repository and only works on this machine. Keep it out of git: use environment variables or the tool's secret storage, never a file tracked by git.
• Both ways in listen on 127.0.0.1 only, refuse requests with a foreign Host header, and send no CORS headers, so web pages cannot reach them.
• Models are public slugs such as anthropic/claude-sonnet-5, deepseek/deepseek-chat, x-ai/grok-4, or any OpenRouter model id; providers' own ids are accepted too. Use only ids listed by GET /v1/models or moochy_pool_status: they are what donors offer your project right now. The examples below use anthropic/claude-sonnet-5; use your project's models.
• Formats. Anthropic donors serve the Anthropic format; OpenAI and xAI (Grok) donors serve the OpenAI format; OpenRouter and DeepSeek donors serve both. A Claude Code session therefore needs Anthropic, OpenRouter, or DeepSeek donors, and a Grok model is reached through the OpenAI-compatible endpoint. moochy_delegate picks the right format for you. Codex uses the OpenAI Responses format, which OpenAI, xAI, and OpenRouter donors serve; requests must be self-contained (store and previous_response_id are refused).
• GUI applications often do not inherit your shell's PATH. If an MCP server fails to start, use the absolute path from command -v moochy as the command.

MCP tools#

Files shared with moochy_delegate come only from inside the repository, at most 2 MiB in total; .git, .env and key files, secret-looking files, and files ignored by git are refused, and secrets are removed from the text before it is encrypted.

Long tasks send MCP progress notifications. Some tools stop waiting for a tool call after about a minute; raise the tool timeout where the tool allows it (shown below).

What is verified by our end-to-end tests#

Our internal end-to-end suite runs the real moochy and relay binaries against fake providers. It tests the ways in with plain HTTP and MCP clients, not the third-party tools themselves:

In the tables below, E2E names the scenario that covers the way in a snippet uses. Tool says how the tool's own settings were checked: manual = checked by hand against the tool's documentation and release, not in automated tests.

2. Coding agents and IDEs#

"MCP only" means the agent cannot use a local base URL for its model; it still delegates work to donated tokens with moochy_delegate.

Claude Code#

Recommended: moochy run -- claude in your repository. It needs no setup and is the only way Claude Code receives tool calls from donated tokens. To configure Claude Code yourself instead:

MCP, user scope (available in every project):

claude mcp add --scope user moochy -- moochy mcp --repo owner/repo
# or over HTTP:
claude mcp add --scope user --transport http moochy http://127.0.0.1:PORT/mcp \
  --header 'Authorization: Bearer ${MOOCHY_TOKEN}'   # single quotes: Claude Code expands it at start, the token is not stored

Raise the tool timeout for long tasks: export MCP_TOOL_TIMEOUT=300000 (milliseconds).

API (donated tokens as Claude Code's model). Works with Anthropic, OpenRouter, and DeepSeek donors, which all serve the Anthropic format:

export ANTHROPIC_BASE_URL=http://127.0.0.1:PORT
export ANTHROPIC_AUTH_TOKEN="$MOOCHY_TOKEN"
export ANTHROPIC_MODEL=anthropic/claude-sonnet-5
export ANTHROPIC_DEFAULT_HAIKU_MODEL=anthropic/claude-haiku-4.5   # small/fast model: pick one donors offer
claude

Or put the same keys in the env block of ~/.claude/settings.json (user-level, never the project's .claude/settings.json if it is committed).

OpenCode#

~/.config/opencode/opencode.json. You can use both ways in at once: a donated model as the main model and moochy_delegate for sub-tasks.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "moochy": {
      "type": "local",
      "command": ["moochy", "mcp", "--repo", "owner/repo"],
      "enabled": true
    }
  },
  "provider": {
    "moochy": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Moochy",
      "options": {
        "baseURL": "http://127.0.0.1:PORT/v1",
        "apiKey": "{env:MOOCHY_TOKEN}"
      },
      "models": {
        "anthropic/claude-sonnet-5": {},
        "deepseek/deepseek-chat": {}
      }
    }
  },
  "model": "moochy/anthropic/claude-sonnet-5",
  "small_model": "moochy/deepseek/deepseek-chat"
}

MCP over HTTP instead of stdio:

"moochy": {
  "type": "remote",
  "url": "http://127.0.0.1:PORT/mcp",
  "headers": { "Authorization": "Bearer {env:MOOCHY_TOKEN}" }
}

For Claude models served by Anthropic donors, "npm": "@ai-sdk/anthropic" with the same baseURL keeps Anthropic prompt caching, which makes donations go further.

Cursor#

~/.cursor/mcp.json:

{
  "mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP:

{
  "mcpServers": {
    "moochy": {
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer TOKEN" }
    }
  }
}

Cline#

MCP: Cline → MCP Servers → Configure (cline_mcp_settings.json):

{
  "mcpServers": {
    "moochy": {
      "command": "moochy",
      "args": ["mcp", "--repo", "owner/repo"],
      "timeout": 300
    }
  }
}

Over HTTP: {"type": "streamableHttp", "url": "http://127.0.0.1:PORT/mcp", "headers": {"Authorization": "Bearer TOKEN"}}.

API: Settings → API Provider OpenAI Compatible: Base URL http://127.0.0.1:PORT/v1, API Key = token, Model ID = a model donors offer. Or provider Anthropic with "Use custom base URL" = http://127.0.0.1:PORT.

Continue#

~/.continue/config.yaml, with the token stored as a Continue secret named MOOCHY_TOKEN:

name: moochy
version: 0.0.1
schema: v1
models:
  - name: Claude Sonnet (Moochy)
    provider: openai
    model: anthropic/claude-sonnet-5
    apiBase: http://127.0.0.1:PORT/v1
    apiKey: ${{ secrets.MOOCHY_TOKEN }}
    roles: [chat, edit, apply]
mcpServers:
  - name: moochy
    command: moochy
    args: [mcp, --repo, owner/repo]

Zed#

settings.json:

{
  "context_servers": {
    "moochy": {
      "command": "moochy",
      "args": ["mcp", "--repo", "owner/repo"]
    }
  },
  "language_models": {
    "openai_compatible": {
      "Moochy": {
        "api_url": "http://127.0.0.1:PORT/v1",
        "available_models": [
          { "name": "anthropic/claude-sonnet-5", "display_name": "Claude Sonnet (Moochy)", "max_tokens": 200000 }
        ]
      }
    }
  }
}

Enter the token as the provider's API key in the Agent panel settings.

Goose#

~/.config/goose/config.yaml:

extensions:
  moochy:
    name: moochy
    type: stdio
    cmd: moochy
    args: [mcp, --repo, owner/repo]
    enabled: true
    timeout: 300

Over HTTP: type: streamable_http, uri: http://127.0.0.1:PORT/mcp, headers: {Authorization: "Bearer TOKEN"}.

API:

export GOOSE_PROVIDER=anthropic
export ANTHROPIC_HOST=http://127.0.0.1:PORT
export ANTHROPIC_API_KEY="$MOOCHY_TOKEN"
export GOOSE_MODEL=anthropic/claude-sonnet-5

Windsurf#

~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP: {"serverUrl": "http://127.0.0.1:PORT/mcp", "headers": {"Authorization": "Bearer TOKEN"}}.

VS Code (agent mode)#

Command palette → MCP: Open User Configuration (mcp.json). The inputs entry makes VS Code prompt for the token once and store it securely, so no token lands in a file:

{
  "inputs": [
    { "type": "promptString", "id": "moochy-token", "description": "Moochy token (moochy env --json)", "password": true }
  ],
  "servers": {
    "moochy": {
      "type": "stdio",
      "command": "moochy",
      "args": ["mcp", "--repo", "owner/repo"]
    },
    "moochy-http": {
      "type": "http",
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer ${input:moochy-token}" }
    }
  }
}

Use one of the two entries, not both.

Aider#

export OPENAI_API_BASE=http://127.0.0.1:PORT/v1
export OPENAI_API_KEY="$MOOCHY_TOKEN"
aider --model openai/anthropic/claude-sonnet-5

The openai/ prefix tells Aider to use the OpenAI-compatible endpoint; the rest is the model id.

Codex (OpenAI Codex CLI)#

moochy connect codex · Codex 0.95 or later (MCP over HTTP with a bearer variable needs 0.48) · Sources, read 2026-10-02: https://developers.openai.com/codex/mcp, https://developers.openai.com/codex/config-reference

Recommended: moochy run -- codex in your repository; inside the sandbox Codex reaches Moochy's MCP server through moochy mcp.

MCP, ~/.codex/config.toml (or .codex/config.toml in a trusted project):

[mcp_servers.moochy]
command = "moochy"
args = ["mcp", "--repo", "owner/repo"]

Over HTTP, with the token read from MOOCHY_TOKEN and sent as Authorization: Bearer:

[mcp_servers.moochy]
url = "http://127.0.0.1:PORT/mcp"
bearer_token_env_var = "MOOCHY_TOKEN"

Or from the command line: codex mcp add moochy -- moochy mcp --repo owner/repo, or codex mcp add moochy --url http://127.0.0.1:PORT/mcp --bearer-token-env-var MOOCHY_TOKEN.

API (donated tokens as Codex's model). Since Codex 0.95, custom providers speak only the OpenAI Responses API (wire_api = "responses"; "chat" is a configuration error), and Moochy serves it at POST /v1/responses. Same ~/.codex/config.toml:

model_provider = "moochy"
model = "anthropic/claude-sonnet-5"

[model_providers.moochy]
name = "Moochy"
base_url = "http://127.0.0.1:PORT/v1"
env_key = "MOOCHY_TOKEN"
wire_api = "responses"

• Donors: Responses requests go only to donors whose provider speaks that format natively: OpenAI, xAI, and OpenRouter. Pick a model those donors offer (moochy connect codex fills in your project's main model; check GET /v1/models).
• Every request is self-contained: store: true, previous_response_id, background mode, and server-side conversations are refused, so nothing is kept at the provider. Codex sends full requests by default, so this needs no change.
• Codex has no Anthropic format; Anthropic and DeepSeek donors serve Codex through MCP (moochy_delegate).

GitHub Copilot CLI#

moochy connect copilot-cli · Copilot CLI 1.0.21 or later (copilot mcp, BYOK) · Sources, read 2026-10-02: https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers, https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models

Recommended: moochy run -- copilot.

MCP, ~/.copilot/mcp-config.json (or .mcp.json / .github/mcp.json in a trusted repository):

{
  "mcpServers": {
    "moochy": { "type": "local", "command": "moochy", "args": ["mcp", "--repo", "owner/repo"], "tools": ["*"] }
  }
}

Over HTTP (Copilot expands ${MOOCHY_TOKEN} from the environment):

{
  "mcpServers": {
    "moochy": {
      "type": "http",
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer ${MOOCHY_TOKEN}" },
      "tools": ["*"]
    }
  }
}

Or: copilot mcp add moochy -- moochy mcp --repo owner/repo.

API (bring your own model), OpenAI Chat Completions:

export COPILOT_PROVIDER_BASE_URL=http://127.0.0.1:PORT/v1
export COPILOT_PROVIDER_TYPE=openai
export COPILOT_PROVIDER_WIRE_API=completions
export COPILOT_PROVIDER_API_KEY="$MOOCHY_TOKEN"
export COPILOT_MODEL=anthropic/claude-sonnet-5
copilot

Or Anthropic Messages: COPILOT_PROVIDER_TYPE=anthropic and COPILOT_PROVIDER_BASE_URL=http://127.0.0.1:PORT, other variables the same.

Gemini CLI#

moochy connect gemini-cli · Gemini CLI 0.1.19 or later · Sources, read 2026-10-02: https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md, https://github.com/google-gemini/gemini-cli/blob/main/docs/reference/configuration.md

Recommended: moochy run -- gemini.

MCP, ~/.gemini/settings.json (or .gemini/settings.json in the project):

{
  "mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP (httpUrl is Streamable HTTP; settings expand ${MOOCHY_TOKEN}):

{
  "mcpServers": {
    "moochy": {
      "httpUrl": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer ${MOOCHY_TOKEN}" }
    }
  }
}

API: Gemini CLI can change its base URL (GOOGLE_GEMINI_BASE_URL) but only for the Gemini API format, which Moochy does not serve, so it uses donated tokens through MCP.

Amp#

moochy connect amp · current Amp (no version numbers are published) · Sources, read 2026-10-02: https://ampcode.com/docs/customize/mcp, https://ampcode.com/docs/customize/model-routing

Recommended: moochy run -- amp.

MCP, ~/.config/amp/settings.json (or .amp/settings.json in the project, then amp mcp approve moochy):

{
  "amp.mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP (Amp expands ${MOOCHY_TOKEN}):

{
  "amp.mcpServers": {
    "moochy": {
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer ${MOOCHY_TOKEN}" }
    }
  }
}

Or: amp mcp add moochy -- moochy mcp --repo owner/repo.

Antigravity#

moochy connect antigravity · Antigravity IDE, Antigravity 2.0, or the agy CLI · Sources, read 2026-10-02: https://antigravity.google/docs/mcp, https://antigravity.google/docs/models

MCP, ~/.gemini/config/mcp_config.json (or .agents/mcp_config.json in the workspace); in the IDE: agent panel → … → MCP Servers → Manage MCP Servers → View raw config:

{
  "mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Use stdio: Antigravity does not document reading environment variables in headers, so an HTTP entry would need the token written into the file.

OpenClaw#

moochy connect openclaw · OpenClaw 2026.3.31 or later · Sources, read 2026-10-02: https://docs.openclaw.ai/cli/mcp, https://docs.openclaw.ai/cli/mcp/transports, https://docs.openclaw.ai/concepts/model-providers/custom-providers

OpenClaw has one configuration file, ~/.openclaw/openclaw.json (JSON5); ${MOOCHY_TOKEN} is read from the environment or ~/.openclaw/.env.

MCP:

{
  mcp: {
    servers: {
      moochy: { command: "moochy", args: ["mcp", "--repo", "owner/repo"] },
    },
  },
}

Over HTTP (transport must say streamable-http; the default is SSE):

{
  mcp: {
    servers: {
      moochy: {
        url: "http://127.0.0.1:PORT/mcp",
        transport: "streamable-http",
        headers: { Authorization: "Bearer ${MOOCHY_TOKEN}" },
      },
    },
  },
}

API, Anthropic Messages (use api: "openai-completions" and baseUrl: "http://127.0.0.1:PORT/v1" for Chat Completions):

{
  agents: { defaults: { model: { primary: "moochy/anthropic/claude-sonnet-5" } } },
  models: {
    mode: "merge",
    providers: {
      moochy: {
        baseUrl: "http://127.0.0.1:PORT",
        apiKey: "${MOOCHY_TOKEN}",
        api: "anthropic-messages",
        models: [{ id: "anthropic/claude-sonnet-5", name: "Claude Sonnet (Moochy)" }],
      },
    },
  },
}

Check with openclaw mcp doctor moochy --probe.

Droid (Factory)#

moochy connect droid · Droid 0.138.0 or later (environment variables in MCP headers) · Sources, read 2026-10-02: https://docs.factory.ai/cli/configuration/mcp, https://docs.factory.ai/cli/configuration/byok

Recommended: moochy run -- droid.

MCP, ~/.factory/mcp.json (or .factory/mcp.json in the project, which is committed: stdio only there):

{
  "mcpServers": {
    "moochy": { "type": "stdio", "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP (${MOOCHY_TOKEN} is expanded in headers):

{
  "mcpServers": {
    "moochy": {
      "type": "http",
      "url": "http://127.0.0.1:PORT/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer ${MOOCHY_TOKEN}" }
    }
  }
}

API, ~/.factory/settings.json (provider: "generic-chat-completion-api" with baseUrl ending in /v1 for Chat Completions; do not use provider: "openai", which is the Responses API):

{
  "customModels": [
    {
      "model": "anthropic/claude-sonnet-5",
      "displayName": "Claude Sonnet (Moochy)",
      "provider": "anthropic",
      "baseUrl": "http://127.0.0.1:PORT",
      "apiKey": "${MOOCHY_TOKEN}"
    }
  ]
}

Kilo Code#

moochy connect kilo-code · Kilo Code 7.x (VS Code extension and Kilo CLI) · Sources, read 2026-10-02: https://kilo.ai/docs/llms.txt (Using MCP in Kilo Code; Using OpenAI Compatible Providers With Kilo Code)

Kilo reads {env:MOOCHY_TOKEN} only from its global configuration, ~/.config/kilo/kilo.json; keep the project's kilo.json to stdio.

MCP:

{
  "mcp": {
    "moochy": { "type": "local", "command": ["moochy", "mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP:

{
  "mcp": {
    "moochy": {
      "type": "remote",
      "url": "http://127.0.0.1:PORT/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:MOOCHY_TOKEN}" }
    }
  }
}

API (OpenAI-compatible), same file:

{
  "model": "moochy/anthropic/claude-sonnet-5",
  "provider": {
    "moochy": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Moochy",
      "options": { "baseURL": "http://127.0.0.1:PORT/v1", "apiKey": "{env:MOOCHY_TOKEN}" },
      "models": { "anthropic/claude-sonnet-5": {} }
    }
  }
}

In the extension: Settings → Providers → Custom provider → "OpenAI Compatible", with the same base URL.

Kiro CLI#

moochy connect kiro-cli · Kiro CLI 2.24.0 or later · Sources, read 2026-10-02: https://kiro.dev/docs/mcp/configuration.md, https://kiro.dev/docs/models.md

Recommended: moochy run -- kiro-cli.

MCP, ~/.kiro/settings/mcp.json (or .kiro/settings/mcp.json in the workspace):

{
  "mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP (Kiro expands ${MOOCHY_TOKEN} from the shell; export it before starting kiro-cli, which no longer reads project .env files):

{
  "mcpServers": {
    "moochy": {
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer ${MOOCHY_TOKEN}" }
    }
  }
}

Hermes Agent (Nous Research)#

moochy connect hermes · Hermes Agent 0.20.0 or later · Sources, read 2026-10-02: https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp, https://hermes-agent.nousresearch.com/docs/integrations/providers

Recommended: moochy run -- hermes.

~/.hermes/config.yaml (Hermes reads ${MOOCHY_TOKEN} from ~/.hermes/.env or the environment). MCP:

mcp_servers:
  moochy:
    command: "moochy"
    args: ["mcp", "--repo", "owner/repo"]

Over HTTP:

mcp_servers:
  moochy:
    url: "http://127.0.0.1:PORT/mcp"
    headers:
      Authorization: "Bearer ${MOOCHY_TOKEN}"

API (OpenAI Chat Completions; for Anthropic Messages use api: http://127.0.0.1:PORT and transport: anthropic_messages):

providers:
  moochy:
    api: http://127.0.0.1:PORT/v1
    key_env: MOOCHY_TOKEN
    transport: chat_completions
model:
  provider: custom:moochy
  default: anthropic/claude-sonnet-5

Roo Code#

moochy connect roo-code · Roo Code 3.19.2 or later · Sources, read 2026-10-02: https://docs.roocode.com/features/mcp/using-mcp-in-roo, https://docs.roocode.com/providers/anthropic, https://docs.roocode.com/providers/openai-compatible

Roo Code's repository was archived in May 2026 (last release 3.54.0); the extension still works, and a community fork is continuing it.

MCP: Roo Code → MCP Servers → "Edit Global MCP" (mcp_settings.json), or .roo/mcp.json in the project:

{
  "mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Over HTTP (${env:MOOCHY_TOKEN} is read from VS Code's environment: set the variable before starting VS Code):

{
  "mcpServers": {
    "moochy": {
      "type": "streamable-http",
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer ${env:MOOCHY_TOKEN}" }
    }
  }
}

API: Settings → API Provider → OpenAI Compatible: Base URL http://127.0.0.1:PORT/v1, API Key = the token, Model ID = a model donors offer. Or Anthropic with "Use custom base URL" = http://127.0.0.1:PORT. The key is kept in VS Code's secret storage.

Trae#

moochy connect trae · Trae IDE 1.4.1 or later (MCP), 3.5.51 or later (custom model URL) · Sources, read 2026-10-02: https://docs.trae.ai/ide/add-mcp-servers, https://docs.trae.ai/ide/models

MCP: Settings → MCP → Add → Add Manually, or .trae/mcp.json in the project (after turning on project MCP in Settings → MCP):

{
  "mcpServers": {
    "moochy": { "command": "moochy", "args": ["mcp", "--repo", "owner/repo"] }
  }
}

Use stdio: Trae does not read environment variables in MCP files, so an HTTP entry would need the token written into the file.

API: Model → Add model → Custom Model: API format OpenAI Chat Completions, request URL http://127.0.0.1:PORT/v1 (or Anthropic Messages with http://127.0.0.1:PORT), Model ID = a model donors offer, API key = the token (kept by Trae).

3. Chat applications#

Claude Desktop#

claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/; Windows: %APPDATA%\Claude\). Use the absolute path to moochy:

{
  "mcpServers": {
    "moochy": {
      "command": "/usr/local/bin/moochy",
      "args": ["mcp", "--repo", "owner/repo"]
    }
  }
}

Good for handing long reads and reviews to donated tokens from a chat.

Web chat apps and remote-only connectors#

Tools that can only reach a remote HTTPS MCP server (connectors in web chat apps, cloud agents that cannot run a local binary) are not supported: both ways in listen only on your own machine by design, and Moochy never runs a hosted endpoint, because that endpoint would have to see your prompts.

4. Agent frameworks#

Any framework with an MCP client can use the Moochy tools; any framework whose model client takes a base URL can run on donated tokens. In CI or containers, run Moochy next to the agent.

OpenAI Agents SDK (Python):

import os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(params={
    "url": "http://127.0.0.1:PORT/mcp",
    "headers": {"Authorization": f"Bearer {os.environ['MOOCHY_TOKEN']}"},
}) as moochy:
    agent = Agent(name="reviewer", instructions="…", mcp_servers=[moochy])
    result = await Runner.run(agent, "Review the diff in src/")

Claude Agent SDK (Python): set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN as for Claude Code to run on donated tokens, and/or add the Moochy tools:

from claude_agent_sdk import ClaudeAgentOptions, query

options = ClaudeAgentOptions(
    mcp_servers={"moochy": {"type": "stdio", "command": "moochy", "args": ["mcp", "--repo", "owner/repo"]}},
)
async for message in query(prompt="Summarize docs/ with moochy_delegate", options=options):
    print(message)

LangGraph / LangChain (Python):

import os
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_openai import ChatOpenAI

client = MultiServerMCPClient({"moochy": {
    "transport": "streamable_http",
    "url": "http://127.0.0.1:PORT/mcp",
    "headers": {"Authorization": f"Bearer {os.environ['MOOCHY_TOKEN']}"},
}})
tools = await client.get_tools()
llm = ChatOpenAI(base_url="http://127.0.0.1:PORT/v1", api_key=os.environ["MOOCHY_TOKEN"],
                 model="anthropic/claude-sonnet-5")

Pydantic AI:

import os
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStdio

moochy = MCPServerStdio("moochy", args=["mcp", "--repo", "owner/repo"])
agent = Agent("openai:gpt-5", toolsets=[moochy])   # your agent's own model; moochy_delegate uses donated tokens

5. SDKs and libraries#

Anthropic (Python; TypeScript takes the same baseURL/apiKey):

import os, anthropic
client = anthropic.Anthropic(base_url="http://127.0.0.1:PORT", api_key=os.environ["MOOCHY_TOKEN"])
msg = client.messages.create(model="anthropic/claude-sonnet-5", max_tokens=1024,
                             messages=[{"role": "user", "content": "Hello"}])

OpenAI (Python; TypeScript is the same):

import os
from openai import OpenAI
client = OpenAI(base_url="http://127.0.0.1:PORT/v1", api_key=os.environ["MOOCHY_TOKEN"])
resp = client.chat.completions.create(model="deepseek/deepseek-chat",
                                      messages=[{"role": "user", "content": "Hello"}])

Vercel AI SDK (TypeScript):

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
const moochy = createOpenAICompatible({
  name: 'moochy',
  baseURL: 'http://127.0.0.1:PORT/v1',
  apiKey: process.env.MOOCHY_TOKEN,
});
const model = moochy('anthropic/claude-sonnet-5');

LiteLLM:

import os, litellm
litellm.completion(model="openai/anthropic/claude-sonnet-5", api_base="http://127.0.0.1:PORT/v1",
                   api_key=os.environ["MOOCHY_TOKEN"], messages=[{"role": "user", "content": "Hello"}])

6. Request rules worth knowing#

• Send max_tokens (the Moochy app adds the model's default if your tool leaves it out, and tells you once).
• The donor's app runs safety checks against a strict list of what is allowed. Server-side tools, remote MCP servers inside the request, provider file ids, URL images, and n > 1 are refused with a 400 that says why.
• Refusals that a retry cannot fix are never 429, so agents do not retry them in a loop: over the donors' limit per request → 400, monthly limit used → 403.
• POST /v1/messages/count_tokens is answered locally (no donor involved) with a deliberately pessimistic estimate.
• Responses carry x-moochy-task, x-moochy-donor (pseudonym), and x-moochy-cost-uusd (cost in millionths of a dollar) headers.

This page as Markdown: /docs/integrations.md · for AI agents: /llms.txt