# Syenite MCP server

DeFi interface for AI agents: swap, bridge, yield, lending. Live at syenite.ai.

## Links
- Registry page: https://www.getdrio.com/mcp/io-github-syenite-ai-syenite
- Repository: https://github.com/syenite-ai/syenite

## Install
- Command: `npx -y @syenite/mcp`
- Endpoint: https://syenite.ai/mcp
- Auth: Not captured

## Setup notes
- Package: Npm @syenite/mcp v0.4.0
- Remote endpoint: https://syenite.ai/mcp

## Tools
- syenite.help - Get information about Syenite — real-time lending rates, yield, and position alerts for AI agents. Covers Aave, Morpho, Compound, Spark, and Pendle. Also: swap/bridge routing (30+ chains), lending execution, prediction markets, carry screening, and a trust layer for transaction verification.
Call this tool to learn what tools are available and how to use them. Endpoint: https://syenite.ai/mcp
- lending.rates.query - Returns real-time borrow APY, supply APY, available liquidity, utilization, max LTV, liquidation threshold, and liquidation penalty for every active lending market across Aave v3, Compound V3, Fluid, Morpho Blue, and Spark on Ethereum, Arbitrum, and Base, plus Kamino and MarginFi on Solana.
Call this before any borrow or supply decision to identify the cheapest borrow or the highest supply rate for a given asset pair; the response includes a `bestBorrowRate` summary field for quick comparison.
Pass `collateral` (e.g. "WBTC", "ETH", "wstETH") and `borrowAsset` (e.g. "USDC", "DAI") to filter by pair; pass `chain` ("ethereum", "arbitrum", "base", "solana", or "all") to restrict scope — omitting either returns all markets.
This tool is read-only and executes no transactions; APYs include compounding and are sourced live from on-chain data. Endpoint: https://syenite.ai/mcp
- lending.market.overview - Returns an aggregated overview of DeFi lending market conditions across Aave v3, Compound V3, Fluid, Morpho Blue, and Spark on Ethereum, Arbitrum, and Base.
Use this for a macro view of the lending landscape before calling `lending.rates.query` for per-market detail — it surfaces cross-protocol totals for supply, borrow, utilization, and available liquidity alongside borrow and supply APY ranges per protocol.
Pass `collateral` (e.g. "ETH", "BTC", or "all") to scope the market scan; optionally pass `chain` to restrict to one network.
Returns cross-protocol summary (lowest borrow APY, highest supply APY, total available liquidity) and per-protocol breakdowns including individual market rows; does not execute any transaction. Endpoint: https://syenite.ai/mcp
- lending.position.monitor - Reads the live health of any EVM wallet's lending positions across Aave v3, Morpho Blue, Compound V3, and Spark on Ethereum, Arbitrum, and Base — no authentication required.
Call this before withdrawing collateral or after price moves to verify health factor and liquidation distance; positions with health factor below 1.5 trigger an explicit warning in the response.
Provide the 0x-prefixed EVM `address` to inspect; optionally filter by `protocol` ("aave-v3", "morpho-blue", "compound-v3", or "spark") and `chain` to reduce response size.
Returns per-position: collateral asset and USD value, debt asset and USD value, current LTV, health factor, liquidation price, percentage price drop to liquidation, borrow APY, and estimated annual interest cost; does not execute any transaction. Endpoint: https://syenite.ai/mcp
- lending.risk.assess - Evaluates the risk of a proposed lending position before it is opened — fetching live rates, current asset price, and available liquidity from Aave v3, Morpho Blue, and Spark to compute position-specific risk metrics.
Call this before `lending.supply` and `lending.borrow` whenever an agent is about to open or resize a collateralized borrow; it surfaces the protocol with the lowest borrow APY that accepts the target LTV.
Provide `collateral` asset symbol (e.g. "wBTC", "wstETH"), `collateralAmount` (token units), `targetLTV` (percentage, e.g. 60), and optionally `borrowAsset` (default "USDC") and `protocol` preference ("aave-v3", "spark", "morpho-blue", or "best").
Returns a risk score (1–10), liquidation price and distance, liquidation penalty in USD, position sizing warnings if the borrow is large relative to pool liquidity, collateral-specific depeg notes, protocol oracle and governance notes, estimated annual borrow cost, and an actionable plain-language summary; does not execute any transaction. Endpoint: https://syenite.ai/mcp
- yield.opportunities - Aggregates and ranks live DeFi yield opportunities for any asset across lending supply (Aave, Morpho Blue, Spark), liquid staking (Lido, Rocket Pool, Coinbase), savings rates (Maker DSR/sDAI), curated vaults (MetaMorpho, Yearn), fixed-yield Pendle PTs, and basis capture (Ethena sUSDe) on EVM chains, plus Kamino, MarginFi, Jito, Marinade, and Drift on Solana.
Call this to discover where to deploy capital before deciding on a protocol; follow up with `yield.assess` to evaluate the risk of a specific opportunity.
Pass `asset` (e.g. "USDC", "ETH", "stables") and `chains` (["ethereum"], ["solana"], or both) to scope results; optionally filter by `riskTolerance` ("low", "medium", "high") or `tags` (["fixed-yield"] for Pendle PTs, ["yt"] to surface Pendle YT markets which are hidden by default).
Returns opportunities sorted by APY with risk level, TVL, lockup period, APY type (variable/fixed/estimated), and category counts; does not execute any transaction. Endpoint: https://syenite.ai/mcp
- yield.assess - Provides a structured risk assessment for a specific DeFi yield opportunity before committing capital — covering smart contract risk, oracle configuration, governance model, liquidity and exit risk, depeg/peg risk, and position sizing relative to TVL.
Call this after `yield.opportunities` when an agent or user wants to evaluate a specific protocol and product in depth rather than just comparing APYs.
Provide `protocol` (e.g. "Aave v3", "Morpho", "Lido") and optionally `product` to disambiguate vaults, `amount` in USD to get position-sizing warnings, and `asset` to narrow matches.
Returns a numeric risk score (1–10), per-dimension risk notes, projected annual and monthly yield for the supplied amount, and up to five comparable alternatives ranked by APY; does not execute any transaction. Endpoint: https://syenite.ai/mcp
- swap.quote - Fetches an optimal swap or bridge quote across 30+ EVM chains and Solana using the LI.FI aggregator (EVM) or Jupiter (Solana), comparing routes from DEXs and bridges including 1inch, 0x, Paraswap, and major cross-chain bridges to find the best price with lowest fees. Call this before any token exchange to obtain a quote; then pass the returned unsigned transaction calldata to a wallet for signing and submission — Syenite never holds or touches private keys. Provide fromToken, toToken, fromAmount (human-readable), fromAddress, and fromChain; set toChain for cross-chain bridges, or omit to default to the same chain. Returns best route, expected output, minimum output (with slippage), gas cost, fee breakdown, and estimated execution time; cross-chain bridges may take 2–30 minutes and should be tracked with swap.status. Quotes are valid for approximately 30 seconds — re-query for fresh pricing. Does not execute the swap. Endpoint: https://syenite.ai/mcp
- swap.status - Tracks the execution status of a cross-chain bridge transaction submitted after a swap.quote call, polling LI.FI's bridge monitoring API to report whether the transfer is PENDING, DONE, or FAILED. Call this after submitting a cross-chain transaction — same-chain swaps settle immediately and do not require polling. Requires txHash (the sending transaction hash); supply fromChain and toChain for faster resolution, or omit to default to ethereum. Returns current status, substatus, receiving transaction hash, amount received at destination, and a human-readable message explaining next steps. Does not cancel or modify the transfer — it is read-only. Endpoint: https://syenite.ai/mcp
- swap.multi - Fetches up to 10 swap or bridge quotes in a single batched call, executing all route lookups in parallel and returning each result alongside a total cost summary. Use this when splitting funds across multiple chains, executing multi-leg portfolio rebalancing, or comparing routes side-by-side without making sequential calls. Each element in the requests array accepts the same parameters as swap.quote (fromToken, toToken, fromAmount, fromAddress, fromChain, toChain, slippage, order). Returns per-request results with status ok or error (failed quotes do not abort the batch), plus aggregate gas and fee totals. Quotes are valid for approximately 30 seconds; sign and submit transactions sequentially to avoid nonce conflicts. Maximum 10 requests per call. Endpoint: https://syenite.ai/mcp
- wallet.balances - Returns native gas token and major stablecoin balances for any EVM or Solana address across supported chains, reading directly from on-chain RPC with no third-party indexer dependency. Accepts an EVM 0x-address (queries Ethereum, Arbitrum, Base, BNB Chain, and Optimism) or a Solana base58 pubkey (queries native SOL and all non-zero SPL token accounts) — address format is detected automatically. Optionally pass chains to restrict the query to specific chains and reduce latency. Use this before executing swaps, bridges, or lending operations to confirm the wallet holds sufficient funds. Returns balances per chain with raw and human-readable amounts; chains with RPC errors are included with an error marker rather than silently dropped. Endpoint: https://syenite.ai/mcp
- gas.estimate - Returns current gas prices and estimated costs for common DeFi operations across EVM chains (Ethereum, Arbitrum, Base, BNB Chain) and Solana priority fees, allowing agents to confirm a wallet holds sufficient native gas and to select the cheapest chain for an operation. Covered operations: transfer, erc20_transfer, erc20_approve, swap, bridge, lending_supply, lending_borrow, contract_register — each reported with gas units, cost in native token, and approximate USD cost at current price. For Solana, returns recent prioritization fees in micro-lamports per compute unit (min, median, p75, max) sampled from the last few slots. Optionally filter by chains (array) and operations (array of operation names); defaults to all chains and all operations. Identifies the cheapest chain per operation. USD estimates use approximate native token prices and are indicative, not exact. Endpoint: https://syenite.ai/mcp
- tx.simulate - Simulates an unsigned EVM transaction against live chain state using eth_call and eth_estimateGas, returning whether the call would succeed or revert (with revert reason), estimated gas units, approximate gas cost in USD, and native token balance changes from the transaction value. Use this to independently verify what a transaction will do before signing — particularly useful when the transaction was constructed by a third party. Requires transaction.to, transaction.from, transaction.data, and optionally transaction.value and transaction.chainId; pass chain or chainId to target a specific network (ethereum, arbitrum, base, bsc supported). Does not submit the transaction; ERC-20 balance diffs require trace-level simulation (not available on public RPCs) and are noted but not fully computed. Endpoint: https://syenite.ai/mcp
- tx.verify - Cross-references a transaction target address against Etherscan (source code verification), Sourcify (independent verification), and Syenite's curated protocol registry to confirm the contract's identity and surface risk flags before signing. Use this to verify any EVM transaction target — not just Syenite-generated ones — as a mandatory pre-signing check in autonomous agent workflows. Requires to (the contract address, 0x-prefixed) and chain (ethereum, arbitrum, base, or bsc); optionally pass data (transaction calldata) to decode and name the function selector via 4byte.directory. Returns verification status from both sources, protocol identification (name, type, risk rating), function name if decoded, risk flags (unverified_contract, unknown_protocol, proxy_contract, eoa_target), and a human-readable summary. Network calls to Etherscan and Sourcify have 10-second timeouts; failures are noted but do not abort the call. Endpoint: https://syenite.ai/mcp
- tx.guard - Evaluates a proposed transaction against a caller-supplied set of risk rules before signing, returning a per-rule pass/fail/skip breakdown and an overall approved verdict. Rules are caller-defined — Syenite does not impose or modify them. Supported rules: maxValueNative (cap native token value), allowedContracts (allowlist of target addresses), blockedContracts (denylist), allowedFunctions (function selector filter), requireVerifiedContract (flag if contract is unverified — requires prior tx.verify call), requireAllowlisted (flag if contract is not in Syenite's curated protocol registry), and maxGasLimit. Pass transaction (to, data, value, gasLimit, chainId) and rules (any subset of the above); at least one rule is required. Use as a programmable safety gate before any autonomous on-chain action. Does not submit or sign the transaction. Endpoint: https://syenite.ai/mcp
- strategy.carry.screen - Screens all DeFi lending markets across Aave v3, Compound V3, Fluid, Morpho Blue, and Spark — plus Pendle PT fixed-rate rows — for positive carry, defined as collateral supply APY minus borrow APY.
Returns strategies ranked by net carry (highest first), with leveraged carry at 70% of max LTV, estimated annual USD return for a given position size, available liquidity, and utilization.
Call this to discover self-funding positions where deposited collateral earns more than the cost to borrow against it; positive-carry count and best strategy are surfaced in the `summary` field for quick scanning.
Optionally pass `collateral` (e.g. "wstETH"), `borrowAsset` (default "USDC"), `chain`, `minCarry` threshold (e.g. 0.5 for 0.5%+), and `positionSizeUSD` to size annual return estimates.
This tool is read-only; use `lending.risk.assess` and the lending execute tools to act on a strategy. Endpoint: https://syenite.ai/mcp
- prediction.trending - Fetches the top trending prediction markets on Polymarket ranked by trading volume, returning market titles, current outcome probabilities (derived from CLOB token prices as 0–100% values), total volume and liquidity in USDC, and bid-ask spread per market. Use this as the starting point for prediction market discovery — call before prediction.market, prediction.book, prediction.quote, or prediction.order to obtain market slugs and token IDs. Optionally pass limit (1–25, default 10) to control result count. Data is live from Polymarket's Gamma API and reflects current on-chain state. Endpoint: https://syenite.ai/mcp
- prediction.search - Searches Polymarket markets by topic keyword and returns matching events with current outcome probabilities, volume, liquidity, and order book metrics including best bid, ask, and spread. Use this when looking for a specific real-world event (elections, crypto price levels, sports outcomes, geopolitical events) rather than browsing by volume. Requires query (the search term); optionally pass limit (1–25, default 10). Returns market slugs and token IDs needed for prediction.market, prediction.book, prediction.quote, and prediction.order. Endpoint: https://syenite.ai/mcp
- prediction.book - Fetches the current CLOB order book for a specific Polymarket outcome token, returning top bid and ask levels with sizes, mid-price, spread in both decimal and basis points, and total bid/ask depth in USD. Use this to assess execution quality and market-making opportunities before placing an order — wide spreads indicate higher edge for makers; shallow depth signals potential slippage on larger size. Requires tokenId, which is obtained from the clobTokenIds field in prediction.trending or prediction.search results. Does not place or modify orders. Endpoint: https://syenite.ai/mcp
- prediction.signals - Scans the top 25 trending Polymarket markets and returns ranked actionable signals across five categories: wide_spread (bid-ask gap above 4% — market-making opportunity), extreme_probability (outcome above 92% or below 8% — contrarian or long-shot play), high_volume (turnover ratio above 5x — active price discovery), deep_liquidity (pool above $100k — safe for large size), and mispriced (outcome probabilities don't sum to 100% — arbitrage opportunity). Use this for autonomous prediction market strategy discovery without manually scanning individual markets. Optionally filter by minStrength (0–100), types (array of signal type strings), and limit (default 20, max 50). Returns each signal with strength score, affected market, suggested action, and supporting data. Signals are heuristic — verify market fundamentals before trading. Endpoint: https://syenite.ai/mcp
- find.strategy - Orchestrates a parallel scan across yield opportunities, carry trades, lending leverage, cross-chain rate arbitrage, and prediction market signals to surface the best strategies for a given asset and risk profile.
Call this as the first step when an agent has capital to deploy and needs ranked recommendations — it fans out to `yield.opportunities`, `carry.screen`, `gas.estimate`, and optionally `prediction.signals` in one call.
Provide `asset` (e.g. "WETH", "USDC", "WBTC"), optionally `amount` in USD (used for return estimates), `riskTolerance` ("low", "medium", or "high"), `chain`, and `includePrediction` (default true).
Returns strategies ranked by risk-adjusted return with category ("yield", "carry", "leverage", "arbitrage", "prediction"), expected APY, execution steps, and the exact Syenite tool names to call next for each strategy; does not execute any transaction. Endpoint: https://syenite.ai/mcp
- lending.supply - Generates unsigned ERC-20 approval and pool supply transaction calldata for depositing an asset into Aave v3 (Ethereum, Arbitrum, Base) or Spark (Ethereum).
Call this when the agent has decided to supply collateral or earn supply APY on a lending protocol; precede it with `lending.rates.query` to confirm the target protocol and chain.
Provide `protocol` ("aave-v3" or "spark"), `chain`, `asset` symbol (e.g. "WETH", "USDC"), human-readable `amount`, and `onBehalfOf` wallet address.
Returns two transaction requests — the ERC-20 approval must be submitted first, then the supply call — and a verification reminder to use `tx.receipt` and `lending.position.monitor` after submission.
Syenite never holds private keys; no funds move until the caller signs and broadcasts. Endpoint: https://syenite.ai/mcp
- lending.borrow - Generates unsigned variable-rate borrow transaction calldata for Aave v3 (Ethereum, Arbitrum, Base) or Spark (Ethereum).
Call `lending.risk.assess` before this tool to confirm the target LTV is safe and the market has sufficient liquidity.
Provide `protocol`, `chain`, `asset` to borrow (e.g. "USDC"), human-readable `amount`, and `onBehalfOf` wallet address; collateral must already be supplied.
Returns one transaction request (no approval needed for borrows); Syenite never holds private keys and no funds move until the caller signs and broadcasts. Endpoint: https://syenite.ai/mcp
- lending.withdraw - Generates unsigned withdraw transaction calldata to reclaim a supplied asset from Aave v3 (Ethereum, Arbitrum, Base) or Spark (Ethereum).
Call `lending.position.monitor` first to confirm the withdrawal will not push an outstanding borrow position toward liquidation.
Provide `protocol`, `chain`, `asset`, a human-readable `amount` or the string "max" to withdraw the full supplied balance, and `to` as the recipient address.
Returns one transaction request; Syenite never holds private keys and no funds move until the caller signs and broadcasts. Endpoint: https://syenite.ai/mcp
- lending.repay - Generates unsigned ERC-20 approval and variable-rate repay transaction calldata for Aave v3 (Ethereum, Arbitrum, Base) or Spark (Ethereum).
Use this to reduce or eliminate an outstanding borrow; pass amount "max" (uint256 max) to repay the entire debt balance, or a specific human-readable amount for partial repayment.
Provide `protocol`, `chain`, `asset` being repaid, `amount`, and `onBehalfOf` wallet address.
Returns the ERC-20 approval transaction (submit first) and the repay transaction; Syenite never holds private keys and no funds move until the caller signs and broadcasts. Endpoint: https://syenite.ai/mcp
- tx.receipt - Fetches and decodes an on-chain transaction receipt from any supported EVM chain, returning confirmation status (confirmed or reverted), gas used and effective gas price, cost in both native token and USD, block number, all contracts interacted with, decoded event logs (Transfer, Approval, Swap, Aave Supply/Borrow/Repay, and others), and a direct block explorer URL. Use after submitting any transaction — swap, supply, borrow, repay, bridge, or approval — to confirm execution and close the strategy loop. Requires txHash and optionally chain (ethereum, arbitrum, base, or bsc; defaults to ethereum). Throws if the transaction is not found, which may indicate it is still pending or was submitted to a different chain. Does not modify state. Endpoint: https://syenite.ai/mcp
- token.price - Returns the current USD price for one or more tokens by reading Chainlink on-chain price feed contracts directly — the same oracles that Aave, Morpho, Spark, and Compound use to trigger liquidations. Use this for portfolio valuation, P&L calculation, health-factor estimation, and policy enforcement where prices must match what lending protocols see. Pass symbol for a single token or symbols (array, max 20) for a batch lookup; results are cached for 60 seconds. Supported tokens: wBTC, tBTC, cbBTC, WETH, wstETH, rETH, cbETH, weETH, USDC, USDT, DAI, GHO, sDAI. Returns priceUSD and the feed contract address per token; unsupported symbols return an error entry without aborting the batch. Endpoint: https://syenite.ai/mcp
- alerts.watch - Registers a persistent background monitor that fires alerts when user-defined thresholds are crossed, persisting across server restarts. Supports four watch types: lending (monitors a wallet's health factor on Aave, Morpho, Spark, or Compound — fires when health factor drops below healthFactorThreshold), rate (monitors borrow/supply APY and pool utilization for a collateral/borrowAsset pair — fires on APY crossings via rateBorrowThreshold/rateSupplyThreshold or utilization via rateUtilizationThreshold), carry (monitors the net spread between best supply APY and cheapest borrow rate — fires when spread exceeds carryThreshold), and yield (monitors best available yield for an asset — fires when APY crosses yieldApyThreshold in the specified direction). Provide webhookUrl to receive POST payloads when alerts fire; otherwise poll alerts.check to retrieve unacknowledged alerts. Does not execute trades — alert data must be acted on by the agent. Returns a watch ID needed for alerts.remove. Endpoint: https://syenite.ai/mcp
- alerts.check - Triggers an immediate evaluation of all registered watches and returns any unacknowledged alerts grouped by severity (critical or warning). Call this to poll for fired conditions without waiting for a webhook — it is safe to call repeatedly and will re-evaluate all watches on each call. Optionally pass watchId to filter results to a single watch; pass acknowledge: true with a watchId to clear that watch's alerts after reading. Returns alert count, severity breakdown, and per-alert details including watch type, message, and supporting data. Does not modify watch configuration. Endpoint: https://syenite.ai/mcp
- alerts.list - Returns all currently registered watches with their full configuration, type (lending, rate, carry, yield, prediction), threshold parameters, and last check timestamp. Use this to audit active monitors before creating new ones or to retrieve watch IDs needed for alerts.remove. Takes no parameters and never triggers a live check — for current alert state, call alerts.check instead. Endpoint: https://syenite.ai/mcp
- rates.watch - Monitor DeFi lending rates and carry opportunities without polling. Three modes:

• rate — fires rate_spike when borrowAPY or supplyAPY crosses a threshold; fires rate_utilization when utilization exceeds rateUtilizationThreshold (critical at ≥95%). Each protocol/chain/market tracked independently — no false re-fires.
• carry — fires carry_opportunity when (best supply APY − cheapest borrow APY) exceeds carryThreshold. Replaces manual carry screener polling.

Results persisted across server restarts. Poll alerts.check to retrieve fired alerts. Endpoint: https://syenite.ai/mcp
- alerts.remove - Removes a registered watch by its ID, stopping all monitoring and alert generation for that watch immediately and permanently. Requires the watchId returned when the watch was created (or retrieved via alerts.list). Returns success: true if the watch was found and removed, or false if the ID was not found. Does not affect other watches or their accumulated alerts. Endpoint: https://syenite.ai/mcp
- metamorpho.supply - Builds unsigned ERC-20 approval and ERC-4626 deposit transaction calldata for supplying assets into a MetaMorpho curated vault on Ethereum, Base, Arbitrum, or Optimism.
Call this after selecting a vault from `yield.opportunities` (category "vault") or `yield.assess`; use `vault` to target by vault address or a name/curator fragment (e.g. "Steakhouse", "Gauntlet").
Provide `vault` identifier, human-readable `amount`, and `receiver` wallet address; the tool resolves vault address, underlying asset, and decimals automatically and errors with suggestions if the vault name is ambiguous.
Returns the ERC-20 approval transaction (submit first) and the deposit transaction; shares are credited to `receiver` at the vault's current exchange rate.
Syenite never holds private keys; no funds move until the caller signs and broadcasts both transactions. Endpoint: https://syenite.ai/mcp
- metamorpho.withdraw - Builds an unsigned ERC-4626 redeem transaction calldata to withdraw assets from a MetaMorpho vault on Ethereum, Base, Arbitrum, or Optimism.
Call this when an agent needs to exit a MetaMorpho vault position; no approval transaction is required for redemption.
Provide `vault` identifier (address or name fragment), `shares` as a human-readable amount or the string "max" to redeem the full balance, `receiver` address to receive underlying assets, and `owner` address whose shares will be burned.
Returns the redeem transaction request; withdrawal is subject to available liquidity in the underlying Morpho Blue markets and Syenite never holds private keys. Endpoint: https://syenite.ai/mcp
- prediction.market - Provides a comprehensive deep-dive on a single Polymarket market, returning the question, outcomes with current token prices and probability percentages, price history statistics for the last 24h/7d/30d (open, close, min, max, change), total and 24h volume, liquidity depth, bid-ask spread, one-sided order flow direction, implied probability, resolution criteria, and time remaining until close. Use this after prediction.trending or prediction.search to fully evaluate a market before quoting, ordering, or monitoring. Requires at least one of slug, conditionId, or marketId — all are returned by the search and trending tools. Does not place or cancel orders. Endpoint: https://syenite.ai/mcp
- prediction.watch - Registers a persistent background monitor for a specific Polymarket market that fires alerts when user-defined conditions are met. Supported conditions (at least one required): oddsThresholdPct (fire when implied probability crosses a target level), oddsMovePct (fire when probability moves by a delta% within a windowMinutes window), liquidityDropPct (fire when liquidity falls by a percentage from baseline), resolutionApproachingHours (fire when the market closes within N hours), and volumeSpikeMultiple (fire when 24h volume exceeds baseline by a multiple). Requires either slug or conditionId to identify the market (both returned by prediction.trending and prediction.search); optionally provide webhookUrl to receive POST payloads when conditions fire. Triggered alerts flow through alerts.check; use the returned watch ID with alerts.remove to stop monitoring. Does not place or cancel orders. Endpoint: https://syenite.ai/mcp
- prediction.position - Returns all open and recently resolved Polymarket positions for a given Polygon EOA address, including size in outcome shares, average entry price, current market price, realized and unrealized P&L in USDC, percentage P&L, and hours remaining until resolution for each market. Use this to audit an agent's prediction market exposure, calculate portfolio value, or identify positions that are redeemable. Requires a valid Polygon EVM address (0x-prefixed, 40 hex chars); read-only via Polymarket data API — no signing or wallet connection required. Does not place or cancel orders. Endpoint: https://syenite.ai/mcp
- prediction.quote - Simulates a Polymarket CLOB order fill by walking the live order book, computing average fill price, total cost in USDC, slippage from mid-price in percentage and basis points, and available book depth for a given size. Call this before prediction.order to validate that the book can absorb the desired position size at an acceptable price. Requires tokenId (from prediction.trending/search), side (buy or sell), outcome (YES or NO — informational label only), and size in shares; optionally pass orderType (market or limit) and limitPrice. Returns a partial-fill warning if the book cannot fully absorb the requested size, and a slippage warning if estimated slippage exceeds 5%. Polymarket CLOB currently charges zero maker and taker fees. Does not place an order. Endpoint: https://syenite.ai/mcp
- prediction.order - Constructs a Polymarket CLOB limit order payload ready for EIP-712 off-chain signing and submission to the Polymarket REST API. Polymarket uses off-chain order signing with on-chain settlement — this tool returns the EIP-712 typed-data (domain, types, message) that the agent must sign with its Polygon EOA private key, then POST to https://clob.polymarket.com/order with CLOB API authentication headers; it is not compatible with tx.simulate, tx.verify, or tx.receipt because no on-chain transaction is broadcast until settlement. Requires tokenId (from prediction.trending/search), side (buy or sell), outcome (YES or NO — label only), size (shares, positive), price (0–1 exclusive, USDC per share), and maker (Polygon EOA address); optionally pass expiration (unix seconds, 0 = GTC). Before the first order, the maker must approve the CTF Exchange contract to spend USDC on Polygon — the response includes approval details. Use prediction.quote first to validate fill price and available depth. Endpoint: https://syenite.ai/mcp
- kalshi.trending - Fetches the top open events on Kalshi ranked by recency, returning event titles, tickers, market questions, current YES/NO prices in cents, implied probability, volume in contracts, and liquidity. Kalshi is a US-regulated prediction market exchange — markets settle to $1 (YES) or $0 (NO). Use this as the starting point for Kalshi market discovery before calling kalshi.market, kalshi.book, or kalshi.signals. Optionally pass limit (1–50, default 25). Prices are in cents where 45¢ means ~45% implied probability of YES. Endpoint: https://syenite.ai/mcp
- kalshi.search - Searches open Kalshi events and markets by keyword, filtering against event titles, tickers, series names, and market subtitles. Use this when looking for a specific topic (elections, crypto price levels, economic data, sports). Requires query (search term); optionally pass limit (1–50, default 25). Returns tickers and market details needed for kalshi.market and kalshi.book. Note: Kalshi has no server-side text search — this filters a large fetch of open events client-side, so very rare topics may not appear. Endpoint: https://syenite.ai/mcp
- kalshi.book - Fetches the current order book for a specific Kalshi market by ticker, returning YES and NO bid levels with sizes in contracts, mid-price, spread in cents and basis points, and total depth on each side. Use this to assess execution quality before sizing a position — wide spreads indicate higher edge for makers. Requires ticker (e.g. "KXBTC-25DEC31-T100000"), obtained from kalshi.trending or kalshi.search. Kalshi prices are in cents (0–99); a YES bid at 45 means you pay 45¢ per contract to win $1 if YES resolves. Endpoint: https://syenite.ai/mcp
- kalshi.market - Provides a comprehensive deep-dive on a single Kalshi market by ticker, returning the question, current YES/NO prices in cents, implied probability, 24h and 7d price history stats (open, close, min, max, change), volume in contracts with approximate USD value, liquidity, order book depth, bid-ask spread, one-sided flow direction, resolution rules, and time remaining until close. Use this after kalshi.trending or kalshi.search to fully evaluate a market before taking a position. Requires ticker (e.g. "KXBTC-25DEC31-T100000"). Does not place orders. Endpoint: https://syenite.ai/mcp
- kalshi.signals - Scans open Kalshi events and returns ranked actionable signals across five categories: wide_spread (bid-ask gap above 4¢ with meaningful liquidity — market-making opportunity), extreme_probability (YES ask above 92¢ or below 8¢ with volume — contrarian or long-shot play), high_volume (volume_24h above 10,000 contracts — active price discovery), near_resolution (market closing within 48 hours — time-sensitive opportunity), and mispriced (mutually exclusive event markets don't sum to ~100¢ — arbitrage opportunity). Returns each signal with strength (0–100), affected market ticker, and a suggested action. Optionally filter by minStrength (0–100), types (array of signal type strings), and limit (default 20, max 50). Signals are heuristic — verify market fundamentals before trading. Endpoint: https://syenite.ai/mcp
- prediction.compare - Searches both Polymarket and Kalshi for the same underlying question and returns a side-by-side comparison of implied probabilities, volume, liquidity, and spread. Use this to see where a question is listed on each exchange, whether prices agree, and which venue has better liquidity. Requires query (the topic to search — e.g. "Trump tariffs", "Bitcoin 100k", "Fed rate cut"). Optionally pass minOverlapPct (0–100, default 20) to control how strictly market titles must match across exchanges — lower values return more speculative matches. Returns matched pairs ranked by match confidence, each showing normalized implied probability (pct) on both sides and the price gap in percentage points. Endpoint: https://syenite.ai/mcp
- prediction.arbitrage - Scans trending markets on both Polymarket and Kalshi simultaneously, matches markets covering the same underlying question, and surfaces pairs where implied probabilities diverge by more than a threshold. A divergence of 5pp or more suggests one exchange is mispriced or lagging. Returns pairs ranked by divergence, each showing the YES probability on each exchange, which side is higher, and the spread in percentage points. Optionally pass minDivergencePp (default 3) to filter only meaningful gaps, and limit (default 20, max 50). Note: cross-exchange arb requires accounts on both platforms and faces execution risk — prices may converge before orders fill. Endpoint: https://syenite.ai/mcp

## Resources
Not captured

## Prompts
- find-yield - Find the best yield opportunities for a given asset across DeFi protocols Arguments: asset
- market-overview - Get current DeFi lending market rates, TVL, and utilization across protocols
- check-position - Check health factor and liquidation risk for a lending position Arguments: address

## Metadata
- Owner: io.github.syenite-ai
- Version: 0.4.0
- Runtime: Npm
- Transports: STDIO, HTTP
- License: Not captured
- Language: Not captured
- Stars: Not captured
- Updated: Mar 18, 2026
- Source: https://registry.modelcontextprotocol.io