Skip to content
verify mcp Beta VerifyMCP is currently in beta. If you notice any issues, get in touch and we’ll put it right.

Quiver Risk Brain

REMOTE · QUIVER-PRODUCTION-C3A8.UP.RAILWAY.APP · SCANNED OCT 7

Verifiable, deterministic risk math for autonomous agents; re-runnable proof on every answer.

0 this week 23 Trust /100
Trust breakdown (7 categories)

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. How we score → Why this is hard to score →

Endpoint Security57
Transport & Reachability0
Schema Quality & AI Usability0
  • Schema not yet verified: we couldn't read the endpoint's schema, or could read only part of its tool list.Unverified
Stability & Change Management0
  • Stability not yet verified: not enough scan history yet (needs a 30-day window).Unverified
Tool Coverage0
  • Tool coverage not yet verified: we couldn't read the endpoint's tools, or could read only part of the list.Unverified
Tool Safety0
  • Tool safety not yet verified: we couldn't read the endpoint's tools, or could read only part of the list.Unverified
Capabilities0
  • Capabilities not yet verified: we couldn't read the endpoint's capabilities.Unverified

Unverified: 5 categories

Categories scored 0 because we could not verify them: authentication we do not have, an unreachable endpoint, or not enough scan history. We only credit what we can confirm.

Install

How do I install the Quiver Risk Brain MCP server?

Quiver Risk Brain is a hosted endpoint at https://quiver-production-c3a8.up.railway.app/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

remote · quiver-production-c3a8.up.railway.app

# add to Claude Code
claude mcp add --transport http tristan-tech-ai-quiver-risk-brain 'https://quiver-production-c3a8.up.railway.app/mcp'
// .cursor/mcp.json
{
  "mcpServers": {
    "tristan-tech-ai-quiver-risk-brain": {
      "url": "https://quiver-production-c3a8.up.railway.app/mcp"
    }
  }
}
// .vscode/mcp.json
{
  "servers": {
    "tristan-tech-ai-quiver-risk-brain": {
      "type": "http",
      "url": "https://quiver-production-c3a8.up.railway.app/mcp"
    }
  }
}
# ~/.codex/config.toml
[mcp_servers.tristan-tech-ai-quiver-risk-brain]
url = "https://quiver-production-c3a8.up.railway.app/mcp"
// opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tristan-tech-ai-quiver-risk-brain": {
      "type": "remote",
      "url": "https://quiver-production-c3a8.up.railway.app/mcp",
      "enabled": true
    }
  }
}
# add to OpenClaw
openclaw mcp add tristan-tech-ai-quiver-risk-brain --url 'https://quiver-production-c3a8.up.railway.app/mcp' --transport streamable-http
# ~/.hermes/config.yaml
mcp_servers:
  tristan-tech-ai-quiver-risk-brain:
    url: "https://quiver-production-c3a8.up.railway.app/mcp"
// ~/.netclaw/config/netclaw.json
{
  "McpServers": {
    "tristan-tech-ai-quiver-risk-brain": {
      "Transport": "http",
      "Url": "https://quiver-production-c3a8.up.railway.app/mcp"
    }
  }
}
# add to Vellum
assistant mcp add tristan-tech-ai-quiver-risk-brain -t streamable-http -u 'https://quiver-production-c3a8.up.railway.app/mcp'
// mcp.json
{
  "mcpServers": {
    "tristan-tech-ai-quiver-risk-brain": {
      "type": "http",
      "url": "https://quiver-production-c3a8.up.railway.app/mcp"
    }
  }
}

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

Changelog

Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.

  • 28 Sept 26 0
    • We updated how we score, so this day's move reflects our rubric, not a change to the server See what changed → functional
  • 25 Sept 26 0
    • We updated how we score, so this day's move reflects our rubric, not a change to the server See what changed → functional
  • 10 Sept 26 −58
    • Endpoint reachability: reachable → not serving MCP ▼ security
    • Stability: pass → unverified ▼ security
    • Tool safety: pass → unverified ▼ security
    • Authorization: partial → unverified ▼ security
    • Transport: pass → fail ▼ security
    • Capabilities: pass → unverified ▼ functional
    • Tool coverage: 100 → unverified ▼ functional
    • First check of Schema quality: unverified functional
  • 26 Aug 26 0
    • We updated how we score, so this day's move reflects our rubric, not a change to the server See what changed → functional
  • 25 Aug 26 0
    • Stability: 0.97 → pass security
  • 11 Aug 26 0
    • We updated how we score, so this day's move reflects our rubric, not a change to the server See what changed → functional
  • 31 Jul 26 0
    • We updated how we score, so this day's move reflects our rubric, not a change to the server See what changed → functional
  • 30 Jul 26 0
    • We updated how we score, so this day's move reflects our rubric, not a change to the server See what changed → functional
