Skip to main content
Guide10 min read·Updated July 31, 2026
🧩

Best AI Agent Skills for Solidity & Smart Contracts (2026)

B

A. Frans

Published July 31, 2026

SoliditySmart ContractsAgent SkillsSecurityWeb3

Of the four most-starred Solidity entries in our own skills directory, exactly one is a Claude Code Agent Skill. Two are MCP servers. One is a standalone Rust binary with no AI integration whatsoever — no SKILL.md, no MCP, no mention of an agent anywhere in its docs.

That matters because the install command is different for each, and copying the wrong one gets you a command-not-found error. In this particular corner it gets worse than that: two of these four want a private key in an environment variable, and one of them ships with a warning from its own author that reads, near enough, do not trust the model.

So this is organised by what each project actually ships. Everything below was checked against each repository on 31 July 2026.

What each one actually is

ProjectWhat it shipsStarsLast pushedUse it for
Trail of Bits SecurityClaude Code plugin marketplace, 50+ skills6,3562026-07-30Contract audit, entry-point analysis, spec compliance
EVM MCP ServerMCP server, 60+ EVM networks3802026-06-04Reading chain state, ABI fetch, transfers
Foundry MCP ServerMCP server for Foundry2502026-01-17Anvil, forge workspace, gas and storage
AderynStandalone Rust CLI7882026-07-26Static analysis your agent runs as a command
Star counts and push dates come from the GitHub API on the date above. The "what it ships" column comes from reading each repository's own README, not from a directory listing, including ours.

The one real skill package: Trail of Bits

This is the strongest security package available for Claude Code right now, and smart contracts are the part they've invested in most heavily. Trail of Bits is an audit firm with a long public record, and they've packaged their internal review methodology as a plugin marketplace.

Install it the documented way:

  • /plugin marketplace add trailofbits/skills

Then browse and install individual plugins from that marketplace. The blockchain-relevant entries in their catalogue include:

  • building-secure-contracts: a smart contract security toolkit with vulnerability scanners across six blockchains
  • entry-point-analyzer: finds state-changing entry points, which is where an audit starts
  • spec-to-code-compliance: checks implementation against the written specification, the gap most exploits live in
  • property-based-testing: invariant testing that covers smart contracts among other targets

Codex users get their own path: codex plugin marketplace add trailofbits/skills, then codex plugin add <plugin-name>@trailofbits.

The licence is CC-BY-SA-4.0, which is worth reading if you plan to fold their prompts into a commercial audit product.

Why this one first: entry-point-analyzer and spec-to-code-compliance encode how a professional auditor sequences a review. The model isn't inventing methodology on the fly, which is exactly the failure mode that makes agent-run audits untrustworthy.

The two MCP servers

Neither of these is a skill. They're servers you register with your agent, and they give it the ability to touch a chain.

Foundry MCP Server

Run it with npx @pranesh.asp/foundry-mcp-server, or install globally with npm install -g @pranesh.asp/foundry-mcp-server. Note the package name. It's namespaced under the author's handle, and several directories list a different one that doesn't exist on npm.

It exposes contract calls and transactions, storage reads, local Anvil management, gas estimation, transaction analysis, bytecode analysis via Heimdall, and a persistent Forge workspace. For a Solidity developer already living in Foundry, that's the right surface area.

Read the author's own warning before you wire it up. The README tells you plainly not to add keys holding mainnet funds, because a model can hallucinate and send a malicious transaction, and it repeats the point in capitals. That's an unusually honest thing for a maintainer to write, and it should set your expectations for the whole category.

The repository was last pushed in January 2026. Six months of silence on a tool that signs transactions is a fact worth weighing.

EVM MCP Server

Run it with npx @mcpdotdirect/evm-mcp-server, or npx @mcpdotdirect/evm-mcp-server --http for HTTP transport.

It covers 60+ EVM-compatible networks with 25 tools, 10 prompts and a set of resource URIs, covering chain state reads, interacting with contracts using automatically fetched ABIs, transferring native tokens, ERC20, ERC721 and ERC1155, token metadata, and ENS resolution.

