Agent wallets on Solana

Give your agent a wallet. Sealed by your rules.

Your agent can trade. It can't touch more than you allow. Nobody can.

Claude, ChatGPT or any MCP client gets its own Solana wallet and an allowance. It pays APIs over x402, trades any token through Jupiter, and writes every action to a public registry anchored on chain. Over budget, it stops. Revoked, it stops.

npx allow-kit init
Install Dashboard
Works with Claude ChatGPT Solana Jupiter
How it works01 / 04
  1. 01
    Ask in words

    "ape $5 into WIF" in Claude or ChatGPT.

  2. 02
    Checked in code

    Within your caps. Honeypots refused.

  3. 03
    Filled on Jupiter

    Re-priced first, floor held, signed by the agent.

  4. 04
    Proved on Solana

    Signed, chained, anchored. Check it on /verify.

Registry entries
0
Solana anchors
0
Spent by the agent
$0
Left in the allowance
$0
Allow

A wallet. A budget. A receipt.

One command gives your agent all three, and none of them depends on trusting the agent.

01

The wallet

A Solana keypair on your machine. Fund it with USDC only: it pays x402 APIs without holding any SOL.

Install it
02

The budget

Caps per action, per day and in total, a pay list and a kill switch. The model can read them, never raise them.

Set the allowance
03

The receipt

Every payment and trade is signed, hash-chained and anchored on Solana. Anyone can check one in a browser.

Verify an entry
The allowance

Every move fits the budget.

Set by you, read live from this agent's policy, checked before anything is signed.

Change the caps
Per action$25

The most one payment or buy can cost.

Before signing
Per 24 h$100

Rolling window, counted from the public registry.

Every action
In total$250

The whole allowance. Past it, the agent stops.

Every action
Slippage5%

Max price drift. Re-quoted before signing, floor enforced on chain.

Every trade
Kill switch1

Command to revoke. The next call fails, funds can sweep home.

Owner only
The agent

Its own wallet. Its own books.

Balance, holdings, spend and every action come from its wallet and its registry. Each line links to its proof.

Open the dashboard →
Allow agentWorking
…
…Allowance left
…Spent of allowance
…Registry entries
How a trade works

Asked in words, checked in code, proved on chain.

  1. Ask

    "Put $2 into WIF." The agent resolves the ticker on Jupiter and refuses tokens that can still be frozen.

  2. Quote

    Jupiter prices it on mainnet liquidity. The agent checks its budget and the slippage cap.

  3. Swap

    It re-prices, aborts if the market moved past the floor, then signs with its own key.

  4. Record

    A signed line in the registry, rolled into a Merkle root posted on Solana.

Latest trade
Spent…
Received…
Value…
Route…
Mode…
Verify ↗All trades →
Live

Counted, not claimed.

Read from this agent's registry and its Solana anchors when the page loads.

0
01 / 03Live

Actions recorded

Payments, trades, caps and revocations

Source: registry
0
02 / 03Live

Solana anchors

Merkle roots posted as SPL memos

Source: memo transactions
0
03 / 03Live

Spent inside the caps

And not one dollar past them

Source: registry
See it run

One minute, real outputs.

The commands and what they printed on a local validator: a wallet, an x402 payment, a buy, a refusal, a revocation.

allow






  
Tools your agent gets

  
Seven tools. That's the kit.

  

    
ToolWhat it does

    
allow_walletIts address, balance, holdings and trading mode.

    
allow_budgetCaps, what's used, what's left. It checks before spending.

    
allow_payFetches a URL and pays its x402 price in USDC (no SOL needed, the seller pays the fee) or SOL.

    
allow_quotePrices a buy or sell of any token on Jupiter. Nothing moves.

    
allow_swapExecutes the quote, under the floor it showed.

    
allow_token$ALLOW on chain: supply, price, market cap, largest holders.

    
allow_historyThe public registry: every payment and trade.

  






  
The token

  
$ALLOW

  
Launched on pump.fun. The contract address is published here and on X at launch, nowhere else first.

  
CADrops at launch






  
Check it yourself

  
Docs, registry and proof.

  

    
Documentation
Install for Claude and ChatGPT, the CLI, the security model.
↗
    
Wallet and registry
The agent's address, its allowance and every action it took.
↗
    
Verify
Recompute any entry and read its memo from a Solana RPC.
↗
  






  
Questions

  
Before you hand it the keys.

  
Can the agent raise its own budget?
No. None of the seven tools writes the allowance. The owner controls answer only on this machine, never through a tunnel.

  
Does the agent need SOL?
Not to pay. x402 payments in USDC are signed by the agent and submitted by the seller, who pays the network fee. A few lamports of SOL are only needed to anchor the registry on chain and to trade.

  
Who holds the key?
You do. It's a file in ~/.allow on your machine. Allow runs no custody server and never sees it.

  
Does it really trade?
Yes, through Jupiter on mainnet when you switch live mode on. Until then every swap fills at the live Jupiter quote into a paper wallet and is marked simulated in the registry.

  
What stops a honeypot?
Tokens whose creator can still freeze holders are refused. Thin liquidity, open mint and concentrated holders come back as warnings in the quote.

  
How is the registry public?
Each entry is hash-chained and signed by the agent. Batches are rolled into a Merkle root posted as an SPL Memo signed by the same wallet. /verify checks all of it against a Solana RPC from your browser.






  

    
    
Give your agent a wallet.

    
One command, a budget you set, and a public receipt for everything it does.

    
Install Allow ↗Verify an entry