Diagnostics

Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.

Captured 8 Oct 2026 · Probed https://quiver-production-c3a8.up.railway.app/mcp

TLS valid

Negotiated TLS 1.3 with TLS_AES_128_GCM_SHA256 .

Subject Issuer Valid from Valid until Key Signature Serial
CN=*.up.railway.app CN=YE2,O=Let's Encrypt,C=US 27 Sept 2026 26 Dec 2026 ECDSA 256 ECDSA-SHA384 618edc56941aa1165ddb080bf9f799eb7c1
SANs: *.up.railway.app, up.railway.app
CN=YE2,O=Let's Encrypt,C=US (CA) CN=Root YE,O=ISRG,C=US 3 Sept 2025 2 Sept 2028 ECDSA 384 ECDSA-SHA384 4df3b15dd6c0784c507cd37b58e6f115
CN=Root YE,O=ISRG,C=US (CA) CN=ISRG Root X2,O=Internet Security Research Group,C=US 13 May 2026 2 Sept 2032 ECDSA 384 ECDSA-SHA384 872165fc34b6e5fba8add5b3705fb53a
CN=ISRG Root X2,O=Internet Security Research Group,C=US (CA) CN=ISRG Root X1,O=Internet Security Research Group,C=US 13 May 2026 2 Sept 2032 ECDSA 384 SHA256-RSA 6c8f1dc727c7117f7baf853ac980f9cd

Background: What to check on a remote MCP endpoint →

DNSSEC insecure

Validation of quiver-production-c3a8.up.railway.app. — Not signed

Zone DS Keys Algorithms Outcome
. trust_anchor 20326, 38696 8, 8 Verified
app. present 23684 8 Verified
railway.app. absent Unsigned (proven) parent-signed NSEC/NSEC3 proves an unsigned delegation
Authentication Inconclusive

We could not reach the endpoint well enough to judge its authorisation posture.

Result Inconclusive
HTTP status 404

Background: How OAuth 2.1 works in the 2026 MCP spec →

Transports 2 probes
Transport URL Outcome Status Location
streamable-http https://quiver-production-c3a8.up.railway.app/mcp HTTP error 404
http (plaintext) http://quiver-production-c3a8.up.railway.app/mcp HTTPS enforced 301 https://quiver-production-c3a8.up.railway.app/mcp
MCP tools · 9 exposed · ~2,340 tokens

The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →

Tool Tokens
event_vol ~306

Options-implied expected move around a scheduled event (FOMC/CPI/earnings/etc.). Given spot, ATM implied vol, and days-to-event, returns the 1σ move, the straddle-implied expected ABSOLUTE move (risk-neutral E|ΔS|), and the probability of exceeding move thresholds. Given the vol term structure across the event (ATM IV of the expiry before vs after), it ISOLATES the event's own priced-in move (the Wright event-day technique). Self-checked: the straddle equals a numerical integral of |S_T−S₀|. This is the magnitude that macro calendars (which give only date + impact label) leave out.

NameTypeReqDescription
Tnumber–years (or daysToEvent)
atmIvnumber–ATM IV as a decimal (alternative to atmIvPct)
atmIvPctnumber–ATM IV in % (or atmIv decimal)
daysAfternumber–days to the after-event expiry
daysBeforenumber–days to the before-event expiry
daysToEventnumber–days until the event
ivAfterPctnumber–ATM IV (%) of the expiry just AFTER the event
ivBeforePctnumber–ATM IV (%) of the expiry just BEFORE the event
spotnumberyescurrent spot price
thresholdsPctarray–move thresholds (%) for probability-of-exceeding
NameTypeReqDescription
atmIvPct––ATM IV used (%)
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
eventIsolation––the event's own priced-in move, isolated from the term structure (when before/after IVs are given)
expectedMove––1σ move + straddle-implied expected |ΔS| (risk-neutral)
horizonDays––horizon in days
method––technique + assumptions used
okboolean–false when the engine rejected the input
probabilityMoveBeyond––probability of exceeding each move threshold
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
spot––spot the computation is anchored on

No examples provided.

exec_verify ~238