It handles keys through EVM_PRIVATE_KEY, or EVM_MNEMONIC with EVM_ACCOUNT_INDEX for HD derivation. The docs say keys are used only for signing and never stored by the server, and warn against committing them. That's the correct design, and it still means a key sits in an environment variable on a machine running an agent that reads untrusted contract source.

The one that isn't AI at all: Aderyn

Aderyn is a Rust-based Solidity static analyzer from Cyfrin. It has no Claude Code skill, no MCP server, and no AI integration mentioned anywhere in its documentation. It's a linter for contracts.

Install it whichever way suits:

  • npm install @cyfrin/aderyn -g
  • brew install cyfrin/tap/aderyn
  • cyfrinup if you already run the Cyfrin toolchain

It still belongs in this article, because a CLI with clean output is often the best thing you can hand an agent. Let the model run Aderyn, read the findings, and reason about which are real, rather than asking the model to spot reentrancy by reading source. Deterministic tool, probabilistic reviewer. That split is generally the right one, and it's the pattern the Trail of Bits skills follow too.

Keys, agents, and the thing everyone gets wrong

Two of the four projects here touch private keys. Some ground rules, in rough order of how badly people get them wrong:

  • Never give an agent a key that controls mainnet funds. Not "a small amount for testing." Testnet keys and Anvil accounts only.
  • Keep signing on a separate machine or container from anything that reads untrusted contract source. Verified source on a block explorer is still attacker-supplied text arriving in your model's context.
  • Treat every generated transaction as unreviewed until a human reads the decoded calldata. Foundry MCP's author says this louder than any directory will.
  • Simulate first. Anvil forking exists precisely so a mistake costs nothing.
  • Pin your MCP server versions. An auto-updating server with signing rights is a supply-chain hole.

None of this is exotic. It's the same discipline you'd apply to a deploy script, applied to something that writes its own deploy script.

A setup that works

For audit and review work, install the Trail of Bits marketplace and use entry-point-analyzer and spec-to-code-compliance as your entry point. Add Aderyn as a CLI the agent can invoke, and have it reconcile Aderyn's findings against its own reading. Two independent passes on the same code catches more than one clever prompt.

For development, add Foundry MCP against a local Anvil node, with a throwaway key. Keep EVM MCP for read-only chain queries and don't configure a key at all unless you specifically need transfers — most of its value is in reading state.

The thing to resist is wiring all of it up at once with a funded wallet because a listicle said these were the top four tools. Three of these four are not what a directory would tell you they are, and that includes ours until this article.

If you want the wider security picture, our round-ups on penetration testing skills and security audit skills cover the non-blockchain side, and our Trail of Bits review goes deeper on that package alone. Developers new to the format should start with MCP servers vs agent skills. See also our full list for developers.

FAQ

Is there a Claude Code skill that audits Solidity on its own? Trail of Bits ships the closest thing, and it's a methodology package rather than a push-button auditor. It structures the review (entry points, spec compliance, invariants) and a human still reads the output. Anything marketed as an autonomous contract auditor is overselling.

Why does the install command differ between these projects? Because they're different kinds of software. Skills and plugins install through the marketplace command inside Claude Code. MCP servers are npm packages you run and register. Aderyn is a binary you install with your package manager. One command doesn't cover all three, and the fabricated one-size install lines floating around directories are the single most common reason people bounce off this category.

Can I let an agent deploy a contract? Technically yes. Do it on a testnet or a forked local node, with a key that holds nothing. The Foundry MCP maintainer's own warning about not trusting the model with mainnet keys is the most useful sentence in that repository.

Which of these is safe to run against a production codebase? Trail of Bits skills and Aderyn both read code without touching a chain, so they carry ordinary code-review risk. The two MCP servers can transact, and belong behind a testnet boundary.

How were these verified? Star counts and push dates came from the GitHub API on 31 July 2026. Install commands and project types came from each repository's own README, because directory install fields, including the ones in our database, carry commands that don't exist.

Share this article

📬

Get More AI Tool Guides

New comparisons and guides every week. Join thousands of professionals staying ahead of the AI curve.