MCP.so
Sign In
V

Velarion — Executive Compensation IntelligenceVerifiedFeatured

@Velarion

About Velarion — Executive Compensation Intelligence

Velarion exposes deterministic executive-compensation and governance intelligence for ~3,000 US public companies as callable MCP tools — sourced from SEC proxy filings, not LLM guesses. Nine tools: look up CEO/NEO pay and pay mix, predict Say-on-Pay risk (deterministic risk band + trend), benchmark CEO pay percentile vs disclosed peers, compare up to 20 companies side-by-side, and generate a structured Governance Alpha Card (pay alignment, governance scorecard, SoP risk band, peer quality). Four commerce tools — list the catalog, price an artifact, place an order, and fulfill it after verified on-chain USDC settlement — enable agent-native paid delivery. All data tools are fully deterministic; out-of-coverage tickers return structured errors, never fabricated data. Remote streamable-HTTP connector; per-agent token issued by Velarion (X-Velarion-Agent-Token header).

Connection details

https://api.velarion.ai/mcp

Setup

claude mcp add velarion-scraper-production-01a332 --transport http https://api.velarion.ai/mcp

Tools

9

Look up executive compensation for a company in Velarion's coverage universe. Returns CEO/NEO total compensation, pay mix breakdown, and canonical metrics for the requested fiscal year (latest available if omitted). All data sourced from Supabase production tables — no LLM, no invented values. Out-of-coverage tickers return a structured error (not_in_coverage).

Predict Say-on-Pay risk for a company using Velarion's deterministic risk compilers. Returns trend phrase, peer cohort distribution note, governance friction summary, and overall risk band. No LLM — fully deterministic from canonical_metrics + say_on_pay data. Compilers: compile_sop_trend_phrase, compile_sop_peer_cohort_distribution, compile_governance_friction_summary (lib/agent_merchant/compilers/say_on_pay_risk.py).

Benchmark executive pay vs. disclosed peers using Velarion's canonical percentile data. Returns pay percentile, performance (TSR) percentile, P4P gap, and an alignment label based on canonical_metrics columns (ceo_percentile, tsr_percentile, p4p_gap). No LLM. role is currently CEO-only (only CEO percentile is pre-computed in canonical_metrics).

Compare multiple companies on pay, performance, and governance metrics. Returns a ranked table from Velarion's canonical_metrics — no LLM narrative invention. The data-based summary describes observed patterns in the returned data only. Out-of-coverage tickers are excluded (listed separately). Max 20 tickers.

