Skip to content

Get an agent started

Testnet

Connect an MCP client to RP1 testnet, create an owner-controlled wallet, submit an approved native transfer, and register an on-chain agent.

Updated View as Markdown

The RP1 MCP endpoint at https://mcp.rp.one/mcp gives agents a shared way to inspect the public testnet, submit a signed native transfer, and register an on-chain agent. It uses Streamable HTTP. The hosted server holds no wallet keys; a local or external signer controls them.

Connect an MCP client

Add https://mcp.rp.one/mcp as a Streamable HTTP MCP server in a compatible agent host. These commands follow the current Claude Code, Codex, and Gemini CLI setup guides:

Connect Claude Codebash
claude mcp add --transport http rp1-testnet https://mcp.rp.one/mcp
Connect Codexbash
codex mcp add rp1-testnet --url https://mcp.rp.one/mcp
Connect Gemini CLIbash
gemini mcp add rp1-testnet https://mcp.rp.one/mcp --transport http

Call rp1_guide with no arguments for plain-language setup steps, or set its topic to wallet, transfer, or registration for a specific task. Then call rp1_network. Continue only when it reports chain ID chain-1, catchingUp: false, and consensusRunning: true. The remote tools are:

Tool Use
rp1_guide Explain setup, wallet ownership, transfer, and registration in order.
rp1_network Verify chain identity and current network status.
rp1_balances Read a complete rp1 account address and its integer balances.
rp1_capabilities Discover actions advertised by the chain’s AI module; this call does not execute them.
rp1_agent_params Read the current agent registration fee and limits; this call does not register an agent.
rp1_agent_by_name Look up a registered agent’s on-chain address and owner by exact name.
rp1_transaction Query a transaction hash and its committed execution result.
rp1_submit_signed_transfer Broadcast one locally signed native MsgSend and observe its result.
rp1_submit_signed_registration Broadcast one owner-signed MsgRegisterAgent and observe its result.

Keep signing under the wallet owner’s control

Claude Code and other shell-capable agents can change files that their shell identity can write. A separate terminal in the same agent-writable checkout cannot protect the wallet password: the agent could alter the signing code before the owner runs it. Run signing from an owner-controlled environment on another device or under a separate OS account. The agent must have no access to that environment, wallet state, or owner terminal.

The chain source remains private. External partners can use the public standalone signer below or a compatible owner-controlled signer without repository access. Do not download wallet software from an unverified source.

Download the standalone signer, its third-party notices, and checksum manifest from the RP1 releases page. The signer is a single self-contained Node.js file with no dependencies to install.

Verify and create a walletbash
sha256sum -c CHECKSUMS.sha256          # verify download integrity
chmod +x rp1-signer.js
node rp1-signer.js owner-create-wallet  # follow the prompts

The owner confirms wallet creation, enters and confirms a password (at least 16 characters), and the signer writes an AES-256-GCM encrypted backup to ~/.rp1-agent-mcp/<address>.wallet.json. The mnemonic and password never leave the owner’s machine. Give the agent only the public address.

To sign a transfer or registration later, use owner-sign-transfer or owner-sign-registration in the same way. See the signer README for full instructions.

Option B: Build from the rp1-chain repository

Teams with access to the rp1-chain repository can use its owner CLI in a separate owner-controlled environment. From the owner-controlled checkout root:

Create a wallet outside the agent environmentbash
pnpm install --filter @rp1/agent-mcp... --ignore-scripts
pnpm --filter @rp1/agent-mcp local owner-create-wallet

The owner confirms wallet creation, enters and confirms a password, and backs up the encrypted wallet file and password separately. Give the agent only the public address. A compatible external signer can instead create and hold the key. The hosted MCP never creates or stores keys.

After wallet creation, fund the address through the current path in Send a first transaction, then call rp1_balances until the expected urp1 balance appears. One RP1 is 1,000,000 urp1.

