Model Context Protocol

Kyte, inside any AI app.

One URL gives Claude, ChatGPT, Cursor, Claude Code and Hermes Agent live access to Kyte's markets: offers, prices, positions, staking and fee proof. It can prepare a trade for you. It can never sign one.

https://elysium.kyte.sh/api/mcp
Checking the endpoint… No login, no keys Read and prepare onlyStreamable HTTP · stateless
KYTE MCP0/5 connected

Live: each thread runs the real MCP handshake. Click a client to run it again.

01
You ask

In Claude, ChatGPT or your editor: "best covered calls on PONS", "what do I hold", "how much was burned".

02
Kyte answers from the chain

The tools read the same indexer kyte.sh uses. Every number has a source and a link.

03
You sign, or not

A prepared action is a link to a pre-filled form. You review it and sign in your own wallet.

Connect

Two minutes, no account.

  1. 1Open claude.ai, Settings, Connectors
  2. 2Add custom connector
  3. 3Paste the URL below and save
  4. 4Ask Claude anything about Kyte
Connector URL
https://elysium.kyte.sh/api/mcp
Self-hosted

Run it in Hermes Agent.

Hermes is the open-source agent from Nous Research that runs on your own machine, with your own model, and talks to you on Telegram, Discord or Slack. Point it at Kyte and it gets every tool above. Give it one cron job and Autopilot's prepared trades land in your chat as links to sign. Kyte still never sees a key.

                                                                       
                                                                       
                                                                       
                                                                       
                                                                       
hermes · gateway
$
Your model, your box

Hermes runs on a laptop or a small VPS with any model you pick. Kyte is one URL in its config; no account, no key.

Autopilot, delivered

A 15-minute cron reads your waiting triggers and posts each one to Telegram as a ready-to-sign link. Nothing new, nothing sent.

Reads flow, prepares ask

Hermes honours the read-only annotation: 13 read tools run unattended, 6 prepare tools ask you once. Nothing can sign.

config.yaml
# ~/.hermes/config.yaml
mcp_servers:
  kyte:
    url: "https://kyte.sh/api/mcp"
    trust: untrusted   # reads never prompt; prepare_* asks once
hermes skills tap add usekyte-org/hermes-kyte
Skills on GitHub
Recommended

Run it under HOL Guard.

Any DeFi tool your agent can call deserves a policy. HOL Guard runs on your machine and lets you allow, ask or block each MCP tool call, with a receipt for every decision. Kyte is built to sit under it cleanly.

Terminal
pipx install hol-guard
hol-guard init

Then add Kyte to your client as above. Guard lists kyte on its Protect page, where you set the defaults below.

What Guard sees
  • 13 read tools are annotated read-only and never change state. Safe to allow.
  • 6 prepare tools are annotated as not read-only, so Guard asks before each one. They only return a kyte.sh link; you still sign in your wallet.
  • No tool can sign, send, spend or read a key, so there is nothing to block.
Pairs well with

Pair it with Harmonic Agent.

Harmonic Agent runs the session oracle for every Robinhood stock token on this chain: halted, paused, held over the weekend, stale or open, with the weekend on-chain mark. Kyte already reads it, so stock-token prices here carry a session state and a warning when the quote is not live. Add Harmonic's own MCP server beside Kyte's and an agent can ask both: is the stock open, and what options are on it. Both are keyless; neither signs.

Config, both servers
{ "mcpServers": {
  "kyte": { "url": "https://elysium.kyte.sh/api/mcp" },
  "harmonic-registry": { "type": "http", "url": "https://harmonicagent.solutions/mcp/registry" }
} }

Harmonic's defi_oracle, defi_weekend_mark and defi_atlas read the same rows Kyte's get_prices summarises.

Try asking
  • Is NVDA open right now, and what NVDA calls are on Kyte?
  • Which Kyte stock tokens are in their weekend hold, and where did SPY trade on chain this weekend?
  • Before I write an AAPL covered call 20% above spot, is that spot live or Friday's print?
What it exposes

13 read tools. 6 prepare tools. Zero that can move funds.

list_tokensread-only