Generate a Governance Alpha Card for a company. Composite deterministic card: pay alignment (Velarion's own P4P-style estimate, modeled on public proxy-advisory methodology concepts — not licensed ISS data), governance scorecard, SoP risk band, peer quality, top risks/strengths. Requires the company to be in Velarion's coverage universe with current-period data. Calls generate_alpha_card (lib/agent_merchant/compilers/governance_alpha_card.py:441) after confirming deliverability via evaluate_deliverability (deliverability.py:219), which includes the period-currency gate (_governance_alpha_card_period_gate at :312). FREE-TIER CAP: this is the free sample of a $100 marketplace product (GOVERNANCE-ALPHA-CARD, pricer.py:59). Each agent gets ALPHA_CARD_FREE_DAILY_CAP cards per UTC day; beyond that the tool returns free_tier_cap_reached with the purchase path. Unlimited free issuance of the paid anchor product is the contradiction the catalog's PRICE_INTEGRITY blocker named — the cap is what resolves it. Structured errors returned (not raised) for: - not_in_coverage: ticker unknown - not_deliverable: coverage too thin / stale period - free_tier_cap_reached: daily free allowance spent (buy it, or wait for 00:00 UTC)

Price a Velarion product. Handles EVERY catalog SKU in its real state. product_type may be a sku_id (e.g. "SKU-002") OR a custom_artifact_family (e.g. "peer_disclosure_custom_cohort"). Returns the row's classification and, when APPROVED_SELLABLE, the price a buyer is actually charged: - APPROVED_SELLABLE → proposed_price_cents + currency + fulfillment_type + latency + caveats. No price floor touches it (deleted 2026-07-14); the catalog/pricer anchor IS the billed price. - NEEDS_OWNER_APPROVAL → {status: "needs_owner_approval"} structurally — price is known but the row is pending Andy's approval flip. - UNSELLABLE / KILLED → structured error with the reason. custom_band families price via the profit-aware pricer (respecting MERCHANT_MIN_MARGIN); one_off_fixed SKUs price at the canonical catalog price_cents. No fabricated price is ever returned (price_verified gate enforced upstream in classify_sku).

Place an order for a priced product — creates a quote you can pay and then fulfill. This is the missing middle of the buy path: price_product tells you what it costs, place_order creates the actual quote (owned by YOUR agent account), and fulfill_paid_order delivers it once settlement clears. Requires a token with the mcp:buy scope AND a Velarion commerce account — a self-serve token issued at POST /agent/v1/token/self-serve has both. CUSTOM-* cohort products (CUSTOM-PEER-COHORT / CUSTOM-SOP-WINDOW / CUSTOM-GOV-EXTENDED): the ticker list is the comparison cohort, capped at 15 distinct tickers (a 16th is a clean too_many_tickers rejection, never a silent truncation). The subject is the first in-coverage ticker unless subject_ticker names another cohort member. Returns quote_id, the price, and how to pay. Nothing is charged here.

Fulfill a paid custom quote by compiling and delivering its artifact. Ownership gate: you may only fulfill a quote your own agent account owns. (The REST buyer rail has always enforced this — routes.py:656 — and this tool did not, which meant any valid token could fulfill, and therefore download, an artifact somebody else had paid for. Latent while every token was owner-issued; a live artifact leak the moment self-serve issuance opened. Closed here.) Settlement gate (fail-closed): if the quote is priced and settlement is not verified on any rail, returns settlement_unverified — compile_and_deliver is NOT called. On verified settlement: calls compile_and_deliver (fulfillment.py:121) — the same path used by Danny and the agent bridge. No forked fulfillment logic.

List the Velarion catalog — every product an agent can see and (where APPROVED_SELLABLE) buy. Returns all APPROVED_SELLABLE SKUs with full detail by default (sku_id, name, price, currency, fulfillment type, latency, caveats, classification). Set include_non_sellable=true to also return NEEDS_OWNER_APPROVAL / UNSELLABLE / KILLED rows, each clearly tagged with its classification and blockers so inventory is never hidden — only de-prioritized. No price is fabricated: unverified prices are surfaced as-is with their classification, never quoted as billable.

Overview

What is Velarion MCP?

Velarion exposes executive compensation and governance intelligence for ~3,000 US public companies as callable MCP tools. Every data tool is deterministic — outputs are structured directly from SEC proxy filings (DEF 14A) and audited production tables, never LLM synthesis. Out-of-coverage tickers return structured errors, never fabricated data.

Nine tools

ToolWhat it returns
lookup_company_compensationCEO & NEO total comp, pay mix, canonical peer benchmarks
predict_say_on_pay_riskDeterministic Say-on-Pay risk band + trend + peer cohort
benchmark_executive_payCEO pay percentile vs disclosed peers, TSR percentile, P4P gap
compare_companiesSide-by-side comparison of up to 20 companies
generate_governance_alpha_cardComposite card: pay alignment, governance scorecard, SoP risk, peer quality
price_productProfit-aware price for a paid intelligence artifact
place_orderCreate a payable quote for a priced product
fulfill_paid_orderDeliver a paid artifact after verified on-chain USDC settlement
list_skusThe sellable catalog with price, latency, and caveats

Get a token (free tier)

Self-issue an agent token at https://intel.velarion.ai/developers — the four read tools plus 3 free Governance Alpha Cards/day work immediately, no card required.

Connect (remote streamable-HTTP)

{
  "mcpServers": {
    "velarion": {
      "type": "streamable-http",
      "url": "https://api.velarion.ai/mcp",
      "headers": { "X-Velarion-Agent-Token": "<YOUR_AGENT_TOKEN>" }
    }
  }
}

Who it's for

  • Compensation consultants — benchmark a client's CEO package against its disclosed peer group in seconds.
  • Stewardship / proxy teams — run Say-on-Pay risk across a portfolio queue as structured JSON.
  • AI / governance builders — machine-readable comp intelligence callable from an agent pipeline.
  • Corporate secretaries & GC — flag governance friction (clawback, hedging, pledging, ownership guidelines) before a filing.

Frequently asked questions

What is the Velarion — Executive Compensation Intelligence remote MCP server?

The Velarion — Executive Compensation Intelligence remote MCP server is a hosted Model Context Protocol endpoint at https://api.velarion.ai/mcp, so AI assistants can connect to it without installing or running anything locally.

How do I connect to the Velarion — Executive Compensation Intelligence MCP server?

Add the endpoint https://api.velarion.ai/mcp to any MCP-compatible client such as Claude Code, Cursor, or VS Code. The setup snippets on this page configure each client in one step.

Does the Velarion — Executive Compensation Intelligence MCP server require authentication?

Yes. Velarion — Executive Compensation Intelligence requires an API key — check the official documentation for how to obtain one, then include it in your client's configuration.

Which transport does the Velarion — Executive Compensation Intelligence MCP server use?

Velarion — Executive Compensation Intelligence exposes a Streamable HTTP endpoint, the transport used by remote MCP servers and supported by all major MCP clients.

Comments