Syenite MCP Server

by syenite-ai Your server? Claim it

not responding

Syenite is listed as active in the registry but did not answer our last check. 30 installs a week from npm. It exposes 46 tools. Last commit 6 Aug 2026.

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

Installs per day peak 9 · avg 2 · +30% w/w

a month agotoday

Uptime history 91 days of history · worst day 0%

91 days agonow

0.0%

Uptime 24h

0 of 91 checks

Tools

read from the server

25 ms

Response time

average over 24h

Installs / week

npm and PyPI

What the code does

We read the source, 3 d ago · tools taken from the live server · rules 995398eba69f

Capabilities

What this server is able to do. For an MCP server this is often the job itself — a terminal server runs commands because that is what it is for. Listed so you know what you are plugging in, not as an accusation.

Builds a file path from a variable mcp/src/web/docs.ts:44

  const filePath = path.join(DOCS_DIR, name);

In the project's build, not in the package

Found in continuous integration, deployment or infrastructure files, or in a neighbouring package of the same monorepo. None of this is installed when you add the server: it describes how the project is built and released. We list it because a leaked key in a build pipeline is still a real problem, but it is not something this server does on your machine.

Image downloads and pipes straight to shell .devcontainer/Dockerfile:39

RUN curl -L https://foundry.paradigm.xyz | bash && \

Image runs as root .devcontainer/Dockerfile:91

USER root

Is this your server and something here is wrong? Tell us — corrections are free and do not require a plan.

This code can reach further than it looks

We found places where it runs commands, builds paths or queries from values it is given. None of that is a flaw by itself — it becomes one when the code changes, and code changes quietly between releases. We re-read it on every one.

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 1 min ago.

Claude Code Claude Desktop Codex Cursor VS Code

run in your terminal

claude mcp add syenite --transport http https://syenite.ai/mcp

Settings → Connectors → Add custom connector, then paste this address

https://syenite.ai/mcp

~/.codex/config.toml

[mcp_servers.syenite]
url = "https://syenite.ai/mcp"

.cursor/mcp.json

{
  "mcpServers": {
    "syenite": {
      "url": "https://syenite.ai/mcp"
    }
  }
}

.vscode/mcp.json

{
  "servers": {
    "syenite": {
      "type": "http",
      "url": "https://syenite.ai/mcp"
    }
  }
}

Available tools 46

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

prediction

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

lending

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.

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.

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.

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.

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.

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.

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.

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.

kalshi

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.

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.

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.

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.

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.

alerts

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.

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.

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.

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.

swap

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.

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.

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.

metamorpho

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.

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.

strategy

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.

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.

yield

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.

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.

gas

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.

guard

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.

rates

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.

receipt

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.

simulate

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.

syenite

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.

token

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.

verify

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.

wallet

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.

Endpoints

URL	Transport	State	Latency	Checked
https://syenite.ai/mcp	streamable-http	answering	25 ms	1 min ago

Alternatives to Syenite

same job, measured the same way

Haiku DeFi MCP

by haiku-trading

DeFi execution for AI agents — swap, lend, bridge, and yield across 22 chains.

88 installs/wk local only

Sharphy

by baharmaulidiii

CLR Intelligence and Runtime Forensic Bridge for AI Coding Agents.

local only

HiveBank

by srotzin

USDC treasury vaults, streaming payments, and DeFi yield for AI agents

5 tools answering

Bitcompare

by bitcompare

Crypto yield data for AI agents: lending, savings, staking, borrowing & stablecoin rates. 18 tools.

73 installs/wk 21 tools answering

Cookie MCP

by cookiechain

Cookie Chain tools for AI agents: swap, launch, liquidity, staking, NFTs, and a Solana bridge.

239 installs/wk local only

web3agent

by apegurus

Web3 MCP proxy for AI agents: DeFi swaps, bridges, market data, wallets, and gated writes.

86 installs/wk local only

FastestRank SEO Intelligence

by fastestrank

Live SEO intelligence, rank tracking, site audits, and backlink analysis for AI agents.

answering

Constellation

by shiftinbits

Code Intelligence Platform for AI Coding Agents

184 installs/wk local only

Syenite — questions

Answers built from our own checks of this server.

What can Syenite do?

It exposes 46 tools, read directly from the server on our last check. Among them: alerts.check, alerts.list, alerts.remove, alerts.watch, find.strategy, gas.estimate and 40 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →

What is Syenite mostly used for?

Its tools cluster around prediction, lending and kalshi. That is what this server is built to work with — the grouping comes from the actual tool names, not from a category we assigned.

Is Syenite working right now?

We send a real MCP handshake every 15 minutes. Over the last 24 hours 0 of 91 checks got a reply (0.0%), average response time 25 ms. The bar chart above shows every period we have measured.

The registry lists Syenite as active — why does it not respond?

The official MCP registry stores what the author submitted; it does not verify that the server still runs. We check the endpoint ourselves, and this one does not answer. Catalogues that copy the registry without checking will show it as working.

How do I connect Syenite?

Copy the ready config from this page. We generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each in the form that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.

Does Syenite need an API key?

No. Syenite completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 46 of them are readable on this page. This is what we observed, not what the docs claim.

How many people use Syenite?

The npm package @syenite/mcp was installed 30 times in the last week. Week over week that is +30%. We show installs rather than GitHub stars on purpose: a star is a bookmark, an install is someone actually running it.

Is Syenite open source?

The code is open source: it is published under the MIT licence, written in TypeScript and 0 stars on GitHub. The licence covers the code in the repository, not the hosted service at syenite.ai, which runs on its operator's own terms.