A week of intent-based trading for AI agents: five threads from the Hashlock Markets desk

The Model Context Protocol surface for crypto trading filled out fast over the last few weeks. Bybit shipped MCP coverage. Gemini added an agentic platform. Alpaca, Kraken, Hummingbot, TraderEvolution, and a handful of community wrappers are all in the same SERP now. The category is real, and it is crowding.

This is a recap of the five threads we worked through here this week — what each one was about, why it matters in a category that is suddenly busy, and what we think is going to matter most going forward.

1. Why public order books are not the right primitive for AI traders

The week opened with the structural argument: public order books and transparent mempools were designed for humans clicking in browsers. Every assumption baked into that design — that the trader is patient, that signaling intent is a feature, that retrying a failed cross-chain swap is acceptable — breaks down when the trader is an autonomous agent operating at machine speed.

An agent that broadcasts a large order into the mempool is feeding free information to every searcher and frontrunner watching that mempool. The order book is supposed to be a price discovery mechanism, but for size, it is a leakage mechanism. The architectural answer is simple to state and hard to build: discovery should happen in private, and settlement should happen atomically.

That is the protocol shape Hashlock Markets settled on. Sealed-bid RFQ for price discovery — takers post a request, market makers respond with sealed quotes, the taker chooses. HTLC for settlement — both legs lock against the same hash, the hash is revealed, both legs unlock. Either the trade settles or it doesn't.

2. One URL for any agent runtime

The MCP spec originally shipped with stdio as the canonical transport: an agent spawns the server as a child process and talks to it over standard input and output. That is fine on a developer laptop, but it does not survive contact with a production agent runtime that lives in a serverless function or a remote container.

Streamable HTTP is the answer the spec landed on, and it is what Hashlock Markets serves at https://hashlock.markets/mcp. That single URL is all an agent runtime needs to know. Claude Desktop, Cursor, an OpenAI agent loop, a LangChain runner, a custom Python client — same endpoint, same six tools, same auth flow.

The npm package @hashlock-tech/mcp is still the right path for stdio deployments where you want the server in-process. Both paths are first-class.

3. Six MCP tools, full trading lifecycle

The whole surface is six tools, deliberately:

• create_rfq — a taker posts a sealed-bid request describing what they want.
• respond_rfq — a market maker posts a sealed quote against an open RFQ.
• create_htlc — once a quote is selected, both sides lock funds against a hash.
• withdraw_htlc — the holder of the preimage settles the trade.
• refund_htlc — if the timeout expires, locked funds return.
• get_htlc — read state for any HTLC by id.

There is no SDK to import. There is no fifty-method client class to pin to a major version. There is no separate auth library. SIWE handles authentication, the MCP server handles the rest. An agent that can call six functions has the full Hashlock Markets surface.

This minimalism is intentional. Tool surfaces grow in two ways: deliberately, when a real new capability arrives, or accidentally, when convenience methods accrete around a leaky core. The HTLC + RFQ core is what Hashlock Markets sells; everything else can be composed on the agent side.

4. Where Hashlock sits relative to the CEX-MCP wave

The single-venue CEX-MCPs are useful, and they are not the same thing. A Bybit MCP, an Alpaca MCP, a Kraken CLI wrapped into MCP — each of those gives an agent access to one venue's order book over one venue's API. Liquidity is whatever that venue has. Settlement is custodial, on the venue's books. Cross-asset moves require the agent to bridge between venues itself.

Hashlock Markets is a different shape. It is not a wrapper around one venue's API; it is a settlement protocol with a quoting layer on top. Liquidity comes from competing market makers via sealed-bid RFQ. Settlement is non-custodial — the protocol never holds either side of the trade. Cross-chain is native: an agent can swap ETH for BTC for Sui without touching a bridge, because the HTLC primitive handles cross-chain atomicity directly.

Both categories will exist. The single-venue CEX-MCP makes sense for an agent trading inside one liquidity pocket. Hashlock Markets makes sense when the trade has to cross venues, cross chains, or stay non-custodial.

5. Wire Claude in ten minutes

The most pragmatic thread was also the most concrete: a hands-on tutorial for getting Claude wired into Hashlock Markets in roughly ten minutes. Sign in with SIWE, point Claude Desktop at hashlock.markets/mcp, give the agent a prompt that describes a trade in natural language, watch it walk through create_rfq → respond_rfq → create_htlc → withdraw_htlc. Cross-chain swap, atomic settlement, no manual steps in between.

That ten-minute path is the intended entry point. The argument for intent-based trading is more compelling once you have actually watched an agent execute one.

What's coming next

Three things on the near horizon worth flagging.

First, more chains. Ethereum, Bitcoin, and Sui are live. Solana and Arbitrum are next. Each new chain expands what a single intent can route across.

Second, the differentiation page. The "AI agent trading MCP" category is crowded enough that a structured comparison — sealed-bid versus public quote, atomic versus custodial, cross-chain versus single-venue — earns its keep. Expect that to land soon as a public page rather than buried in docs.

Third, more tooling for market makers. The taker side of the protocol is well-trodden because of the agent narrative. The market-maker side is where pricing and inventory management get interesting, and where there is a lot of headroom for tools that haven't been built yet.

If you are running an agent today and the trading layer is the part that feels brittle, the ten-minute path is the place to start: hashlock.markets.

What's your current MCP trading runtime setup, and what is breaking?