Deterministic execution-quality / fair-fill verification. Given a completed swap (amountIn, amountOutRealized) plus either the pre-trade pool reserves+fee (constant-product) or a fair reference price, returns how many basis points the fill lost to ADVERSE execution (sandwich/MEV/stale) beyond the unavoidable fee + own price impact. Proves that a fill "within slippage tolerance" can still have been robbed. Call after a swap to detect being sandwiched.

NameTypeReqDescription
amountInnumberyesinput amount actually sent
amountOutRealizednumberyesoutput amount actually received
fairPricenumber–reference mode: fair out-per-in price at submit time
feeTiernumber–pool fee as fraction, e.g. 0.003
reserveInnumber–pool reserve of input token, pre-trade (constant-product mode)
reserveOutnumber–pool reserve of output token, pre-trade
slippageTolerancePctnumber–the slippage setting used, to demonstrate within-tolerance-yet-robbed
NameTypeReqDescription
adverseExecutionBps––bps lost to ADVERSE execution beyond the honest cost
adverseValueOut––value lost to adverse execution, in output-token units
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
honestFillPrice––the fill price an honest execution would have produced
honestOut––output an honest execution would have delivered
midPrice––pre-trade mid price
mode––constant-product or reference-price mode
note––interpretation guidance
okboolean–false when the engine rejected the input
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
realizedFillPrice––the fill price actually received
unavoidableCostBps––fee + own price impact — the honest, unavoidable cost (bps)
verdict––plain-language verdict

No examples provided.

lp_risk ~229

Forward-looking liquidity-provision risk. Given a realized price ratio (for impermanent loss) and/or a volatility + horizon (for expected divergence / LVR), returns the closed-form IL, the expected −σ²T/8 divergence, and — with a fee APR — the net forecast and breakeven volatility (the vol above which fees no longer cover the bleed). Self-checked: the IL closed form is verified at the token level against explicit constant-product amounts. Call before providing liquidity to see whether the fee yield can plausibly beat the divergence loss.

NameTypeReqDescription
capitalUsdnumber–position capital in USD — losses are also reported in USD
concentrationFactornumber–V3 amplifier ≥1 (default 1)
feeAprPctnumber–annualized fee yield estimate
horizonPeriodsnumber–periods (default 1)
periodsPerYearnumber–default 365
priceRationumber–realized P1/P0 for realized IL
volatilitynumber–per-period vol (decimal) for expected divergence
NameTypeReqDescription
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
concentrationFactor––V3 concentration amplifier applied
expectedDivergence––expected divergence loss / LVR over the horizon (−σ²T/8 law)
feeVsDivergence––net forecast and breakeven volatility vs the fee APR
model––model assumptions used
okboolean–false when the engine rejected the input
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
realizedIL––closed-form impermanent loss at the realized price ratio

No examples provided.

options_risk ~215

Portfolio greeks (delta/gamma/vega/theta/vanna/volga) + SPAN-style scenario margin for an options book on Black-76. Given a list of legs {type, strike, expiryDays, iv, quantity(signed)} and a forward, returns aggregate greeks, first-order P&L per underlying move, and the worst-case loss over a price×vol grid. Self-checked: analytic greeks are verified against finite-difference derivatives of the repriced book. Call to size an options book's true net risk and margin — not the sum of per-leg notionals.

NameTypeReqDescription
forwardnumber–shared forward price (or set per position)
positionsarrayyesoption legs of the book
rnumber–discount rate, default 0
scanRangePctnumber–SPAN price scan range, default 0.15
volShiftVolPtsnumber–SPAN vol shift in vol-points, default 10
NameTypeReqDescription
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
greeks––aggregate delta/gamma/vega/theta/vanna/volga — each verified vs finite differences
model––Black-76 assumptions used
okboolean–false when the engine rejected the input
pnlPerUnderlyingPctMove––first-order P&L per % move of the underlying
portfolioValue––mark-to-model value of the book
positions––per-leg pricing breakdown
positionsCount––number of legs priced
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
spanMargin––worst-case loss over the price×vol scenario grid (SPAN-style margin)

No examples provided.

perp_gate ~427

Deterministic perpetual-futures risk. Given a position (entry, size, margin/leverage, maint-margin/maxLeverage), returns the exact liquidation price, the % adverse move to liquidation, effective leverage, and (if a funding rate is given) the funding drag. Pass a Hyperliquid `symbol` (e.g. BTC) to auto-fill live mark price, funding, and max leverage. Includes a self-check proving the liquidation invariant. Call this BEFORE opening or sizing any leveraged perp position — an agent that knows its true liquidation distance does not get surprise-liquidated.

