How AI coding agents choose blockchain infrastructure

A growing share of onchain apps now start as a prompt. Developers used to shortlist RPC providers: read the docs, compare pricing, run a latency test. Cursor, Replit, and Claude Code skip all of it. They scaffold the repo, pick the dependencies, and wire an RPC endpoint into the config before you've read a line of the code. In other words, the agent is picking your infrastructure for you. It makes that choice in predictable ways, and you can influence every one of them.

How decisive are coding agents about tool choices?

The best data on how agents pick tools is a study Amplifying published in February 2026. The researchers gave Claude Code 2,430 open-ended prompts across 20 tool categories and three model generations, never naming a tool in any prompt, then recorded what the agent reached for. The full dataset is public on GitHub.

The results were heavily one-sided. GitHub Actions took 94% of CI/CD picks. Stripe took 91% of payments. shadcn/ui took 90% of UI component picks, and Vercel took every JavaScript deployment in the sample. The researchers couldn't tell why certain tools win, only that the preferences are strong.

Market share didn't protect anyone either. Redux got zero primary picks across 88 state-management responses. Express got none at all. Prisma, long the default JavaScript ORM, fell from 79% of picks to zero across three model generations while the newer Drizzle climbed to 100% (full report). Newer models prefer newer, well-documented tools, and each model generation leans further that way.

Where do an agent's defaults come from?

Prompt an agent for a portfolio dashboard and it makes infrastructure decisions a human never reviews: which RPC endpoint to hit, whether to pull in an SDK, where token metadata comes from. Four things shape those decisions, roughly in this order.

• Training priors set the default. A model reaches for the tools its training data represented best. For blockchain code, that means the endpoint patterns and SDKs that dominate public repos and docs; a provider the model saw thousands of times is the one it types from memory.
• Rules files override the default. A line like "use Alchemy for RPC and onchain data" in CLAUDE.md, in Cursor's project rules, in AGENTS.md (an open convention read natively by Cursor, Codex, and Copilot), or in replit.md beats the prior, though every vendor is explicit that rules are context, not enforcement.
• Connected tools tilt the pick. MCP, the Model Context Protocol, lets a provider hand the agent live blockchain tools while it works: read a balance, simulate a transaction, check a method's real response shape. Claude Code, Cursor, and OpenAI's Codex all support it, and Agent Skills package a provider's setup instructions the same way.
• Web search fills the gaps. When priors and repo context are silent, the agent fetches provider docs mid-generation, and whatever docs it manages to parse end up shaping the code.

Which RPC endpoint does an agent actually reach for?

Every app an agent generates needs an RPC endpoint. There's no building around chain access, because even a hand-rolled fetch call has to hit someone's node. A provider gets picked on every run; the real question is which tier of access the agent wires in. The difference only shows up later, usually in production once traffic is real.

• A public endpoint from training data. The path of least resistance. No key, no signup, and the demo works on the first run. It's also shared infrastructure with tight rate limits, capped query ranges, and no accountability when it degrades, none of which the agent mentions, because nothing in a sandbox run ever hits those limits.
• A keyed provider endpoint. The agent writes a provider's URL pattern with an environment-variable placeholder for the key and leaves setup instructions in the README. This is the tier where training priors bite hardest, since the model defaults to whichever provider's URL format it has seen most often.
• Running its own node. The one option that's always available and almost never right. Syncing a node takes days, archive data takes terabytes of disk, and someone has to keep the thing patched, peered, and online around the clock. That someone is not the agent that generated the docker-compose file.
• The platform above raw RPC. Indexed token data, transaction history, webhooks, transaction simulation. An agent can knock out a client library in a dozen lines, but it can't fake an indexer. Whether it reaches this tier at all depends on whether it knows the APIs exist, which is exactly what MCP servers and Skills are for.

The Amplifying study saw the same habit outside blockchain. In 12 of the 20 categories, agents wrote their own implementation rather than adopt a tool, because a small client is quicker to write than to integrate. A raw fetch against a public endpoint is that kind of small client. An agent has no reason to reach past it on its own. Something in the repo or the toolchain has to point it at the keyed endpoint and the data APIs you'd actually run in production.