Submit an approved transfer

  1. Gather the exact sender, recipient, positive integer amountUrp1, integer feeUrp1, and memo. Use complete rp1 addresses and base-unit strings.

  2. Give those fields to the owner for review. In the separate owner environment, run:

    Sign an exact transfer outside the agent environmentbash
    pnpm --filter @rp1/agent-mcp local owner-sign-transfer

    The command prompts for sender, recipient, amount, fee, and memo as plain text. The owner checks the displayed fields, types yes, and enters the wallet password. It prints signed transaction JSON. A compatible external signer must independently approve the exact transaction and provide signed Cosmos TxRaw bytes plus the same fields.

  3. Give only the signed JSON to the agent. Pass it unchanged to hosted rp1_submit_signed_transfer.

  4. Treat the transfer as successful only when the hosted tool returns status: "committed", execution code 0, the matching hash, and a positive height. For status: "unknown", call rp1_transaction with the returned hash before considering a retry.

RP1’s broadcast_tx_sync confirms queueing, not CheckTx execution. A code-zero queue receipt alone does not prove admission or commitment. The MCP reports an explicit RPC queue error as rejected and an unobserved queued transaction as unknown.

The transfer tool accepts only a single signed native bank transfer in urp1. It checks the decoded sender, recipient, amount, fee, and memo against the supplied fields before broadcast. Treasury, institutional stablecoin, and MPP workflows use the separate module tools described below. Velocity and vault workflows remain outside these submit tools.

Treasury, institutional stablecoin, and MPP flows

The module integration is a preview until the hosted server’s tool list advertises rp1_module_availability, rp1_module_state, and rp1_submit_signed_module. Tool discovery alone does not establish that the public chain is reachable. Call rp1_network and stop if it reports the wrong chain, stopped consensus, or catch-up; then call rp1_module_availability. This checks each module’s params query, not a wallet’s authority to execute an action.

Flow Inspect and submit
Treasury approval Read rp1_module_state with kind: "treasury_payment_request" and the request ID. An authorized approver signs /enterprise.v1.MsgApprovePaymentRequest; execution is a separate /enterprise.v1.MsgExecutePaymentRequest after treasury policy is satisfied.
Institutional mint/redeem Read kind: "issued_stable" with the complete governance-approved bank/ denom. The configured issuer signs /stables.v1.MsgMintIssuedStable against matching reserves; a holder signs /stables.v1.MsgRedeemIssuedStable. Issuance pauses do not block redemption.
MPP charge/refund Sign /mpp.v1.MsgCreateCharge, inspect kind: "mpp_charge" with the resulting charge ID, then pay with /mpp.v1.MsgPayCharge binding the expected amount, denom, and recipient. An authorized requester signs /mpp.v1.MsgRefundCharge after payment.

These actions require an external owner-controlled Cosmos signer with the chosen module’s protobuf codecs. The public signer-0.1.0 download only signs native transfers and agent registration; it cannot prepare these module messages. Arrange a supported signer and the required testnet roles with the RP1 team before a diligence session. Treasury setup requires an enterprise, member roles, policy, and funded treasury; institutional issuance requires a configured issuer and reserves. Read the enterprise, stables, and MPP guides for the chain’s authorization and accounting boundaries.

The owner must review every action field, memo, gas, and fee before signing a single SIGN_MODE_DIRECT Cosmos TxRaw for chain-1. Pass signedTxBase64, its exact typeUrl, signer, and feeUrp1 to rp1_submit_signed_module. The MCP checks the allowed type, signer, and fee; the external signer must independently display and approve the complete action. Require a matching committed hash and envelope, positive height, and code 0, then reread the module state. For status: "unknown", query the returned hash with rp1_transaction before signing a replacement. On-chain permissions, treasury policy, reserve checks, and MPP state transitions still apply.

