# Syenite (remote · syenite.ai)

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

- Trust score: 67/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `syenite.ai`: 67/100 (this document), [markdown](https://verifymcp.io/servers/syenite-ai-syenite/syenite.md), [page](https://verifymcp.io/servers/syenite-ai-syenite/syenite)
- npm · `@syenite/mcp`: 35/100, [markdown](https://verifymcp.io/servers/syenite-ai-syenite/syenite-mcp.md), [page](https://verifymcp.io/servers/syenite-ai-syenite/syenite-mcp)

## Channel facts

- Endpoint: `https://syenite.ai/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.4.0`

## Trust breakdown

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. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (lending.supply).
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 75/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 10579 tokens (~229/item across 46 items; 46 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 98% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

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

### Codex

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

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "syenite-ai-syenite": {
      "type": "remote",
      "url": "https://syenite.ai/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add syenite-ai-syenite --url https://syenite.ai/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  syenite-ai-syenite:
    url: "https://syenite.ai/mcp"
```

### Other

```json
{
  "mcpServers": {
    "syenite-ai-syenite": {
      "type": "http",
      "url": "https://syenite.ai/mcp"
    }
  }
}
```

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

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-01 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 65, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-28 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 63, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 63)

First indexed and scored.

## MCP tools (46)

### `syenite.help` (~89 tokens)

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.

Output parameters:

- `access` (object)
- `description` (string)
- `lendingProtocols` (array)
- `service` (string)
- `swapAndBridge` (object)
- `tools` (array)
- `website` (string)
- `yieldSources` (object)

### `lending.rates.query` (~317 tokens)

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.

Input parameters:

- `borrowAsset` (string): Asset to borrow: "USDC", "USDT", "DAI", "GHO"
- `chain` (string): Chain to query. Defaults to all supported chains.
- `collateral` (string): Collateral asset or category: "wBTC", "tBTC", "cbBTC", "WETH", "wstETH", "rETH", "cbETH", "weETH", "BTC", "ETH", or "all"

Output parameters:

- `bestBorrowRate`: Best rate found, or null if no markets match
- `markets` (array): All matching lending markets, sorted by borrow APY
- `note` (string)
- `query` (object)
- `timestamp` (string)

### `lending.market.overview` (~202 tokens)

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.

Input parameters:

- `chain` (string): Chain to query. Defaults to all supported chains.
- `collateral` (string): Filter by collateral asset, or "all"

Output parameters:

- `crossProtocol` (object)
- `protocols` (array)
- `query` (object)
- `timestamp` (string)

### `lending.position.monitor` (~227 tokens)

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.

Input parameters:

- `address` (string, required): EVM address to check (works on all supported chains)
- `chain` (string): Chain to query. Defaults to all supported chains.
- `protocol` (string): Protocol filter

Output parameters:

- `address` (string)
- `positionCount` (number)
- `positions` (array)
- `timestamp` (string)
- `warning` (string): Present when positions are approaching liquidation

### `lending.risk.assess` (~333 tokens)

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.

Input parameters:

- `borrowAsset` (string): Asset to borrow
- `collateral` (string, required): Collateral asset: "wBTC", "tBTC", "cbBTC", "WETH", "wstETH", "rETH", "cbETH", "weETH"
- `collateralAmount` (number, required): Amount of collateral
- `protocol` (string): Protocol preference
- `targetLTV` (number, required): Desired LTV percentage (1-99)

Output parameters:

- `alternativeMarkets` (array)
- `assessment` (object)
- `query` (object)
- `timestamp` (string)

### `yield.opportunities` (~405 tokens)

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.

Input parameters:

- `asset` (string): Asset to find yield for: "ETH", "USDC", "DAI", "WETH", "USDe", "stables", or "all"
- `category` (string): Yield category filter: "lending-supply", "liquid-staking", "vault", "savings-rate", "basis-capture", or "all"
- `riskTolerance` (string): Maximum risk level to show: "low", "medium", or "high" (default, shows all)
- `tags` (array): Tag filters: ["fixed-yield"] isolates Pendle PT; ["yt","leveraged-variable"] surfaces Pendle YT (hidden by default)

Output parameters:

- `note` (string)
- `opportunities` (array)
- `query` (object)
- `summary` (object)
- `timestamp` (string)

### `yield.assess` (~271 tokens)

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.

Input parameters:

- `amount` (number): Amount in USD to deposit (optional, enables position sizing analysis)
- `asset` (string): Asset context for finding alternatives
- `product` (string): Specific product name (optional, helps match the right source)
- `protocol` (string, required): Protocol to assess: "Aave", "Lido", "Morpho", "Ethena", "Yearn", "Maker", "Rocket Pool", "Coinbase"

Output parameters:

- `alternatives` (array)
- `projectedReturn` (object): Present when an amount was provided
- `query` (object)
- `riskAssessment` (object)
- `source` (object)
- `timestamp` (string)

### `swap.quote` (~445 tokens)

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.

Input parameters:

- `fromAddress` (string, required): Sender wallet address (used for routing and approval checks)
- `fromAmount` (string, required): Amount to swap in smallest unit (e.g. 1000000 for 1 USDC with 6 decimals). Use token decimals.
- `fromChain` (string): Source chain: "ethereum", "arbitrum", "optimism", "base", "polygon", "bsc", "avalanche", or chain ID
- `fromToken` (string, required): Token to sell — symbol (e.g. "USDC", "ETH") or contract address
- `order` (string): Route preference: CHEAPEST (best price) or FASTEST (lowest execution time)
- `slippage` (number): Max slippage as decimal (0.005 = 0.5%)
- `toAddress` (string): Recipient address (defaults to fromAddress)
- `toChain` (string): Destination chain (defaults to fromChain). Set differently for cross-chain bridges.
- `toToken` (string, required): Token to buy — symbol (e.g. "WETH", "USDT") or contract address

Output parameters:

- `approvalRequired` (object): Present when token approval is needed before the swap
- `costs` (object)
- `estimatedTime` (string)
- `execution` (object)
- `note` (string)
- `quote` (object)
- `route` (array): Ordered routing steps
- `summary` (string): Human-readable summary, e.g. '1.5 WETH → 3500 USDC'
- `tracking` (string): Present for cross-chain bridges — use swap.status to track
- `type` (string)
- `warnings` (array): Risk warnings (slippage, gas, cross-chain)

### `swap.status` (~176 tokens)

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.

Input parameters:

- `fromChain` (string): Chain where the transaction was submitted
- `toChain` (string): Destination chain (for cross-chain bridges)
- `txHash` (string, required): Transaction hash of the submitted swap/bridge

Output parameters:

- `amountReceived` (string): Present when transfer is complete
- `bridge` (string)
- `fromChain` (string)
- `message` (string): Human-readable status explanation
- `note` (string)
- `receivingTxHash` (string): Present when destination tx is confirmed
- `sendingTxHash` (string)
- `status` (string)
- `substatus` (string)
- `toChain` (string)

### `swap.multi` (~176 tokens)

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.

Input parameters:

- `requests` (array, required): Array of swap/bridge requests to quote in parallel

Output parameters:

- `failedCount` (number)
- `note` (string)
- `quotes` (array): Individual quote results — each has index, status, and full quote data or error
- `requestCount` (number)
- `successCount` (number)
- `timestamp` (string)
- `totalCosts` (object)

### `wallet.balances` (~195 tokens)

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.

Input parameters:

- `address` (string, required): EVM address to check
- `chains` (array): Chains to query (defaults to all: ethereum, arbitrum, base, bsc)

Output parameters:

- `address` (string)
- `balances` (array)
- `chainsQueried` (array)
- `hasAnyBalance` (boolean): True if any chain has a non-zero balance
- `note` (string)
- `timestamp` (string)

### `gas.estimate` (~245 tokens)

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.

Input parameters:

- `chains` (array): Chains to check (defaults to all)
- `operations` (array): Operation types to estimate: transfer, erc20_transfer, swap, bridge, erc20_approve, lending_supply, lending_borrow, contract_register

Output parameters:

- `availableOperations` (array)
- `chainsQueried` (array)
- `cheapestChain` (object): Cheapest chain for each operation type
- `estimates` (array)
- `note` (string)
- `solana` (object): Present when chains includes 'solana' — prioritization fees in µLamports/CU from getRecentPrioritizationFees
- `timestamp` (string)

### `tx.simulate` (~186 tokens)

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.

Input parameters:

- `chain` (string): Chain name or ID (defaults to tx chainId or ethereum)
- `transaction` (object, required)

Output parameters:

- `balanceChanges` (array)
- `chain` (string)
- `contractsCalled` (array)
- `detail` (string)
- `gasEstimateUSD` (string)
- `gasUsed` (number)
- `note` (string)
- `revertReason`: Present when simulation reverts
- `simulatedAtBlock` (number)
- `success` (boolean)
- `timestamp` (string)
- `verification` (string): How the simulation was performed — verifiable by any RPC node

### `tx.verify` (~251 tokens)

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.

Input parameters:

- `chain` (string, required): Chain name: ethereum, arbitrum, base, bsc
- `data` (string): Calldata — if provided, decodes the function being called
- `to` (string, required): Contract address to verify

Output parameters:

- `address` (string)
- `chain` (string)
- `functionCalled`
- `isContract` (boolean)
- `note` (string)
- `protocol` (object)
- `riskFlagCount` (number)
- `riskFlags` (array)
- `summary` (string)
- `timestamp` (string)
- `verification` (object)

### `tx.guard` (~210 tokens)

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.

Input parameters:

- `chain` (string): Chain name (defaults to ethereum)
- `rules` (object, required)
- `transaction` (object, required)

Output parameters:

- `approved` (boolean)
- `chain` (string)
- `checks` (array)
- `failedCount` (number)
- `note` (string)
- `passedCount` (number)
- `skippedCount` (number)
- `summary` (string)
- `timestamp` (string)

### `strategy.carry.screen` (~306 tokens)

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.

Input parameters:

- `borrowAsset` (string): Borrow asset
- `chain` (string): Chain filter
- `collateral` (string): Collateral filter: specific asset, "BTC", "ETH", or "all"
- `minCarry` (number): Minimum net carry % to include (e.g. 0 for positive-only)
- `positionSizeUSD` (number): Position size in USD for annual return calculation

Output parameters:

- `note` (string)
- `query` (object)
- `strategies` (array)
- `summary` (object)
- `timestamp` (string)

### `prediction.trending` (~149 tokens)

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.

Input parameters:

- `limit` (number): Number of trending markets to return (max 25)

Output parameters:

- `eventCount` (number)
- `events` (array)
- `note` (string)
- `source` (string)
- `timestamp` (string)

### `prediction.search` (~148 tokens)

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.

Input parameters:

- `limit` (number): Maximum results to return
- `query` (string, required): Search query (e.g. 'Bitcoin price', 'US election', 'Fed rate')

Output parameters:

- `events` (array)
- `query` (string)
- `resultCount` (number)
- `source` (string)
- `timestamp` (string)

### `prediction.book` (~140 tokens)

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.

Input parameters:

- `tokenId` (string, required): Polymarket outcome token ID (from prediction.trending or prediction.search results)

Output parameters:

- `askDepthUSD` (number)
- `asks` (array)
- `bidDepthUSD` (number)
- `bids` (array)
- `error` (string)
- `midPrice` (number)
- `note` (string)
- `spread` (number)
- `spreadBps` (number): Spread in basis points
- `timestamp` (string)
- `tokenId` (string)

### `prediction.signals` (~233 tokens)

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.

Input parameters:

- `limit` (number): Maximum signals to return
- `minStrength` (number): Minimum signal strength (0-100) to include
- `types` (array): Filter to specific signal types (defaults to all)

Output parameters:

- `marketsScanned` (number)
- `note` (string)
- `signalCount` (number)
- `signalTypes` (object): Legend: signal type → description
- `signals` (array): Ranked signals — each has type, strength, market, question, action, and signal-specific data
- `source` (string)
- `timestamp` (string)
- `typeCounts` (object)

### `find.strategy` (~312 tokens)

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.

Input parameters:

- `amount` (number): Amount in USD to deploy (for return calculations)
- `asset` (string, required): Asset you have or want to deploy: "ETH", "WETH", "wBTC", "USDC", "USDT", etc.
- `chain` (string): Chain preference
- `includePrediction` (boolean): Include prediction market signals in strategy search
- `riskTolerance` (string): Maximum risk level: low (yield only), medium (carry + arb), high (leverage + prediction)

Output parameters:

- `note` (string)
- `query` (object)
- `strategies` (array)
- `summary` (object)
- `timestamp` (string)

### `lending.supply` (~290 tokens)

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.

Input parameters:

- `amount` (string, required): Amount in human-readable units (e.g. '1000' for 1000 USDC)
- `asset` (string, required): Token to supply: "USDC", "WETH", "wBTC", "tBTC", "DAI", etc.
- `chain` (string): Chain where the pool lives
- `onBehalfOf` (string, required): Address that will receive the aToken (usually your own address)
- `protocol` (string): Lending protocol

Output parameters:

- `action` (string)
- `amount` (string)
- `amountWei` (string)
- `approvalRequired`: Present when token approval is required before the action
- `asset` (string)
- `chain` (string)
- `execution` (object)
- `note` (string)
- `pool` (string)
- `protocol` (string)
- `verification` (string)

### `lending.borrow` (~202 tokens)

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.

Input parameters:

- `amount` (string, required): Borrow amount in human-readable units
- `asset` (string, required): Asset to borrow: "USDC", "USDT", "DAI", "GHO"
- `chain` (string): Chain
- `onBehalfOf` (string, required): Address with collateral deposited
- `protocol` (string): Lending protocol

Output parameters:

- `action` (string)
- `amount` (string)
- `amountWei` (string)
- `asset` (string)
- `chain` (string)
- `execution` (object)
- `interestRateMode` (string)
- `note` (string)
- `pool` (string)
- `protocol` (string)
- `verification` (string)

### `lending.withdraw` (~179 tokens)

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.

Input parameters:

- `amount` (string, required): Amount in human-readable units, or "max" to withdraw all
- `asset` (string, required): Asset to withdraw
- `chain` (string): Chain
- `protocol` (string): Lending protocol
- `to` (string, required): Recipient address for withdrawn tokens

Output parameters:

- `action` (string)
- `amount` (string)
- `asset` (string)
- `chain` (string)
- `execution` (object)
- `note` (string)
- `pool` (string)
- `protocol` (string)
- `verification` (string)

### `lending.repay` (~202 tokens)

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.

Input parameters:

- `amount` (string, required): Repay amount in human-readable units, or "max" for full repayment
- `asset` (string, required): Asset to repay
- `chain` (string): Chain
- `onBehalfOf` (string, required): Address whose debt to repay
- `protocol` (string): Lending protocol

Output parameters:

- `action` (string)
- `amount` (string)
- `amountWei` (string)
- `approvalRequired`: Present when token approval is required before the action
- `asset` (string)
- `chain` (string)
- `execution` (object)
- `interestRateMode` (string)
- `note` (string)
- `pool` (string)
- `protocol` (string)
- `verification` (string)

### `tx.receipt` (~199 tokens)

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.

Input parameters:

- `chain` (string): Chain: ethereum, arbitrum, base, bsc (or chain ID)
- `txHash` (string, required): Transaction hash to look up

Output parameters:

- `blockNumber` (number)
- `chain` (string)
- `contractsInteracted` (array)
- `explorerUrl` (string)
- `from` (string)
- `gas` (object)
- `logs` (object)
- `nonce`
- `note` (string)
- `status` (string)
- `success` (boolean)
- `timestamp` (string)
- `to` (string)
- `tokenTransfers` (array): ERC-20 Transfer events decoded from logs
- `txHash` (string)
- `value` (string)

### `token.price` (~223 tokens)

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.

Input parameters:

- `symbol` (string): Token symbol (e.g. wBTC, WETH, USDC). Ignored when symbols is provided.
- `symbols` (array): Batch: array of token symbols to price in one call (up to 20)

Output parameters:

- `errors` (array): Present when some symbols failed to resolve
- `prices` (array)
- `source` (string)
- `supportedTokens` (array): All token symbols with Chainlink feeds
- `timestamp` (string)

### `alerts.watch` (~622 tokens)

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.

Input parameters:

- `address` (string): EVM address to monitor (lending watches)
- `carryBorrowAsset` (string): Asset you borrow, e.g. USDC (carry)
- `carryCollateral` (string): Collateral you post to borrow, e.g. wBTC (carry)
- `carrySupplyAsset` (string): Asset you supply — defaults to carryBorrowAsset (carry)
- `carryThreshold` (number): Minimum net spread % to fire carry_opportunity (carry)
- `chain` (string): Chain filter (lending)
- `healthFactorThreshold` (number): Alert threshold (lending, default 1.5)
- `protocol` (string): Protocol filter (lending)
- `rateBorrowAsset` (string): Borrow asset, e.g. USDC (rate, default USDC)
- `rateBorrowThreshold` (number): Borrow APY % threshold (rate)
- `rateChain` (string): Chain filter (rate)
- `rateCollateral` (string): Collateral asset, e.g. wBTC (rate)
- `rateDirection` (string): APY threshold direction (rate, default above)
- `rateProtocol` (string): Protocol filter (rate)
- `rateSupplyThreshold` (number): Supply APY % threshold (rate)
- `rateUtilizationThreshold` (number): Utilization % threshold — fires rate_utilization; critical at ≥95% (rate)
- `type` (string): Watch type: lending (health factor), rate (APY/utilization), carry (net spread), yield (best APY)
- `webhookUrl` (string): HTTP(S) URL to POST alerts to in real-time
- `yieldApyThreshold` (number): APY % threshold (yield)
- `yieldAsset` (string): Asset to watch, e.g. ETH, USDC, stables (yield)
- `yieldChains` (array): Chains to include (yield)
- `yieldDirection` (string): APY threshold direction (yield, default above)
- `yieldRisk` (string): Max risk level (yield)

Output parameters:

- `message` (string)
- `usage` (string)
- `watch` (object)

### `alerts.check` (~147 tokens)

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.

Input parameters:

- `acknowledge` (boolean): Mark returned alerts as acknowledged
- `watchId` (string): Filter alerts for a specific watch ID

Output parameters:

- `alertCount` (number)
- `alerts` (array)
- `critical` (number)
- `timestamp` (string)
- `warnings` (number)

### `alerts.list` (~79 tokens)

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.

Output parameters:

- `timestamp` (string)
- `watchCount` (number)
- `watches` (array)

### `rates.watch` (~421 tokens)

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.

Input parameters:

- `carryBorrowAsset` (string): Asset you borrow, e.g. USDC (carry mode)
- `carryCollateral` (string): Collateral you post to borrow, e.g. wBTC (carry mode)
- `carrySupplyAsset` (string): Asset you supply/lend — defaults to carryBorrowAsset (carry mode)
- `carryThreshold` (number): Minimum net spread % to fire carry_opportunity alert (carry mode)
- `mode` (string, required): rate: APY/utilization threshold; carry: net spread between best supply and cheapest borrow
- `rateBorrowAsset` (string): Borrow asset, e.g. USDC, USDT (rate mode, default USDC)
- `rateBorrowThreshold` (number): Borrow APY % to fire at (rate mode)
- `rateChain` (string): Limit to a specific chain (rate mode, default all)
- `rateCollateral` (string): Collateral asset, e.g. wBTC, ETH (rate mode)
- `rateDirection` (string): Direction for APY threshold (default above)
- `rateProtocol` (string): Limit to a specific protocol (rate mode, default all)
- `rateSupplyThreshold` (number): Supply APY % to fire at (rate mode)
- `rateUtilizationThreshold` (number): Utilization % to fire rate_utilization alert at (rate mode). Critical severity at ≥95%.
- `webhookUrl` (string): HTTP(S) URL to POST alerts to in real-time

Output parameters:

- `message` (string)
- `usage` (string)
- `watch` (object)

### `alerts.remove` (~91 tokens)

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.

Input parameters:

- `watchId` (string, required): ID of the watch to remove

Output parameters:

- `message` (string)
- `success` (boolean)

### `metamorpho.supply` (~264 tokens)

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.

Input parameters:

- `amount` (string, required): Amount to deposit in human units (e.g. '1000' for 1000 USDC)
- `receiver` (string, required): Address that receives the vault shares
- `vault` (string, required): Target MetaMorpho vault — address (0x...) or name fragment (e.g. "Steakhouse USDC")

Output parameters:

- `amount` (object)
- `approvalRequired` (object)
- `chain` (string)
- `note` (string)
- `product` (string)
- `protocol` (string)
- `timestamp` (string)
- `transactionRequest` (object)
- `vault` (object)

### `metamorpho.withdraw` (~212 tokens)

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.

Input parameters:

- `owner` (string, required): Owner of the shares (must have authorized the caller if different)
- `receiver` (string, required): Address that receives the withdrawn underlying
- `shares` (string, required): Share amount in human units, or 'max' to redeem all
- `vault` (string, required): MetaMorpho vault — address or name fragment

Output parameters:

- `chain` (string)
- `note` (string)
- `product` (string)
- `protocol` (string)
- `shares` (object)
- `timestamp` (string)
- `transactionRequest` (object)
- `vault` (object)

### `prediction.market` (~190 tokens)

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.

Input parameters:

- `conditionId` (string): Polymarket condition ID (0x-prefixed)
- `marketId` (string): Polymarket market ID
- `slug` (string): Polymarket market slug

Output parameters:

- `error` (string)
- `fairValue` (object)
- `identifier` (string): Present when the market was not found
- `impliedProbabilityPct`
- `liquidity` (object)
- `market` (object)
- `note` (string)
- `oddsHistory` (object)
- `source` (string)
- `timestamp` (string)
- `volume` (object)

### `prediction.watch` (~226 tokens)

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.

Input parameters:

- `conditionId` (string): Polymarket condition ID
- `conditions` (object, required): At least one condition required
- `slug` (string): Polymarket market slug
- `webhookUrl` (string): Optional HTTPS webhook for alert delivery

Output parameters:

- `message` (string)
- `usage` (string)
- `watch` (object)

### `prediction.position` (~145 tokens)

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.

Input parameters:

- `address` (string, required): Polygon EOA address holding Polymarket positions

Output parameters:

- `address` (string)
- `note` (string)
- `positions` (array)
- `source` (string)
- `summary` (object)
- `timestamp` (string)

### `prediction.quote` (~263 tokens)

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.

Input parameters:

- `limitPrice` (number): Required for limit orders (USDC per share)
- `orderType` (string): Order type: market fills immediately, limit rests in the book
- `outcome` (string, required): Informational — used for display only
- `side` (string, required): Direction: buy to open a position, sell to close
- `size` (number, required): Order size in shares
- `tokenId` (string, required): Polymarket outcome token ID

Output parameters:

- `avgFillPrice` (number)
- `depthAvailable` (number)
- `error` (string)
- `expectedFill` (object)
- `fees` (object)
- `limitCheck`
- `midPrice` (number)
- `note` (string)
- `orderType` (string)
- `outcome` (string)
- `side` (string)
- `size` (number)
- `slippageBps` (number)
- `slippagePct` (number)
- `timestamp` (string)
- `tokenId` (string)
- `warnings` (array)

### `prediction.order` (~333 tokens)

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.

Input parameters:

- `expiration` (number): Unix seconds (0 = GTC, default)
- `maker` (string, required): Polygon EOA that will sign the EIP-712 order
- `outcome` (string, required): Outcome token side (YES or NO)
- `price` (number, required): Limit price in USDC per share (0-1)
- `side` (string, required): Direction: buy to open, sell to close
- `size` (number, required): Shares
- `tokenId` (string, required): Polymarket outcome token ID

Output parameters:

- `approvalRequired` (object)
- `mode` (string)
- `notice` (string)
- `order` (object)
- `source` (string)
- `submission` (object)
- `timestamp` (string)
- `typedData` (object)

### `kalshi.trending` (~154 tokens)

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.

Input parameters:

- `limit` (integer): Number of events to return (default 25, max 50)

Output parameters:

- `eventCount` (number)
- `events` (array)
- `note` (string)
- `source` (string)
- `timestamp` (string)

### `kalshi.search` (~152 tokens)

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.

Input parameters:

- `limit` (integer): Max results (default 25, max 50)
- `query` (string, required): Search term (topic, ticker, or keyword)

Output parameters:

- `events` (array)
- `query` (string)
- `resultCount` (number)
- `source` (string)
- `timestamp` (string)

### `kalshi.book` (~157 tokens)

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.

Input parameters:

- `ticker` (string, required): Market ticker (e.g. "KXBTC-25DEC31-T100000")

Output parameters:

- `error` (string)
- `impliedProbabilityPct` (number)
- `noAsks` (array)
- `note` (string)
- `spreadBps` (number)
- `spreadCents` (number)
- `ticker` (string)
- `timestamp` (string)
- `yesAskDepthContracts` (number)
- `yesBidDepthContracts` (number)
- `yesBids` (array)
- `yesMidCents` (number)

### `kalshi.market` (~161 tokens)

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.

Input parameters:

- `ticker` (string, required): Market ticker (e.g. "KXBTC-25DEC31-T100000")

Output parameters:

- `error` (string)
- `liquidity` (object)
- `market` (object)
- `note` (string)
- `priceHistory` (object)
- `siblings` (array)
- `source` (string)
- `ticker` (string): Present when the market was not found
- `timestamp` (string)
- `volume` (object)

### `kalshi.signals` (~247 tokens)

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.

Input parameters:

- `limit` (integer): Max signals to return (default 20, max 50)
- `minStrength` (number): Minimum signal strength to include (0–100, default 0)
- `types` (array): Filter by signal type: wide_spread, extreme_probability, high_volume, near_resolution, mispriced

Output parameters:

- `marketsScanned` (number)
- `note` (string)
- `signalCount` (number)
- `signalTypes` (object)
- `signals` (array)
- `source` (string)
- `timestamp` (string)
- `typeCounts` (object)

### `prediction.compare` (~216 tokens)

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.

Input parameters:

- `minOverlapPct` (number): Minimum keyword overlap to count as a match (0–100, default 20). Lower = more speculative matches.
- `query` (string, required): Topic to search on both Polymarket and Kalshi (e.g. 'Trump tariffs', 'Bitcoin 100k', 'Fed rate cut')

Output parameters:

- `kalshiMarketsFound` (number)
- `matchedPairs` (number)
- `note` (string)
- `pairs` (array)
- `polymarketsFound` (number)
- `query` (string)
- `timestamp` (string)
- `unmatchedMarkets` (array)

### `prediction.arbitrage` (~188 tokens)

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.

Input parameters:

- `limit` (integer): Max opportunities to return (default 20, max 50)
- `minDivergencePp` (number): Minimum probability divergence in percentage points to surface (default 3)

Output parameters:

- `arbOpportunities` (number)
- `marketsScanned` (object)
- `minDivergencePp` (number)
- `note` (string)
- `opportunities` (array)
- `timestamp` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/syenite-ai-syenite/syenite#diagnostics

## Score history

- 2026-08-03: 67
- 2026-08-02: 66
- 2026-08-01: 66
- 2026-07-31: 65
- 2026-07-30: 65
- 2026-07-29: 65
- 2026-07-28: 64
- 2026-07-27: 63
- 2026-07-26: 63

## Links

- Remote endpoint: https://syenite.ai/mcp
- Repository: https://github.com/syenite-ai/syenite
- Changelog RSS feed: https://verifymcp.io/servers/syenite-ai-syenite/syenite/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/syenite-ai-syenite/syenite/changelog.json
- HTML version of this page: https://verifymcp.io/servers/syenite-ai-syenite/syenite