# MCP logo server: a brand-file tool for agents

> MCP is how an agent discovers a tool without custom glue. The Dosie Foxie server exposes the same three steps a human uses: brief, preview, pack.

Canonical: https://dosiefoxie.com/mcp-logo-server.html

> Agent API (2026-11-09). The contract, the free endpoints and the paid x402 checkout are live. A preview is $1 and a Production Pack $19, in USDC on Base, paid per request — no account, no API key, no card. A request that arrives without payment returns 402 with the exact amount, asset, network and address.

The HTTP API needs no account and no key, because it is paid per request with x402. MCP is not the same door: a tool call carries no headers, so a prepaid key is how a paid tool gets paid there. The payment section below says exactly what each one can do.

An HTTP API is enough for an agent that already knows the endpoint. MCP is for the agent that is choosing tools: the client reads the tool names, descriptions and input schemas, and the model decides whether to call one. A logo tool that is discoverable in that loop has a better chance of being used than a URL buried in a docs page.

The MCP server is a thin wrapper over the same contract. It does not hold a model key and it does not change the pack; it turns a tool call into an API request and returns the manifest.

## The tools

| Tool | Input | Returns |
| --- | --- | --- |
| get_pricing | none | The price of a preview, a pack and a re-render |
| get_sample | none | The manifest of a real Production Pack, free |
| create_preview | brief (object) | Three directions with QA, preview_id, status_url |
| get_preview | preview_id | Status, and the directions once they are drawn |
| create_pack | preview_id, concept_id | order_id and status_url (paid) |
| get_pack | order_id | Status, file manifest with sha256, download URL |

Those are the names the server answers to. `tools/list` is the source of truth: a client that reads it cannot be wrong, and this table is kept to match it. The two free reads come first on purpose — a model should be able to inspect the price and a real pack before it commits to anything.

Two paid steps, two free lookups, and one thing that is not a tool: re-rendering an existing spec is `POST /api/v1/render` on the HTTP API. It is the cheap path for a colour, layout or tagline change, and it is not exposed as a tool because it takes a whole spec document rather than a handful of arguments.

## What a tool call returns

The result is JSON, not prose. A tool call that returns a paragraph forces the model to parse it; a manifest lets the agent hand the files to its own code. The manifest is the same on the API and the MCP server.

```
{
  "order_id": "pv_01J...",
  "status": "delivered",
  "manifest": {
    "order_id": "pv_01J...",
    "download_url": "https://dosiefoxie.com/o/6f70.../f/pack/dosiefoxie.zip",
    "spec_url": "https://dosiefoxie.com/o/6f70.../f/pack/spec.json",
    "mark_svg_url": "https://dosiefoxie.com/o/6f70.../f/pack/mark.svg",
    "files": [
      {"name": "logo-color.svg", "kind": "vector", "bytes": 4182,
       "sha256": "a8c1...", "url": "https://dosiefoxie.com/o/6f70.../f/pack/logo-color.svg"}
    ],
    "qa": {"passed": true, "gates": ["legible at 16px: ..."]},
    "license": {"owner": "Salthouse Smokehouse", "terms_url": ".../terms.html"},
    "expires_at": "2026-12-09 13:30:00",
    "price_paid_micros": 19000000
  }
}
```

## Payment inside the tool loop

A tool call cannot pay for itself, and the server does not pretend that it can. x402 settles on a PAYMENT-SIGNATURE header on the HTTP request; a tool call carries arguments, not headers, so a wallet configured in the client has nothing to sign into. A paid tool that is called without a key therefore answers with the price, the asset, the network and the exact HTTP request that pays for it — and with isError set, because the call did not succeed.

```
{"tool": "create_preview", "arguments": {
  "brief": {"name": "Salthouse Smokehouse",
            "trade": "wood-smoked fish",
            "style": "woodcut"}
}}
```

Two routes actually work. A prepaid balance: buy one at POST /api/v1/keys with USDC (76 for a balance of 76, four preview-and-pack cycles), take the key out of the 202, and set Authorization: Bearer <key> on the MCP connection. That closes the loop with no human in it — the tool call cannot pay, but it can spend a balance. Or pay per request: post the same JSON body to /api/v1/previews or /api/v1/orders with a PAYMENT-SIGNATURE header and an Idempotency-Key, which is the x402 rail and needs no account at all.

The payment is never hidden inside the tool. The price is visible before anything is signed, and on the HTTP rail the settlement comes back in the PAYMENT-RESPONSE header so the agent can log what it paid.

## Why MCP and not just HTTP

The contract is the same; the difference is discovery and schema. An MCP client can list the tools, inspect the input schema and let the model choose. That is a better fit for a general-purpose agent than a hard-coded URL, and it is another place for the product to be found.

## Status

The MCP server is live at https://dosiefoxie.com/mcp: JSON-RPC over one POST, streamable HTTP, six tools. Point any MCP client at that URL and it will list them. The free tools work with no credential; the paid ones need a key on the connection, as above.

## Questions

### Is the MCP server published?

Yes. It is at https://dosiefoxie.com/mcp and it wraps the same endpoints, so it inherits the same $1 preview and $19 pack.

### Which clients will work?

Any MCP client that supports tool calls, including Claude, Cursor and ChatGPT's MCP support. The server uses the standard streamable HTTP transport.

### Does the MCP server need an API key?

For the free tools, no. For the paid ones, yes: a tool call cannot carry an x402 signature, so the prepaid key is the rail that works inside MCP. You do not need to ask for one — POST /api/v1/keys takes 76 USDC and returns a balance and a key. The x402 rail also works over the HTTP API, which can take the header.

### Can it re-render an existing pack?

Yes, over HTTP: POST /api/v1/render takes a spec.json and returns a new pack without a model call — the cheap path for colour, layout and tagline changes. It is not an MCP tool, because the argument is a whole spec document.