NameTypeReqDescription
entryPricenumber–defaults to live mark if a symbol is given
fundingRateHourlynumber–hourly funding rate (Hyperliquid funds hourly)
horizonHoursnumber–horizon for the funding-drag estimate, in hours
leveragenumber–position leverage (alternative to margin)
maintMarginRatenumber–e.g. 0.0125; or pass maxLeverage (mmr = 0.5/maxLeverage)
marginnumber–isolated margin posted (or pass leverage)
markPricenumber–current mark; distance-to-liq measured from here
maxLeveragenumber–venue max leverage for the asset
notionalnumber–position notional in quote/USD
sidestring–long | short (buy | sell are accepted synonyms, as is -1 for short); default long
sizenumber–position size in base units (or pass notional)
symbolstring–perp symbol (e.g. BTC) — auto-fills live markPrice, fundingRateHourly, and the margin source (Hyperliquid notional tiers or dYdX maintenance rate); also defaults entryPrice to the live mark
venuestring–live-data venue (default hyperliquid). The maths is venue-agnostic — for any other venue omit this and pass maxLeverage/markPrice/fundingRateHourly yourself.
NameTypeReqDescription
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
effectiveLeverage––notional / margin actually run
funding––funding drag over the horizon (when a funding rate is given)
initialMarginRatePct––initial margin rate applied (%)
liquidationPrice––exact price at which the position liquidates
maintenanceMarginRatePct––maintenance margin rate applied (%)
marginTier––venue margin tier the notional falls into
model––model assumptions used
moveToLiquidationPct––adverse % move (from mark) that triggers liquidation
okboolean–false when the engine rejected the input
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…

No examples provided.

portfolio_gate ~382

