# Muse Mirror

> Creative direction as a paid API. Send a plain-language project brief; get back
> a critic-reviewed creative direction — positioning, audience tension, visual
> metaphor, typography and colour system, plus three distinct creative
> territories — and, optionally, finished campaign media generated from the
> territory you choose.
>
> Muse Mirror is agent-native. Every capability is reachable over HTTP with
> stablecoin settlement. There is no signup, no API key, and no account to
> create: you pay per call and the payment *is* the authentication.

Base URL: `https://musemirror.app`

## What you get

Two endpoints, called in sequence.

| Step | Endpoint | Price | Returns |
|---|---|---|---|
| 1 | `POST /api/x402/creative-direction` | $0.29 | Brand intelligence, 3 creative territories, campaign copy, image prompts, production specs. No media. |
| 2 | `POST /api/x402/generate-campaign` | $0.49 – $1.79 | Finished media, generated from the direction and reviewed by a visual critic before delivery. |

Media pricing is additive: `$0.29 base + $0.70 carousel + $0.20 per single
format`, capped at `$1.79`. Requesting one poster costs $0.49; requesting
everything costs $1.79.

Deliverable formats (`outputFormats`): `poster` (4:5), `carousel` (five slides),
`cover` (9:16), `thumbnail` (16:9), `logo` (1:1 identity concept, not production
vector files). Defaults to the four campaign formats.

Step 2 **requires** the `direction` object returned by step 1. You cannot skip
step 1. This is deliberate: the media is generated from a reviewed position, not
from a raw prompt.

## Paying: x402 over X Layer

Settlement uses the OKX Agent Payments Protocol (x402 v2). Muse Mirror is on
**X Layer** — `eip155:196`. X Layer is gas-free, so a call costs exactly the
listed price and nothing else.

The current settlement asset is **USD₮0**
(`0x779ded0c9e1022225f8e0630b35a9b54be713736`, 6 decimals). Read the asset from
the challenge rather than hardcoding it — it is authoritative and will change
when the USDC migration lands.

### The handshake

1. `POST` your JSON body to the endpoint with no payment header.
2. You get **HTTP 402**. The JSON body carries `service`, `price` and a complete
   `inputSchema`. The `payment-required` **response header** carries the
   machine-readable challenge: base64-encoded JSON, x402 v2.
3. Decode `payment-required`. Its `accepts[0]` gives you `scheme` (`exact`),
   `network`, `amount` (minor units), `asset`, `payTo`, and `maxTimeoutSeconds`.
4. Sign an EIP-3009 `TransferWithAuthorization` for exactly that amount, asset
   and recipient.
5. Replay **the identical request body** with the `x-payment` header set to the
   encoded payment payload.
6. You get **HTTP 200** with your result.

Two things that will cost you money if you get them wrong:

- **Replay the same body.** The challenge is bound to the request. A body that
  differs from the one that produced the 402 will be rejected after you have
  already signed.
- **Validate before signing.** Check `payTo`, `asset`, `network` and `amount`
  against the challenge you just received. Never sign a transfer assembled from
  values you cached from an earlier call.

Invalid input is rejected *before* any payment challenge is issued, so a `400`
costs nothing. Send a deliberately empty body first if you want to read the
schema for free.

## Two ways to hire Muse Mirror

### 1. Via the OKX.AI marketplace

Muse Mirror is a listed Agent Service Provider: **ASP #7222**. If your agent
runs inside OKX Onchain OS, discover it through the marketplace and call it the
way you call any listed ASP — identity, settlement and receipts are handled by
the marketplace layer. Use this path when you want the marketplace to broker
the transaction.

### 2. Direct over HTTP

Call the endpoints above from anywhere, with any wallet that can sign EIP-3009
on X Layer. Nothing about this path depends on OKX Onchain OS. Use it when you
are building your own agent, your own runtime, or a server-side integration.

Both paths hit the same engine and cost the same.

## Input

Both endpoints accept the same shape. The simplest valid call is one field:

```json
{ "prompt": "A privacy-first budgeting app for people who hate budgeting apps. Launch campaign." }
```

For control, send a structured brief instead:

```json
{
  "project": {
    "projectName": "Ledgerless",
    "description": "A privacy-first budgeting app for people who hate budgeting apps.",
    "audience": "Salaried professionals who have abandoned three budgeting apps already.",
    "objective": "Make the launch feel like relief, not discipline.",
    "tone": "Dry, exact, unhurried.",
    "proof": ["No bank login required", "Local-first storage"]
  },
  "outputFormats": ["poster", "carousel"]
}
```

Useful optional fields:

- `referenceImages` — up to four public HTTPS URLs or compact data URLs. Read
  directly as strategic and visual evidence.
- `brandAssetImages` — up to four *authorized* identity assets (your logo, your
  product marks). These are preserved exactly and are never treated as style
  inspiration.
- `referenceInsights` — client-measured pixel evidence (palette, brightness,
  contrast, focal point, negative space). The exact object shape is published in
  the `inputSchema` so you can construct it reliably.
- `feedback` / `creativeMemory` — accepted creative rules from earlier results.
  Persist these across calls to compound a house style.
- `territorySet` + `selectedTerritoryId` — resend the exact territories from a
  previous response to reuse a chosen route without paying to regenerate it.

The full JSON Schema is returned in every 402 body and mirrored inside the
`payment-required` challenge under `extra.outputSchema`. Treat that as the
source of truth; this file is a guide, not the contract.

## What the critic rejects

Delivered images are read back against the brief before you receive them.
Assets are rejected or repaired when they contain malformed or clipped copy,
invented metrics, prices, tickers or rankings, fabricated third-party logos,
unsafe crops that cut critical subjects, or generic fake dashboards. If an
asset cannot be repaired, the call fails rather than returning a substitute.

You own the output and may publish, edit and sell it.

## Limits and behaviour

- Bodies are capped at 64 KB. Requests are throttled per client.
- `maxTimeoutSeconds` in the challenge is 300. Media generation is the slow
  path; budget for it.
- Reusing a `territorySet` is model-free and therefore fast.
- `GET /api/health` is unauthenticated and reports live readiness, current
  prices, the settlement network and the active `payTo` address.

## Not available

The free MCP generation endpoint is **retired**. `POST /api/mcp` now returns
JSON-RPC error `-32001` directing you to the paid endpoints. Do not build
against it.

## Contact

- Product: https://musemirror.app
- Studio (human interface): https://musemirror.app/studio
- Health: https://musemirror.app/api/health