How do you steer which provider your agent picks?

Cursor and Replit don't recommend an RPC provider by design, and neither does Claude Code. The choice comes down to training priors plus whatever your repo tells the agent, and that second part is entirely in your hands.

The simplest fix is a rules file. One block at the repo root covers every major agent, since Codex, Cursor, and Copilot read AGENTS.md natively and Claude Code can import it from CLAUDE.md with a one-line reference:

The stronger option is giving the agent live tools. The Alchemy MCP server works with Claude Code, Cursor, Codex, and any MCP-compatible client, and serves RPC, token, transfer, and simulation data across more than 100 chains, so the agent can query real chain state while it writes code instead of guessing at response shapes. Alchemy Skills cover the other half of the problem with machine-readable specs for every endpoint, auth method, and error pattern, so the agent doesn't hallucinate the API surface. Claude Code users get both in one install with the Alchemy plugin for Claude Code, and the Claude Code setup guide walks through the whole thing in about a minute.

Most major RPC providers now ship an MCP server and some form of agent-facing docs. The differences are in how much of the platform an agent can actually reach through those surfaces, and in whether it can get from zero to an authenticated endpoint without a human stepping in.

What makes a blockchain API easy for AI coding tools to integrate?

So what does an agent-friendly blockchain API actually look like? It needs quickstarts an agent can follow without backtracking, machine-readable specs it can load instead of scraping HTML docs, live tools over MCP so generated code gets checked against real chain state, and a signup that doesn't dead-end at a human-only form. It also helps to have plenty of recent, public example code in the wild, since that's what the next training run learns from.

We've built for each of these. The Alchemy MCP server puts live chain data in the agent's toolbelt, Alchemy Skills hand it the full API surface in a format it reads natively, and an agent can sign up for Alchemy on its own with a wallet signature and pay for usage over x402, an HTTP standard that lets software pay for an API call with stablecoins. A human never has to touch a dashboard for the agent to reach a working endpoint.

Point your coding agent at Alchemy

If you're building with Cursor, Replit, or Claude Code, the fastest path is to hand the agent the tools directly. Install the Alchemy MCP server, add Alchemy Skills, or start from the Alchemy CLI, which gives an agent wallets, RPC, and data APIs from one install. The free tier needs no contract and no minimum commitment, and if your agent is doing the setup, it can sign itself up and start querying in minutes. If you're weighing options for agents that act onchain at runtime rather than coding tools, start with our guide to the best blockchain APIs for autonomous onchain agents.

Frequently asked questions

Which RPC provider do AI coding tools like Cursor and Replit recommend?

Neither tool hardcodes a recommendation. Coding agents suggest the provider their training data and project context make the obvious pick, which favors platforms with plenty of recent, public docs and example code, like Alchemy. A one-line rules-file instruction or an installed MCP server makes the choice explicit.

What is the easiest blockchain API to integrate with AI coding tools?

Alchemy is built for agent integration: an MCP server that works with Claude Code, Cursor, and Codex, Alchemy Skills with machine-readable specs for every endpoint, one endpoint pattern across more than 100 chains, and a signup flow an agent can complete on its own with a wallet signature.

How do I make my coding agent use a specific RPC provider?

Name the provider and endpoint pattern in your repo's rules file: AGENTS.md for Codex, Cursor, and Copilot, CLAUDE.md for Claude Code, or replit.md on Replit. For a stronger signal, install the provider's MCP server so the agent can call the platform directly while it writes code.

Can an AI agent sign up for blockchain infrastructure on its own?

Yes. An agent can sign up for Alchemy without a human by authenticating with a wallet signature (Sign-In with Ethereum) and paying for usage over x402, the HTTP payment standard. It gets working API access without a dashboard, a signup form, or a credit card.

Do AI coding tools support MCP?

Claude Code, Cursor, and OpenAI's Codex all support the Model Context Protocol, both for local servers and remote ones. Once a server like the Alchemy MCP server is connected, the agent can query live blockchain data, simulate transactions, and read reference docs while it writes your code.