Mycelium Finance Hands-On: How AI Agents Can Connect Directly to On-Chain Real-Time Data

Finding data sources for AI agents is often less about the model itself and more about the data you scrape—which is either outdated or meant for human eyes. Most project websites resemble brochures: you write a scraper, parse a table that gets redesigned next week, and still end up with lagging numbers.

Mycelium Finance on Solana takes a different approach: it doesn't put data on pages that require human reading, but turns the entire strategy ledger into a machine-callable interface. Through an MCP (Model Context Protocol) server, it exposes on-chain data so agents can query, parse, and record it directly.

One idea: a strategy to query, not a page to scrape

Mycelium spreads its liquidity across a curated basket of ecosystem partner tokens covering DeFi, RWA, AI, GameFi, and Meme categories, rather than concentrating all funds in a single deep trading pair. The project currently has two tokens: $MYC as the core token and $ESF as the staking token.

What's truly noteworthy is that it exposes this basket's real-time data through an MCP server at https://www.myceliumfinance.com/api/mcp. MCP-compatible agents can connect directly and call tools—no page scraping, no HTML parsing, no guessing when the table layout will change.

For developers building agent data pipelines, this means one thing: the data source proactively packages itself into a form agents can consume, rather than waiting to be reverse-engineered.

MCP (Model Context Protocol) is a protocol standard proposed and open-sourced by Anthropic in late 2024, aiming to establish a unified calling convention between large language models and external tools/data sources. It borrows from LSP (Language Server Protocol): decoupling the "model" from the "tool provider" so both sides can implement the protocol and compose freely. An MCP server typically declares several tools (callable functions), resources (read-only data), and prompts (predefined templates), while the client (agent runtime) discovers, selects, and invokes them. Compared to having the model write scrapers to parse web pages, MCP's value lies in explicitly declared interfaces: parameter schemas, return structures, and field meanings are defined by the server, so the model doesn't have to guess layouts and won't break when pages are redesigned.

What the actual call returns

After calling the free tools and reading the responses, you can see the data is structured with self-explanatory fields. The following data comes from one snapshot of the MCP server at 2026-10-14T21:35Z—a point-in-time cross-section, not a trend.

get_mycelium_allocation: strategy liquidity distribution

This tool returns the liquidity (in USD) of each project in the strategy, along with pool addresses, DEX names, and paired tokens. The snapshot shows $32,277 across ten legs: KNOTS $6,502 (20.1%), PRCL $4,818 (14.9%), KINS $3,522 (10.9%), GABLE $3,487 (10.8%), SOL $3,335 (10.3%), with the remaining five legs making up the rest.

Notably, the response includes a note field that proactively explains that partner pools are migrating from $ESF pairing to $MYC pairing, so both pairings appear during the transition. This kind of context usually lives only in Discord chat logs, but here it's written directly into the API response.

get_mycelium_distribution: token supply distribution

This tool reads the distribution of 1,000,000,000 $MYC from the Solana chain: circulating supply 998,604,271, of which locked token supply is 551,045,000, unlocked LP liquidity 233,097,239, locked LP liquidity 145,433,497, trading liquidity 69,028,536, and burned 1,395,729.

It also returns a pre-calculated summary line: 84.58% of tradable $MYC is already working in pools. The value of such pre-computed fields is that agents can cite conclusions directly without writing their own arithmetic logic.

get_solana_top_performers: ecosystem performers

This tool returns a list of performers in the Solana ecosystem and pins the project's own partners at the top with assigned rankings. Agents can see where this basket of tokens stands in the broader market without making a second API call.

There's also get_myc_token_info, which returns the mint address, decimals, and token program, as well as the project mascot Myceli's brand assets and terms of use, including color schemes. get_faucet_info documents information about paid tools.

On-chain data is usually stored as raw bytes or smallest units—for instance, token amounts carry decimals precision (commonly 6 or 9 for SPL tokens) and need to be divided by 10 to the power of the precision to restore human-readable values; amounts are often expressed in lamports (1 SOL = 10^9 lamports). Therefore, an agent-friendly interface often provides already-normalized values and ratios alongside raw fields. Additionally, token accounts on Solana are divided into mint (defining the token itself, precision, and permissions) and token account (holding balances); querying distribution requires traversing many accounts or using an indexer. The mint address, precision, and token program returned by the tools here are precisely so agents can recompute and verify themselves, rather than blindly trusting the server's numbers.

Why agent developers should pay attention

From hands-on testing, three design choices stand out.

Tools come with descriptive metadata. Every response includes updatedAt, and some include note or summary fields explaining what the data means. Agents can log data sources and caveats without humans pre-writing explanation logic. This self-describing design is uncommon in APIs.

There's a paid path with real incentives. The get_mycelium_snapshot tool charges $0.05 USDC per call, settled through the x402 payment protocol. The wallet's first payment earns 1,337 $MYC as a reward. Daily historical data costs $0.01 but comes without a reward. This means there's a documented, machine-payable path from "I want data" to "here's the money, here's the data"—no account registration, no API key, no sales conversation.

The same data has a pure HTTP mirror. Every free tool has a corresponding HTTP route—/api/mycelium-allocation, /api/mycelium-distribution, /api/solana-top-performers—plus token.json, pools.json, and an OpenAPI 3.1 spec. If your stack hasn't adopted MCP yet, you're not locked out.

x402 is a payment convention based on the HTTP 402 "Payment Required" status code, championed by Coinbase, enabling per-call API billing without relying on account systems. The typical flow: the client initiates a request, the server returns 402 with payment requirements including price, receiving address, supported chains and tokens; after completing an on-chain transfer, the client retries the request with a payment credential, and the server verifies the credential and returns the data. Since settlement is an on-chain stablecoin transfer, the caller needs no registration, no API key, and no human negotiation of pricing terms—a machine can complete the entire "see price—pay—get data" process in a single interaction, which is precisely the prerequisite for agents to autonomously purchase data.

One area for improvement: the lack of free historical data

To be honest: all the numbers above are snapshots, and snapshots can't tell you whether a number is rising or falling.

The project does record historical data—there's a paid get_mycelium_history tool that returns one summary per UTC day—but for a cold-start free agent evaluating this data source, there's no free way to see the past week's trend.

Adding a free, versioned, read-only historical endpoint (even just a seven-day window) would let agents answer "is this strategy growing?" before paying. For an interface already more agent-friendly than most APIs, this is a small addition.

Try it yourself

If you're running an MCP-compatible agent, point it at https://www.myceliumfinance.com/api/mcp and have it call get_mycelium_allocation. One call gets you a structured answer.

That's Mycelium's core proposition: not a page to scrape, but a data source to query. For those seeking reliable on-chain data for agents, this pattern itself may be more worth studying than the project's token.

All data above comes from one snapshot of the Mycelium Finance MCP server at 2026-10-14T21:35Z. It is not a trend judgment, not a prediction, and not investment advice.

The OpenAPI specification (currently version 3.1) is a machine-readable interface contract described in JSON or YAML, listing each endpoint's path, method, parameters, return structures, and error codes. Its significance lies in enabling automatic consumption by toolchains: code generators can produce clients in various languages, agent frameworks can wrap HTTP endpoints into callable tools, and validators can check whether responses conform to the contract. Therefore, a project that provides both an MCP server and an OpenAPI spec effectively offers two parallel integration paths—one for agent runtimes with native MCP support, and one for any general system that can read HTTP. Both share the same data source, reducing the risk of being locked into a single protocol.