Register an on-chain agent

  1. Call rp1_agent_params. Note the current registrationFeeUrp1 and maxFeeRateBps. The registration fee is burned by the chain; the owner also pays any initial funding and network fee.

  2. Agree on the owner address, unique name, description, capabilities, fee rate in basis points, optional fee recipient, JSON metadata, initial funding in urp1, network fee in urp1, and memo. In the separate owner environment, run:

    Sign an agent registration outside the agent environmentbash
    pnpm --filter @rp1/agent-mcp local owner-sign-registration

    The command checks the testnet chain ID and live registration limits, displays every field and the total owner debit, and asks the owner to approve before entering the wallet password. It prints signed JSON. Give only that JSON to the agent.

  3. Pass the signed JSON unchanged to hosted rp1_submit_signed_registration. It checks the signed message, network fee, live registration fee, and fee-rate limit before broadcast. If the fee or limit changed, request fresh owner approval. Treat status: "unknown" as unresolved and call rp1_transaction with its hash before retrying.

  4. After status: "committed" with execution code 0, call rp1_agent_by_name and verify the returned name and owner. Its address is the new on-chain agent account.

The signed message cannot cap the chain’s registration fee: governance can change that parameter between the MCP check and execution. On testnet, use an owner-approved risk limit for that interval. Agent registration does not grant arbitrary access to AI capabilities or vault capital.

Optional local MCP for tool-only agents

If the agent host cannot run arbitrary shell commands or read or modify the signer checkout, dependencies, wallet state, or owner terminal, it may launch pnpm --filter @rp1/agent-mcp local as a stdio MCP from the rp1-chain checkout root. Do not use this shared-state flow with Claude Code or another shell-capable agent that can write to that checkout. Keep the wallet password out of the agent host’s environment, commands, and MCP tool arguments; the local MCP refuses to start if RP1_AGENT_WALLET_PASSWORD is set.

Call rp1_create_wallet to request owner creation and rp1_wallet_status to retrieve the public address. For transfers, call rp1_prepare_transfer, give the returned command to the owner to run in a separate terminal, and call rp1_sign_approved_transfer after owner approval. Each request expires after ten minutes. Pass the returned signed JSON unchanged to the hosted submit tool.

The local password prompt prevents a tool-only agent from signing by running the approval command alone. This protection depends on the agent being unable to alter the code or access the owner terminal.

Give the workflow to an agent

Download the RP1 Agent Skill into your host’s skill directory. The rp1-chain repository already includes the same file in both locations:

Host Project skill path
Claude Code .claude/skills/rp1-chain/SKILL.md
Codex .agents/skills/rp1-chain/SKILL.md
Gemini CLI .agents/skills/rp1-chain/SKILL.md

The file describes the verify, fund, approve, submit, and reconcile flow without containing a secret. Other hosts that support Agent Skills can install that same file in their documented skill directory. For an MCP host without skill discovery, add the hosted MCP URL and give the file’s instructions to the agent as a custom instruction. A host needs Streamable HTTP MCP support to call the RP1 tools.

Verified on public testnet

On 8 October 2026, the wallet, transfer, and agent-registration workflow was verified on chain-1 using the standalone signer and hosted MCP. A wallet was created, funded from a seed account, signed a native transfer, and registered an on-chain agent. Both transactions committed with execution code 0:

Step Result
Wallet creation Standalone signer created an encrypted wallet
Funding Seed transfer committed
Transfer C8F3D774D0C21922CF57F42ACADFF831168DE9E9C25859E6D391886D125E0E22, code 0, height 537
Registration 74F752E61C074DDE2A872D3567943504E34CA4D939538CEFAB41F984C37D81A1, code 0, height 569
Agent lookup Verified by name and owner address

Call hosted rp1_transaction with either complete hash above and verify the returned hash, positive height, and execution code 0. The first-transaction guide also shows a public REST query. These historical observations do not establish current network availability; retained transaction history may become unavailable after a testnet reset or pruning. To repeat the workflow with a new wallet, follow the public signer and MCP steps on this page. No private repository access is required.

Navigation

Type to search…

↑↓ navigate↵ selectEsc close