Read, audit, and build on gno.land with your AI agent
gnomcp puts your agent on gno.land, where every contract is published as readable source. Ask whether a contract is safe, have a vote explained, or turn an idea into a live app.
$ curl -fsSL https://raw.githubusercontent.com/gnoverse/gno-mcp/main/scripts/install.sh | sh
Pipes a script into your shell. Read it first ↗
One server, one skill
Everything on gno.land is readable Go-like source with transparent state, so an agent can read a realm the way it reads any codebase. What was missing was a safe way to let it act. gnomcp adds that part.
The MCP server
Live chain queries, writes, and an agent key of its own to sign with. It ships pointed at the public testnet and a local gnodev node, so there is nothing to configure, and any other gno.land chain is one profile away.
The gno skill
Teaches your agent where Gno differs from Go: interrealm semantics, the security taxonomy, Render() conventions, the stdlib surface. So it stops guessing from Go or Solidity habits.
From a question to a live app
You talk, the agent does the chain work and shows its receipts: quoted code, real transactions, links anyone can check.
Check a contract before you trust it
Give me a formal security audit of gno.land/r/gnoland/wugnot before I deposit into it.
The agent audits the code that actually runs, line by line, and reports findings with the lines quoted. On bytecode chains you audit whatever the deployer claims the source is; here the source is the contract itself.
Get the chain explained
What is being voted in gno.land/r/gov/dao right now, and what changes if it passes?
Governance, balances, realm pages, history: ask in your own words and the answer comes from live chain queries, not from a thread on social media.
Turn an idea into a live app
Deploy a check-in board: anyone can check in, it records their address, and reading it back lists everyone so far. Then check in yourself.
The agent writes the code, tests it, deploys it, and proves it works with a real call. You get a link anyone can open and code anyone can verify. When a transaction fails, it debugs the same way: reproduce, fix, prove.
Delegate, with a hard cap
From now on act as my account: budget 5 GNOT, only gno.land/r/demo/profile, for two weeks.
The chain itself enforces the budget, the paths, and the expiry. No clever prompt can spend past them.
Act as yourself, safely
Want writes under your own address? The agent proposes a scoped session and hands you a gnokey command to sign on your own machine. It never touches your keys. Once approved it writes as you, within the limits you set, and revoking takes one command.
Pre-releaseSessions are the newest part of gnomcp and still evolving. Keep scopes tight and spend limits low.
25 tools, grouped by what they touch
Chain reads
Render realms, evaluate expressions, read packages, inspect accounts and node status.
Work immediatelyIndexer reads
List realms, deployment and transaction history, on-chain activity.
Indexer URLWrites
Call functions, run code, deploy packages, sign the CLA. Every result names its signer.
Agent key or sessionConnect & configure
List the configured chains, discover a new one from its gnoweb URL, and add it as an in-session profile.
A gnoweb URLSessions & keys
Propose and revoke user sessions; generate, list, fund, and manage the agent's own keys.
Your signature for sessionsgno_rendergno_readgno_evalgno_packagesgno_accountgno_statusgno_profile_listgno_connectgno_profile_addgno_historygno_activitygno_session_proposegno_session_revokegno_auth_statusgno_callgno_rungno_addpkggno_cla_infogno_cla_signgno_key_addressgno_key_listgno_key_generategno_key_deletegno_key_sendgno_faucet_fund
Full catalog with arguments and return shapes → docs/tools.md
Safe by architecture, not by promise
An agent with chain access is a sharp tool, so the guarantees are structural. They live in code paths, not in a policy document.
Your keys stay in gnokey
The agent signs with its own key. Acting as you goes through an authorization you sign yourself.
No signing on real-funds chains
A write path for real-funds chains does not exist in the code. Writes stay on dev and testnet chains.
Chain output is data, not instructions
Everything read from the chain is wrapped as untrusted content, so a malicious realm can't steer the agent.
Bounded reads
Output is budgeted and summarized, never silently truncated.
Every write is logged
An append-only trail records the tool, the profile, the result, and which account signed.
Structured errors
Machine-routable codes and recovery hints, so the agent fails forward.
Work in progress, unaudited, and the tool API can still change. Writes only work on dev and testnet chains. Read docs/security.md and file issues when something looks off.
Install it, then just ask
One command installs the server binary and the agent skill. It verifies the checksum and wires up the clients it can.
Install
This pipes a script from the internet into your shell, so read it first. Claude Code, Gemini CLI, and Codex are wired automatically; OpenCode gets printed steps.
Restart your agent
So it loads gnomcp. From the next prompt on, your agent can reach the chain.
Ask
New to gno.land? Ask your agent to teach you. It will walk you through a hands-on tour. Otherwise just describe what you want on chain.