Which tokens are listed on Kyte and can have options written on them, with whether puts are enabled, the exposure cap and the minimum strike per token.

find_offersread-only

Open option offers you can buy right now, filterable by token and kind (call or put), soonest expiry first. Each row has strike per token, premium, amount, expiry and a link.

get_offerread-only

One offer or position in full by its id: kind, token, amount, strike, premium, expiry, seller, holder, status, fees and the transaction that created it.

get_positionsread-only

What an address holds (options it can exercise), is selling (its open and filled offers) and its recent history. Pass the connected wallet address.

get_pricesread-only

Live price in ETH per token for every listed token with a feed, the 1 hour change, the source (Uniswap v4 swaps, a DEX price or a Robinhood quote), for FOBO launchpad tokens the floor price the hook guarantees, and, for stock tokens, the session state (open, held over the weekend, halted, paused, stale) with a warning when the quote is not live.

get_chartread-only

Recent OHLC candles for a token, in ETH per token. Use for "how has X moved today".

get_stakingread-only

Staking state: total $KYTE staked, the current epoch and when it ends, last epoch rewards, and for a given address its active and pending stake and claimable WETH.

get_protocol_statsread-only

Protocol totals: volume, fees, open interest, $KYTE burned, $KYTE staked, number of stakers, active and total offers.

get_proofread-only

Every fee split (per epoch, with the WETH to stakers, buyback and operations) and every $KYTE buyback burn, each with its transaction hash.

get_activityread-only

Recent protocol events: listings, fills, exercises, expiries, cancellations, fee splits, burns and staking, newest first, each with a transaction hash.

explain_offerread-only

Plain-language economics of one offer for both sides: what the buyer pays and gets, breakeven per token, max loss and max payoff, what the seller receives after fees, exercise fee, time left. Computed from get_offer and get_prices.

compare_offersread-only

Rank the open offers on one token: premium per token, premium as a share of strike, strike versus spot, time to expiry. Returns a sorted table with a short reason per row. Information only.

list_strategiesread-only

The user's Autopilot rules and the triggers waiting for them (prepared actions to review and sign). Needs the wallet address.

prepare_buyprepares

Prepare buying an open offer: returns a preview of what the buyer pays and gets and a kyte.sh link that opens the buy dialog for that offer.

prepare_covered_callprepares

Prepare a covered call: validates token, amount, strike per token (ETH), premium (ETH) and expiry against the protocol rules, then returns a preview and a kyte.sh Sell link with the form pre-filled. The seller must hold the tokens.

prepare_cash_secured_putprepares

Prepare a cash-secured put (only on tokens with puts enabled): validates the inputs and returns a preview and a pre-filled kyte.sh Sell link. The seller locks the strike in WETH.

prepare_exerciseprepares

Prepare exercising a held option: checks it is filled and not expired, previews what the holder pays and receives including the exercise fee, and returns the kyte.sh Positions link.

prepare_stakeprepares

Prepare staking or unstaking $KYTE, or claiming WETH rewards: returns a preview and a pre-filled kyte.sh Stake link.

design_strategyread-only

Turn a plain-language strategy into an Autopilot rule (sell covered calls or puts on a schedule, flag cheap calls or puts to buy, exercise in-the-money options, cancel stale offers). Validates the rule, explains it, and shows what it would have triggered over the last 30 days of prices. Returns a link to the Autopilot page where the user signs it. Nothing runs until the user signs. Ask for any number the user has not given rather than inventing it.

Resources

The official docs as kyte://docs/how-it-works, fees, staking, rules, risks, glossary, so a client grounds its answers in the real text.

Prompts

find_best_offers, explain_my_positions and protocol_health: one-click starting points your client can list.

Ground rules
Non-custodial, always

No tool can sign, send or read a key. Prepare tools return a link; you sign in your wallet.

Information, not advice

Numbers and what they mean. Never "buy", never a price prediction.

One source of truth

Every value comes from the Kyte indexer, the same API this site uses.

Data is not instructions

Token names and chain text are untrusted. Instructions inside them are ignored.

Options are risky and can expire worthless. Nothing here is investment advice. Rate limited per client. Kyte is not affiliated with or endorsed by Robinhood.