Cross-venue portfolio risk. Given positions across venues [{venue, asset|symbol, side, size, entryPrice, margin|leverage, maxLeverage|marginTiers}] — OR just account: a Hyperliquid 0x address, whose FULL live book (positions, margins, account equity, the venue's own liquidation prices) is pulled keylessly — returns TRUE net exposure per underlying, the leg that liquidates FIRST (the binding constraint), concentration (HHI / effective independent bets), and a correlated-crash stress counting how many legs liquidate SIMULTANEOUSLY when the market moves ±X% (correlation→1, the Oct-10-2025 crash regime). Pass Hyperliquid symbols to auto-fill live mark/leverage/margin-tiers. Self-checked (exposure reconciliation, per-leg liquidation invariant, nearest=min, monotone stress, venue-liquidation cross-check). Call to see whether independently-sized bets are secretly ONE bet that blows up together.

NameTypeReqDescription
accountstring–OR: a Hyperliquid account address (0x…) — the full live book (positions, margins, equity, venue liquidation prices) is pulled keylessly; explicit positions take precedence.
betaTierstring–beta regime for the factor stress: mild | moderate | severe — cross-event validated tiers (pre-registered). Default = worst-case single-event table; explicit betas override.
positionsarray–legs: {venue, asset|symbol, side long|short, size, entryPrice, markPrice?, margin|leverage, maxLeverage|maintMarginRate|marginTiers}. A Hyperliquid symbol auto-fills live mark/leverage/tiers.
shockScenariosPctarray–correlated market moves (%) to stress; default [5,10,20,30]
NameTypeReqDescription
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
concentration––HHI + effective number of independent bets
correlatedShockStress––per-scenario: how many legs liquidate simultaneously at a correlated ±X% move
model––model assumptions used
nearestLiquidation––the leg that liquidates FIRST — the binding constraint
netExposureByAsset––TRUE net exposure per underlying (longs netted against shorts)
okboolean–false when the engine rejected the input
positions––per-leg breakdown with each liquidation price
positionsCount––number of legs analyzed
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
totalGrossNotional––sum of |notional| across legs
totalNetNotional––net notional after long/short netting

No examples provided.

risk_attest ~132

Batch the content-hashes from many Quiver proof envelopes into ONE Merkle root plus per-item inclusion proofs, so a single on-chain anchor (your wallet's tx) attests all of them at once. Self-checked for completeness (every item verifies) and soundness (a non-member does not). Use to make a batch of risk computations cheaply and permanently attestable for audit/liability, without a chain write per computation.

NameTypeReqDescription
contentHashesarray–alternatively, raw content-hashes
itemsarray–proof envelopes (uses proof.contentHash) or raw content-hashes (hex)
NameTypeReqDescription
algorithm––hash/tree construction used
anchor––EIP-712 (EAS-ready) attestation payload for the single on-chain anchor
attestations––per-item inclusion proofs
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
duplicateLeaves––duplicate content-hashes detected in the batch
leafCount––number of items batched
merkleRoot––the single root that attests every item
okboolean–false when the engine rejected the input
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
verify––how to verify inclusion against the root

No examples provided.

size_gate ~211

Deterministic position sizing (fractional Kelly) + risk-of-ruin. Given an edge — discrete {winProb, winLossRatio} or continuous {expectedReturn, volatility} — and a bankroll, returns the fractional-Kelly size and the probability of ever drawing down to 50/75/90%. The direct antidote to over-betting: full Kelly rides thin edges to ruin; this defaults to quarter-Kelly. Call before sizing ANY position.

NameTypeReqDescription
bankrollnumber–bankroll in account units — recommended sizes are returned in the same units
expectedReturnnumber–continuous mode: excess return per period (mu)
kellyFractionnumber–fraction of full Kelly to bet (default 0.25)
volatilitynumber–continuous mode: volatility per period (sigma)
winLossRationumber–discrete mode: net win/loss odds b
winProbnumber–discrete mode: win probability in (0,1)
NameTypeReqDescription
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
expectedLogGrowth––expected log-growth rate at the recommended size
fullKellyFraction––full-Kelly fraction of bankroll (the ruinous ceiling, not the recommendation)
hasEdge––false when the edge is non-positive (bet nothing)
impliedPortfolioVolPct––portfolio volatility implied by the recommended size (%)
kellyFractionUsed––fraction of full Kelly applied (default 0.25)
leverage––implied leverage of the recommended size
mode––discrete or continuous
model––model assumptions used
note––plain-language guidance
okboolean–false when the engine rejected the input
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
recommendedBetFraction––recommended bet as a fraction of bankroll
recommendedSize––recommended bet size in bankroll units
riskOfRuin––probability of ever drawing down to 50/75/90% of bankroll

No examples provided.

treasury_risk ~200

Stablecoin / on-chain treasury risk. Given a book of positions [{asset, amountUsd, apyPct, venue, chain, pegTarget, depegProbAnnual}], returns concentration (Herfindahl by asset/venue/chain + breaches over a limit), depeg stress (explicit scenarios + a worst-single-depeg scan), weighted and risk-adjusted yield. Self-checked: HHI == Σw², weights sum to 1, depeg-loss identity. Call to size a treasury's real risk — issuer/venue/chain concentration and depeg exposure — not just its headline APY.

NameTypeReqDescription
concentrationLimitPctnumber–flag any single exposure above this (default 25)
depegFloornumber–worst-single-depeg stress floor (default 0.90)
depegScenariosarray–[{asset, price}] explicit depeg stresses
positionsarrayyestreasury holdings
NameTypeReqDescription
checksarray–Ground-truth self-checks; the result is untrustworthy if any fails.
concentration––Herfindahl (HHI) by asset/venue/chain + limit breaches
depegStress––explicit depeg scenarios + worst-single-depeg scan
expectedAnnualDepegLossUsd––expected annual loss from depeg probabilities (USD)
model––model assumptions used
okboolean–false when the engine rejected the input
proofobject–Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-f…
riskAdjustedApyPct––yield after expected depeg loss (%)
totalUsd––total treasury size in USD
verdict––plain-language verdict
weightedApyPct––holdings-weighted headline APY (%)

No examples provided.

Common questions

What is the Quiver Risk Brain MCP server?

Quiver Risk Brain is an MCP server listed in the public MCP registry as io.github.Tristan-tech-ai/quiver-risk-brain. Verifiable, deterministic risk math for autonomous agents; re-runnable proof on every answer. This page covers its hosted endpoint (https://quiver-production-c3a8.up.railway.app/mcp).

Is the Quiver Risk Brain MCP server safe to use?

Quiver Risk Brain scores 23 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

What tools does the Quiver Risk Brain MCP server expose?

Quiver Risk Brain exposes 9 tools: perp_gate, portfolio_gate, size_gate, exec_verify, options_risk, and 4 more. Their descriptions and schemas cost roughly 2,340 tokens of context every time the server is loaded.

Does the Quiver Risk Brain MCP server require authentication?

Its publisher declares no required credentials for Quiver Risk Brain. We have not been able to confirm that against the live endpoint, and a server can require authorisation without declaring it here.

Is the Quiver Risk Brain MCP server still maintained?

Quiver Risk Brain is still listed as active in the MCP registry. We last reached this channel on 7 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.