_ registry / mcp streamable-http · checked 2h ago

qmax-mcp-server

https://qmax.exchange

Registry code: c6eae699a3857b06

api record

QMax compares the QX order book with the QSwap pool for Qubic assets and splits an order across both for the best price. Everything here is free, needs no key and reads public data; no tool signs or sends anything (qmax_build_plan returns unsigned steps for the caller's own wallet). Prices are in QU, Qubic's coin; quantities are whole units. A quote is a snapshot: quote again before signing. To answer how much a sale would fetch, call qmax_get_quote with side=sell: its summary field says the result in words. The Max plan (best position, 100 QU) is not offered here: see…

endpoint
https://qmax.exchange/api/mcp
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is qmax-mcp-server live?
Yes — it answered the hub's last check (checked 2h ago). It answered 100% of checks over the last 30 days.
Is qmax-mcp-server free to use?
Yes — the hub reached it with no key and no payment.
What tools does qmax-mcp-server have?
19 tools: qmax_check_arbitrage, qmax_list_assets, qmax_get_quote, qmax_build_plan, qmax_get_sellers, qmax_swap_quote, qmax_get_wallet_ledger, qmax_get_liquidity_positions, ….
Is qmax-mcp-server safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
140ms

last good check

priced tools
0

of 19 tools

_ answered our checks, 90 days 1 checks · signed record
  • unknown → live
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 19 tools
3 open 16 never probed 3 of 19 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • qmax_get_flow open 2h ago

    Buy and sell volume (QU and units), trade counts and net pressure (positive = more buying) over the last hour or 24 hours, for one asset or the whole market. Direction is the taker's side. 'partial' is true while the server is still loading the window.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "venue": {
      "enum": [
        "QX",
        "QSwap"
      ],
      "type": "string"
    },
    "window": {
      "enum": [
        "1h",
        "24h"
      ],
      "type": "string",
      "default": "24h"
    }
  }
}
    arguments 27 lines
  • qmax_get_health open 2h ago

    A 0 to 100 score and A to E grade for an asset, from its QX order book, its QSwap pool and six months of trades, with flags and plain-English reasons (most important first). Flags include thin-book, wide-spread, quiet, few-trades, new-listing, volume-spike, one-sided, pool-dominated and wash-suspected / bot-burst (a single wallet churning tiny same-size swaps against itself, which inflates trade counts but not volume). Many assets grade D or E because QX markets are thin: that is information, not an error. It is an automated estimate from public data and NOT advice; the absence of 'wash-suspected' is not proof of a clean market (large wash trades are not detectable from this data). Omit 'asset' to get every asset's grade in one call.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Leave out for all assets (grade, score, flags, top reason each)"
    }
  }
}
    arguments 12 lines
  • qmax_get_tape open 2h ago

    The most recent trades on both markets in one feed, newest first: time, market, asset, quantity, QU, price and direction. The direction is the TAKER's side (the person who started the trade): 'buy' or 'sell'. Rows also carry the transaction hash. The answer includes 'flow24h', the last 24 hours of buy versus sell volume, and 'latestId': pass it back as 'since' to get only newer trades. Served from memory, so cheap to poll.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Only this asset (leave out for all)"
    },
    "limit": {
      "type": "integer",
      "default": 30,
      "maximum": 200,
      "minimum": 1
    },
    "since": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "Only trades newer than this id (the latestId from an earlier call)"
    },
    "venue": {
      "enum": [
        "QX",
        "QSwap"
      ],
      "type": "string"
    }
  }
}
    arguments 31 lines
  • qmax_check_arbitrage unknown never probed

    Searches, live and at full depth, for a profitable buy-on-one-market, sell-on-the-other loop after every venue fee, and returns the most profitable size or null. It is two separate transactions, so the second leg can fill worse than shown; this is a snapshot, not a guarantee. Only assets on both markets can have one. A found result may be billed to the caller's QMax key (50 QU).

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "max_cost_qu": {
      "type": "number",
      "minimum": 0,
      "description": "Most QU to put in (a budget); the search returns the best loop that fits"
    },
    "min_profit_qu": {
      "type": "number",
      "minimum": 0,
      "description": "Only an opportunity with at least this profit (QU)"
    },
    "min_profit_pct": {
      "type": "number",
      "minimum": 0,
      "description": "Only one with at least this profit as a percentage of the QU put in"
    }
  }
}
    arguments 30 lines
  • qmax_list_assets unknown never probed

    Lists assets that trade on QX and/or QSwap, most liquid first, or searches by symbol. Use this first to find the right asset symbol and to see which markets it trades on ('QX', 'QSwap' or both: only assets on both can be split for a better price). Returns: { count, assets: [{ id, symbol, category ('contract' shares or 'token'), venues, priceQu, liquidityQu, activity }] }. Prices are QU per unit.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "limit": {
      "type": "integer",
      "default": 25,
      "maximum": 100,
      "minimum": 1,
      "description": "Most assets to return"
    },
    "query": {
      "type": "string",
      "maxLength": 32,
      "description": "Part of a symbol to search for, e.g. 'QD'"
    },
    "category": {
      "enum": [
        "contract",
        "token"
      ],
      "type": "string",
      "description": "Only smart-contract shares or only tokens"
    }
  }
}
    arguments 26 lines
  • qmax_get_quote unknown never probed

    Prices an order and finds the cheapest route across the QX order book and the QSwap pool, splitting the order across both when that is cheaper. Nothing is placed. Returns the total in QU, the average price, each leg (venue, quantity, price range, fees, price impact), what each single market alone would cost, a plain-English line saying what the routing saved, and warnings. All amounts are QU; quantities are whole units. The quote is a snapshot: prices move, so re-quote before acting.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "side",
    "asset",
    "qty"
  ],
  "properties": {
    "qty": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1,
      "description": "How many units of the asset"
    },
    "side": {
      "enum": [
        "buy",
        "sell"
      ],
      "type": "string"
    },
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "split": {
      "type": "boolean",
      "default": true,
      "description": "false prices the best single market only"
    },
    "slippage_bps": {
      "type": "integer",
      "default": 100,
      "maximum": 1000,
      "minimum": 0,
      "description": "Slippage tolerance in basis points (100 = 1%), applied to the limits in route[].execution"
    }
  }
}
    arguments 42 lines
  • qmax_build_plan unknown never probed

    Quotes an order and returns the exact transactions a wallet must sign to carry it out, in order. QMax signs nothing and sends nothing: you (or the user) sign each step with your own wallet and broadcast it. Steps (in order): any share-management move needed first (selling shares that the other market manages), then one call per market. Each step: kind, description, destination (a smart contract by index), inputType (procedure number), amountQu to attach (QU that may leave the wallet; unused QU is refunded by the contracts) and payloadBase64 (the call's input bytes). 'maxOutlayQu' is the most QU that can leave the wallet across all steps, so check it against your own spending limit BEFORE signing. Sending a step moves real funds. For a sell, pass how many shares the wallet holds under QX management and under QSwap management (holdings_qx, holdings_qswap) so the right moves are planned. Buys need no holdings.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "side",
    "asset",
    "qty"
  ],
  "properties": {
    "qty": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1
    },
    "side": {
      "enum": [
        "buy",
        "sell"
      ],
      "type": "string"
    },
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "holdings_qx": {
      "type": "integer",
      "default": 0,
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "Selling only: units of this asset the wallet holds that QX manages"
    },
    "slippage_bps": {
      "type": "integer",
      "default": 100,
      "maximum": 1000,
      "minimum": 0
    },
    "holdings_qswap": {
      "type": "integer",
      "default": 0,
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "Selling only: units of this asset the wallet holds that QSwap manages"
    }
  }
}
    arguments 49 lines
  • qmax_get_sellers unknown never probed

    For the last 7 days: the wallets that sold the asset on QX or QSwap, how long each had held the units (each unit sold is matched, first in first out, to the purchase it came from), what they paid and whether they sold above or below that, with a plain-language reading ("what the numbers say"). Read from the public Qubic archive, so the first call for an asset starts the reading and answers status "working" with its progress and what is known so far: call again in 30 to 60 seconds until status is "ready" (a reading takes a minute or two and is kept for six hours). The chain shows who sold and what they paid, not why. Free.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    }
  }
}
    arguments 15 lines
  • qmax_swap_quote unknown never probed

    Plans swapping one token for another as two linked trades: sell 'from' for QU (leg 1), then buy 'to' with the QU (leg 2), each routed across QX and QSwap by the best route. Read-only: nothing is signed. Returns both quotes, 'upfrontQu' (QU the wallet must hold BEFORE leg 1 for its flat fees), 'expectedOutQty' (what you should get) and 'minOutQty' (guaranteed by the limits only if neither price moves past the slippage limit), plus warnings. Leg 2 can only be sized exactly after leg 1 settles, from the wallet's real balance, so a swap is never one atomic transaction: if leg 1 completes and leg 2 cannot proceed you are left holding QU. Both tokens must trade on QX or QSwap; QU itself is not a swap leg (use qmax_get_quote).

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "from",
    "to",
    "qty"
  ],
  "properties": {
    "to": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Token to buy"
    },
    "qty": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1,
      "description": "How many units of 'from' to sell"
    },
    "from": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Token to sell"
    },
    "compare": {
      "type": "boolean",
      "default": false,
      "description": "Also plan the same swap forced onto each single market (QX or QSwap per leg) and say what QMax's route is worth against them (bestDeal). Slower."
    },
    "slippage_bps": {
      "type": "integer",
      "default": 100,
      "maximum": 1000,
      "minimum": 0
    }
  }
}
    arguments 40 lines
  • qmax_get_wallet_ledger unknown never probed

    Every QX and QSwap buy and sell a wallet made (read from public on-chain transfers, so any 60-letter identity works): price, QU net of fees, estimated fees, running position, and average-cost realized profit, plus current positions with unrealized profit and loss. ESTIMATED. Read 'warnings' and 'truncated': the archive has no events for about 10 to 14 June 2026, units that arrived before the window or by transfer have no known cost (selling them is not counted as profit), and QSwap liquidity changes appear as transfers. Unrealized P&L uses the mid or pool price, which can mislead on thin markets. Takes a few seconds and many archive reads, so ask once and keep the answer. Not tax advice.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "identity"
  ],
  "properties": {
    "days": {
      "type": "integer",
      "default": 180,
      "maximum": 365,
      "minimum": 1
    },
    "identity": {
      "type": "string",
      "pattern": "^[A-Z]{60}$",
      "description": "The wallet's 60-letter identity"
    }
  }
}
    arguments 20 lines
  • qmax_get_liquidity_positions unknown never probed

    Every QSwap pool a wallet has liquidity in (public chain data, so any 60-letter identity works): its liquidity units, share of the pool, what removing it all would pay (QU and tokens, before QSwap's flat 100,000 QU fee) and its value in QU at the pool's own price, read live from the contract. Read-only. Adding or removing liquidity is done in the QMax app with a wallet; this tool never builds or signs one. Check 'complete': when false, a pool could not be read and its positions are missing. 'earnedFeesQu' is already inside what removing pays, nothing pays it separately. Values are estimates at the pool's price, which can be far from what the tokens sell for on a thin market.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "identity"
  ],
  "properties": {
    "identity": {
      "type": "string",
      "pattern": "^[A-Z]{60}$",
      "description": "The wallet's 60-letter identity"
    }
  }
}
    arguments 14 lines
  • qmax_get_liquidity_pool unknown never probed

    A QSwap pool's reserves (QU and tokens), total liquidity units and price, read from the contract. Use it to see how deep a pool is before talking about providing liquidity. Adding or removing liquidity each cost a flat 100,000 QU on top of any deposit. Read-only.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    }
  }
}
    arguments 15 lines
  • qmax_get_candles unknown never probed

    Open, high, low, close, QU volume, units and trade count per candle, built from every trade QX and QSwap logged (a minute wide at the finest; about six months back, which is all the Qubic archive has: its trade records begin in April 2026). A candle exists only where something traded, so a gap means no trades. The response also gives the last 24 hours of volume across both markets. Returns: { asset, range, interval, venue, candles: [{ t (ms), o, h, l, c, volumeQu, volumeQty, trades }], truncated?, available?, volume24hQu, trades24h }. Prices are QU per unit.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "range": {
      "enum": [
        "1d",
        "7d",
        "30d",
        "90d",
        "all"
      ],
      "type": "string",
      "default": "7d",
      "description": "How far back to look. 'all' is everything QMax has (about six months)."
    },
    "venue": {
      "enum": [
        "auto",
        "QX",
        "QSwap",
        "all"
      ],
      "type": "string",
      "default": "auto",
      "description": "Which market's prices: QX (order book), QSwap (pool), 'all' (treat both as one market), or 'auto' (the market the live price comes from)."
    },
    "interval": {
      "enum": [
        "1m",
        "5m",
        "15m",
        "30m",
        "1h",
        "4h",
        "1d"
      ],
      "type": "string",
      "description": "Candle width: a minute up to a day (default suits the range). One answer holds at most the latest 5,000 candles"
    }
  }
}
    arguments 51 lines
  • qmax_get_price_history unknown never probed

    The asset's price over time as points (ms timestamp, price in QU, and for recently recorded points the best bid, ask and pool price). Points before 'recordedSince' were rebuilt from past trades as hourly volume-weighted averages (marked src 'trades'); after it QMax recorded the price about every 10 minutes. Use qmax_get_candles for OHLC and volume.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "range": {
      "enum": [
        "1d",
        "7d",
        "30d",
        "90d",
        "all"
      ],
      "type": "string",
      "default": "7d",
      "description": "How far back to look. 'all' is everything QMax has (about six months)."
    }
  }
}
    arguments 27 lines
  • qmax_get_order_book unknown never probed

    What is resting on the QX order book (grouped by price, with cumulative size and cost from the best price outward, best bid/ask, spread) and the QSwap pool (reserves, price, and how far trades of 0.1% to 5% of the pool would move the price). Use it to judge depth before sizing an order.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "levels": {
      "type": "integer",
      "default": 15,
      "maximum": 50,
      "minimum": 1,
      "description": "Price levels per side of the QX book"
    }
  }
}
    arguments 22 lines
  • qmax_venue_premium unknown never probed

    Hour by hour, the gap between the asset's QX and QSwap prices (positive = QSwap dearer) and how often it was wider than the trading costs for a trade of 'reference_qu'. This is an UPPER BOUND on arbitrage, not a profit: it uses hourly average prices, so it leaves out the QX bid-ask spread (often wider than the costs) and the delay between the two transactions. Returns { bothVenues, breakEvenPct, points, summary, note }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "range": {
      "enum": [
        "7d",
        "30d",
        "90d",
        "all"
      ],
      "type": "string",
      "default": "30d"
    },
    "reference_qu": {
      "type": "number",
      "maximum": 1000000000000,
      "minimum": 100000,
      "description": "Trade size in QU used to work out the break-even gap (default 10,000,000)"
    }
  }
}
    arguments 31 lines
  • qmax_list_pools unknown never probed

    Every QSwap liquidity pool with its TVL, trailing swap volume, estimated fee APR (from real swap volume; only 0.192% of each swap's volume reaches liquidity providers), price change and impermanent loss over the window. A trailing estimate: past fees do not predict future fees, and volume that looks inflated (wash trading) is flagged in each pool's notes.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "sort": {
      "enum": [
        "apr",
        "tvl",
        "volume"
      ],
      "type": "string",
      "default": "apr"
    },
    "limit": {
      "type": "integer",
      "default": 20,
      "maximum": 50,
      "minimum": 1
    },
    "window": {
      "enum": [
        "7d",
        "30d"
      ],
      "type": "string",
      "default": "7d"
    }
  }
}
    arguments 29 lines
  • qmax_pool_detail unknown never probed

    One pool's numbers explained, and for a deposit size (position_qu, the QU value of both sides together) an estimate of fees per day, per 30 days and the impermanent loss for price moves of 10%, 25% and 50%. Adding and removing liquidity each cost a flat 100,000 QU.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "window": {
      "enum": [
        "7d",
        "30d"
      ],
      "type": "string",
      "default": "7d"
    },
    "position_qu": {
      "type": "number",
      "maximum": 1000000000000000,
      "minimum": 1
    }
  }
}
    arguments 28 lines
  • qmax_backtest unknown never probed

    Replays a strategy over real hourly trade data with the venues' real fees and reports what it would have done: final value, return, buy-and-hold comparison, max drawdown, fees paid, trades. Decisions are made on an hour's close and filled at the next hour's open; hours with no trades cannot be traded. Strategies: 'hold' (buy once, hold), 'dca' (spend amountQu every everyHours), 'bands' (buy fractionPct of the QU when the price is bandPct below its lookbackHours average, sell fractionPct of the holding when above, with a cooldown). READ 'warnings' in the result: there is no order book depth in the history, so large amounts are optimistic, and QSwap's flat 100,100 QU fee can swallow small trades. Past results do not predict future ones.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "asset",
    "starting_qu",
    "strategy"
  ],
  "properties": {
    "asset": {
      "type": "string",
      "maxLength": 32,
      "minLength": 1,
      "description": "Asset symbol, for example CFB or QDOGE (case does not matter). Use qmax_list_assets to find one."
    },
    "range": {
      "enum": [
        "30d",
        "90d",
        "all"
      ],
      "type": "string",
      "default": "90d"
    },
    "venue": {
      "enum": [
        "auto",
        "QX",
        "QSwap",
        "all"
      ],
      "type": "string",
      "default": "auto",
      "description": "Which market's prices: QX (order book), QSwap (pool), 'all' (treat both as one market), or 'auto' (the market the live price comes from)."
    },
    "strategy": {
      "type": "object",
      "required": [
        "type"
      ],
      "properties": {
        "type": {
          "enum": [
            "hold",
            "dca",
            "bands"
          ],
          "type": "string"
        },
        "bandPct": {
          "type": "number",
          "description": "bands: how far from the average triggers a trade, in %"
        },
        "amountQu": {
          "type": "integer",
          "maximum": 9007199254740991,
          "minimum": -9007199254740991,
          "description": "dca: QU per purchase, fees included"
        },
        "everyHours": {
          "type": "integer",
          "maximum": 9007199254740991,
          "minimum": -9007199254740991,
          "description": "dca: hours between purchases (168 = weekly)"
        },
        "fractionPct": {
          "type": "number",
          "description": "bands: share of QU (to buy) or holding (to sell) per trade, in %"
        },
        "cooldownHours": {
          "type": "integer",
          "maximum": 9007199254740991,
          "minimum": -9007199254740991,
          "description": "bands: minimum hours between trades"
        },
        "lookbackHours": {
          "type": "integer",
          "maximum": 9007199254740991,
          "minimum": -9007199254740991,
          "description": "bands: moving-average window in hours"
        }
      },
      "additionalProperties": false
    },
    "starting_qu": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": 1,
      "description": "QU to start with, e.g. 10000000"
    }
  }
}
    arguments 92 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id c6eae699a3857b06.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/c6eae699a3857b06/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/c6eae699a3857b06/badge.svg)](https://brick.blue/agent/c6eae699a3857b06?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.