Give your AI agents
a wallet they can
actually use.

MOSS is the execution and permission layer for AI agents in crypto applications. No private key exposure. No escrow contracts. No human approval loops.

//
MOSS turns wallets into programmable execution environments for AI agents — without smart contracts, without escrow, and without asking users to trust a black box.

Every alternativehas a fatal flaw.

Developers building agents on crypto have tried three approaches. Each breaks in a different way..

DANGEROUS

Raw EOA + private key

Give the agent a wallet it "owns" directly. The most common approach. The most dangerous.

  • One leaked key means total, irreversible loss. No recovery path.
  • The agent has unconstrained access. There is no permission layer.
  • No revocation. You can't narrow what the agent can do after the fact.
  • Can't scope by app, time window, or spend amount.
const wallet = new ethers.Wallet(
  process.env.AGENT_PRIVATE_KEY
);

// If this leaks:
// total loss, no limits, no revocation
COMPLEX

Custom escrow contracts

Deploy a contract that holds user funds. The agent draws from it within rules you define in Solidity.

  • Users must deposit funds before the agent can operate.
  • Every new rule requires a contract deployment or upgrade.
  • New attack surface. Smart contract bugs mean drained escrows.
  • 3–6 weeks of engineering before you have a working prototype.
contract AgentEscrow {
  mapping(address => uint256) limits;

  // Audit this. Then audit again.
  // Then deploy. Then upgrade.
}
UNUSABLE

Human wallet SDKs

Bolt an existing embedded wallet (Privy, Dynamic, Turnkey) onto your agent flow. Built for humans, not agents.

  • Every action interrupts with an approval popup. Agents can't click "Confirm."
  • Session keys exist as afterthoughts, not first-class primitives.
  • No natural language → policy compiler. You write JSON schemas by hand.
  • Cross-app execution requires separate wallet connections per app.
await wallet.sendTransaction(tx);

// "Please confirm this in your wallet"
// Agent stalls. User is not there.

Identity, Wallet, Permissions, Clean separation

Identity. Wallet. Permissions. Clean separation.

OWS wallet address, service identity, or social credential. The agent never holds a private key.

agent-provisioning.ts@megaeth-labs/wallet-sdk
const identity = {
  type: "service",
  address: agentServiceAddress,
};

await mega.initialise({
  network: "mainnet",
  sponsorUrl: "YOUR_PAYMASTER",
});

const { status } = await mega.grantPermissions({
  permissions: {
    expiry: now + 86_400,
    permissions: {
      calls: [{ to: wcmContractAddress, signature: "executeLimitOrder(uint256)" }],
      spend: [{ limit: Value.fromEther("5"), period: "day" }],
    },
  },
});

// status === "approved"
// identity stays separate from wallet keys

Plain language becomesEnforceable policy.

Users describe what they want. MOSS compiles it into a precise JSON permission schema, presents a human-readable summary for approval, and the agent is live. No JSON editing. No session key schemas. One approval.

User Input

“Trade up to 5 ETH on WCM, 0.5 ETH on Kumbaya's launchpad, and use 0.25 ETH on Euphoria — for the next 2 days.”

Compiled Policy

expiry48h from now
WCM spend5 ETH / day
Kumbaya spend0.5 ETH / day
Euphoria spend0.25 ETH / day
executionsilent within limits
revocationinstant, any time

SDK Call

await mega.grantPermissions({
  permissions: {
    expiry: now + 172_800,
    permissions: {
      calls: [
        { to: wcmAddr, signature: "executeLimitOrder(uint256)" },
        { to: kumbayaAddr, signature: "swap(bytes,uint256)" },
        { to: euphoriaAddr, signature: "mint(uint256)" },
      ],
      spend: [
        { limit: fromEther("5"), period: "day" },
        { limit: fromEther("0.5"), period: "day" },
        { limit: fromEther("0.25"), period: "day" },
      ],
    },
  },
});

Approve (once),Execute (forever).

Once a user approves a permission policy, the agent operates silently within those bounds — no confirmation popups, no user present required. When the permission expires or is revoked, execution stops immediately.

Software-speed execution

Responds in <10ms on MegaETH. Your agent doesn't wait for block confirmations.

No key management

Session keys live inside MOSS infrastructure. Your agent code never touches them.

Enforced at account level

Spend limits and app scope are enforced by the smart account itself — not middleware you maintain.

No escrow contracts

Users don't deposit funds first. Permissions apply to the wallet directly. Zero contract deployment.

Instant revocation

Call mega.revokePermissions() and the agent is stopped immediately, no transaction needed.

trading-agent.ts@megaeth-labs/wallet-sdk
await mega.grantPermissions({
  permissions: {
    expiry: now + 86_400,
    permissions: {
      calls: [{ to: wcmContractAddress, signature: "executeLimitOrder(uint256)" }],
      spend: [{ limit: Value.fromEther("5"), period: "day" }],
    },
  },
});

if (ethPrice <= targetPrice) {
  const result = await mega.callContract({
    address: wcmContractAddress,
    abi: wcmAbi,
    functionName: "executeLimitOrder",
    args: [orderId],
    silent: true,
  });
}

Five agent patternsReady to build.

Each use case runs on the same SDK. Different permissions, same wallet.

Autonomous Trading

An agent executes a limit order or rebalancing strategy with defined spend limits and a time window. No approvals for individual transactions — the strategy runs from the moment conditions are met.

Works without deploying any contracts. Session key enforcement handles authorization at the account level.

Spend limits per day, per session, or per action. Agent cannot exceed them regardless of what the strategy requests.

Spend limits per day, per session, or per action. Agent cannot exceed them regardless of what the strategy requests.

Receipts in <10ms. Limit order strategies viable at software cadence, not block time.

This is the primary launch narrative and demo

trading-agent.ts@megaeth-labs/wallet-sdk
await mega.grantPermissions({
  permissions: {
    expiry: now + 86_400,
    permissions: {
      calls: [{ to: wcmContractAddress, signature: "executeLimitOrder(uint256)" }],
      spend: [{ limit: Value.fromEther("5"), period: "day" }],
    },
  },
});

if (ethPrice <= targetPrice) {
  await mega.callContract({
    address: wcmContractAddress,
    abi: wcmAbi,
    functionName: "executeLimitOrder",
    args: [orderId],
    silent: true,
  });
}