Wallet Access Limitation Layer

Bring AI models onchain the safe way.

A control layer between AI agents and crypto wallets. Define what an agent can do, how much it can spend, and what stays off limits. No private key handoffs. No blind trust.

Try the demo Read the API docs

Robinhood chain

The problem

Agents need wallets. Wallets don't need agents with full control.

Today, giving an AI agent access to a wallet means handing over a private key. The agent gets everything: transfers, approvals, contract calls, withdrawals. There is no middle ground between full access and no access.

Private keys are all-or-nothing

Share a key and the agent can drain the wallet. There is no way to scope what it touches.

Spend limits don't exist

No native mechanism to cap how much an agent can move in a session, a day, or a trade.

No audit trail

When an agent acts onchain, there is no log of what it intended versus what it did. Just transactions.

Revocation is manual

Pulling access means rotating keys, redeploying contracts, and hoping the agent didn't act first.

How it works

Connect a wallet. Set the rules. Let the agent work.

WALL sits between the agent and the wallet. Every transaction goes through a policy engine that checks permissions before anything touches the chain.

Connect via MetaMask

Link your wallet through MetaMask on the Robinhood chain. The agent never sees the private key. It gets a session token scoped to the permissions you define.

Define a policy

Set what the agent can do: swap, stake, transfer. Set limits: per-transaction, per-session, daily. Whitelist contracts and tokens. Block everything else by default.

Agent operates within bounds

The agent calls the WALL API like it would any other tool. Transactions that fit the policy execute. Transactions that don't get rejected with a reason.

Review and revoke

Every action the agent takes is logged with intent, parameters, and result. Revoke a session instantly. No key rotation needed.

The API

Three calls to go from wallet to working agent.

The SDK handles session management, policy enforcement, and transaction signing. Your agent code stays simple.

agent.ts

import { WALL } from "@wall/sdk";

// Connect a wallet and define what the agent can do
const session = await WALL.createSession({
  wallet: walletAdapter,
  chain: "robinhood",
  policy: {
    allow: ["swap", "stake"],
    deny:  ["transfer", "withdraw"],
    limits: {
      perTransaction: "50 USDC",
      daily:          "500 USDC",
    },
    contracts: ["0x..."],
  },
});

// Agent uses the session to act onchain
const result = await session.execute({
  action: "swap",
  from:   "USDC",
  to:     "ETH",
  amount: 25,
});

// { status: "executed", tx: "0x5Uj3...", spend: "25 USDC", remaining: "475 USDC" }

Permissions

Granular control, not blanket access.

Every permission is explicit. Anything not allowed is denied. Limits are enforced before the transaction is signed.

Permission	Scope	Description
swap	allow	Trade between tokens on approved DEXs. Subject to per-tx and daily limits.
stake	allow	Stake tokens with whitelisted validators or pools. Unstake requires separate permission.
transfer	restrict	Move tokens to external addresses. Can be scoped to specific recipients and amounts.
withdraw	restrict	Remove funds from the wallet entirely. Typically denied for autonomous agents.
approve	restrict	Grant token approvals to contracts. Can be limited to specific programs and amounts.

Live demo

See the policy engine work.

Connect your MetaMask wallet, then simulate agent actions. The policy engine approves or rejects each one in real time. No real transactions are sent.

WALL SESSION no wallet

Connected wallet not connected

Chain --

Balance --

Session ID --

allow swap

allow stake

deny transfer

deny withdraw

Limits: 50 USDC per tx / 500 USDC daily

The thinking behind it

Agents will use wallets. The question is how.

Every agent framework is racing to add wallet support. Most of them solve it by giving the agent a private key and hoping for the best. That is not a solution. That is a liability.

The pattern is familiar from cloud infrastructure. Before IAM, you either gave someone root access or no access. Before OAuth, you shared passwords. Every system eventually needs a permission layer between the user and the thing that acts on their behalf.

Crypto wallets are at that inflection point. Agents are useful enough to justify onchain access. They are not trustworthy enough to justify unrestricted access. WALL is the control layer that makes the middle ground possible.

The product is an API. Developers integrate it into their agent frameworks. Wallet owners define policies. Agents operate within those policies. Everything is logged, everything is revocable, and nobody hands over a private key.