> ## Documentation Index
> Fetch the complete documentation index at: https://seilabs-docs-evm-cookbook.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Agentic Wallets

> Build AI agents with secure, programmable wallets on Sei using Coinbase AgentKit or Privy server wallets. Includes setup guides, policy engines, and a full feature comparison.

Agentic wallets let AI agents hold funds, sign transactions, and interact with smart contracts autonomously. They do this without exposing private keys to the agent or the LLM. This page covers the two leading solutions that work on Sei today: Coinbase AgentKit and Privy server wallets.

<Info>
  Both platforms support Sei as an EVM-compatible chain. You do not need a special integration. Point the wallet provider at Sei's RPC and chain ID, and everything works with no other setup.
</Info>

## How it works

An agentic wallet sits between your AI agent and the blockchain:

1. **Agent decides**: The LLM reasons about what onchain action to take (for example, "send 5 USDC to 0x...").
2. **SDK prepares**: The wallet SDK builds and validates the transaction.
3. **Policy check**: The policy engine evaluates the transaction against spending limits, allowlists, and other guardrails.
4. **TEE signs**: The private key is isolated in a Trusted Execution Environment (TEE) and signs the transaction there. The key is never exposed to the agent.
5. **Broadcast**: The signed transaction is submitted to Sei's EVM RPC.

```
┌─────────┐     ┌───────────┐     ┌──────────────┐     ┌─────────┐     ┌──────────┐
│ LLM /   │────▶│ Wallet    │────▶│ Policy       │────▶│ TEE     │────▶│ Sei EVM  │
│ Agent   │     │ SDK       │     │ Engine       │     │ Signer  │     │ RPC      │
└─────────┘     └───────────┘     └──────────────┘     └─────────┘     └──────────┘
```

## Quick comparison

| Dimension | Coinbase AgentKit | Privy server wallets |
| - | - | - |
| **Type** | Open-source SDK + wallet infrastructure | Wallet-as-a-service API |
| **Key isolation** | Self-custodial on Sei (bring-your-own key with Viem). CDP's TEE-managed signer does not support Sei. | TEE + Shamir secret sharing |
| **Sei support** | With `ViemWalletProvider` (TS) or `EthAccountWalletProvider` (Python) | With CAIP-2 `eip155:1329` |
| **Policy engine** | Spending limits, address/contract allowlists, network restrictions | All of the above + time-based controls, key quorums |
| **Built-in actions** | 40+ action providers. Wallet, ERC-20, ERC-721, and Pyth work on Sei. Many others are Base/Ethereum-only. | Wallet operations only (create, sign, send) |
| **AI frameworks** | LangChain, Vercel AI SDK, OpenAI Agents SDK, MCP | LangChain (`langchain-privy`) |
| **Server SDKs** | TypeScript, Python | TypeScript, Python, Java, Rust, Go + REST API |
| **Open source** | Yes (MIT) | Partial (`langchain-privy` is open source) |
| **Pricing** | Free SDK. CDP wallets \$0.005/op (5K free/mo). | Free 50K sigs/mo. Paid tiers from \$299/mo. |

You can also use both together. AgentKit includes a built-in `PrivyWalletProvider`, so you can combine Privy's policy engine with AgentKit's 40+ action providers.

***

## Coinbase AgentKit on Sei

[AgentKit](https://github.com/coinbase/agentkit) is Coinbase's open-source toolkit that gives AI agents crypto wallets and onchain capabilities. It is framework-agnostic (LangChain, Vercel AI SDK, OpenAI Agents SDK, MCP) and wallet-agnostic (CDP wallets, Privy, Viem, and others).

### Architecture

AgentKit is organized around three concepts:

* **Wallet providers**: An abstraction over different wallet implementations. For Sei, use `ViemWalletProvider` (TypeScript) or `EthAccountWalletProvider` (Python).
* **Action providers**: Units of onchain functionality, such as ERC-20 transfers, ERC-721 operations, and Pyth price feeds. Generic EVM providers work on Sei, but providers with hard-coded chain allowlists do not. These include `x402ActionProvider`, `wethActionProvider`, and CDP-managed providers. See the support matrix below.
* **Framework extensions**: Adapters that turn AgentKit actions into tools for your AI framework.

### Prerequisites

* Node.js v22+ (TypeScript) or Python 3.10+
* A [CDP Secret API Key](https://portal.cdp.coinbase.com/) (for CDP wallet providers, not required for Viem)
* A funded wallet on Sei

### Setup

<Tabs>
  <Tab title="TypeScript">
    <Steps>
      <Step title="Install packages">
        ```bash theme={null}
        npm install @coinbase/agentkit @coinbase/agentkit-langchain viem
        ```
      </Step>

      <Step title="Create the wallet provider and AgentKit">
        Viem includes `sei` (chain ID `1329`) and `seiTestnet` (chain ID `1328`), so you can import them directly from `viem/chains`.

        ```typescript theme={null}
        import { AgentKit, ViemWalletProvider, walletActionProvider, erc20ActionProvider } from '@coinbase/agentkit';
        import { createWalletClient, http } from 'viem';
        import { privateKeyToAccount } from 'viem/accounts';
        import { sei } from 'viem/chains';

        // Create a Viem wallet client pointed at Sei
        const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
        const client = createWalletClient({
          account,
          chain: sei,
          transport: http('https://evm-rpc.sei-apis.com'),
        });

        // Wrap it in AgentKit
        const walletProvider = new ViemWalletProvider(client);
        const agentKit = await AgentKit.from({
          walletProvider,
          actionProviders: [
            walletActionProvider(),
            erc20ActionProvider(),
            // Add more action providers as needed
          ],
        });
        ```
      </Step>

      <Step title="Wire into LangChain">
        ```typescript theme={null}
        import { getLangChainTools } from '@coinbase/agentkit-langchain';
        import { ChatOpenAI } from '@langchain/openai';
        import { createReactAgent } from '@langchain/langgraph/prebuilt';

        const tools = await getLangChainTools(agentKit);
        const model = new ChatOpenAI({ model: 'gpt-4o' });

        const agent = createReactAgent({
          llm: model,
          tools,
          messageModifier:
            'You are an AI agent operating on the Sei blockchain. You can check balances, transfer tokens, and interact with smart contracts.',
        });

        // Run the agent
        const result = await agent.invoke({
          messages: [{ role: 'user', content: 'What is my SEI balance?' }],
        });
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Python">
    <Steps>
      <Step title="Install packages">
        ```bash theme={null}
        pip install coinbase-agentkit coinbase-agentkit-langchain
        ```
      </Step>

      <Step title="Create the wallet provider">
        ```python theme={null}
        from coinbase_agentkit import (
            AgentKit,
            AgentKitConfig,
            EthAccountWalletProvider,
            EthAccountWalletProviderConfig,
        )
        from eth_account import Account

        account = Account.from_key("YOUR_PRIVATE_KEY")

        wallet_provider = EthAccountWalletProvider(
            config=EthAccountWalletProviderConfig(
                account=account,
                chain_id=1329,  # Sei Mainnet
                rpc_url="https://evm-rpc.sei-apis.com",
            )
        )

        agent_kit = AgentKit(AgentKitConfig(wallet_provider=wallet_provider))
        ```
      </Step>

      <Step title="Wire into LangChain">
        ```python theme={null}
        from coinbase_agentkit_langchain import get_langchain_tools
        from langchain_openai import ChatOpenAI
        from langgraph.prebuilt import create_react_agent

        tools = get_langchain_tools(agent_kit)
        model = ChatOpenAI(model="gpt-4o")

        agent = create_react_agent(
            model,
            tools=tools,
            state_modifier="You are an AI agent on the Sei blockchain.",
        )

        result = agent.invoke({
            "messages": [{"role": "user", "content": "What is my SEI balance?"}]
        })
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

### Available action providers on Sei

Not every AgentKit action provider works on Sei, because some are chain-specific. This table shows which providers you can use:

| Action provider | Works on Sei | Notes |
| - | - | - |
| `walletActionProvider` | Yes | Balance, transfers, native SEI operations |
| `erc20ActionProvider` | Yes | Any ERC-20 token, such as USDC or WSEI |
| `erc721ActionProvider` | Yes | NFT minting, transfers |
| `pythActionProvider` | Yes | Pyth price feeds through Hermes (off-chain, chain-agnostic) |
| `wethActionProvider` | No | Hard-coded WETH addresses with no WSEI entry. Use `erc20ActionProvider` with Sei's WSEI contract instead. |
| `x402ActionProvider` | No | The provider's `SUPPORTED_NETWORKS` allowlist is limited to `base-mainnet`, `base-sepolia`, `solana-mainnet`, and `solana-devnet`. The x402 protocol itself is chain-agnostic. If you need x402 on Sei, write a custom action provider or call the facilitator directly. |
| `cdpApiActionProvider` | No | Requires a Coinbase `networkId`. Sei is not in AgentKit's chain map. |
| `morphoActionProvider` | No | Morpho contracts are not deployed on Sei |
| `moonwellActionProvider` | No | Moonwell contracts are not deployed on Sei |

<Info>
  Sei-native DeFi actions include swaps on Symphony or DragonSwap, staking through Silo, and lending through Takara. For these actions, use the [Cambrian Agent Kit](/ai/cambrian-agent-kit) alongside AgentKit, or write custom action providers.
</Info>

### Known quirks on Sei

These quirks were verified with AgentKit `0.10.4` against Sei Testnet (`chain 1328`). They are in AgentKit's network and action-provider layer, and they apply to both `ViemWalletProvider` and `PrivyWalletProvider`:

* **Balances are labeled "ETH" in action output.** `walletActionProvider` hard-codes the native-currency symbol. Even on Sei, `get_wallet_details` returns strings like `Native Balance: 512993.50 ETH`, and `native_transfer` responses say `Transferred 0.05 ETH to 0x...`. The quirk affects only the display, not signing or arithmetic. If the LLM quotes balances or transfer confirmations to users, rewrite `ETH` to `SEI` when `chain_id == 1329 || 1328`. Use a post-processing step or a system-prompt instruction.
* **`networkId` is `undefined`.** Coinbase's internal `CHAIN_ID_TO_NETWORK_ID` map includes only Ethereum, Polygon, Base, Arbitrum, and Optimism (mainnet and testnet). Sei's chain IDs are not in the map, so `walletProvider.getNetwork()` returns `{ protocolFamily: 'evm', chainId: '1328', networkId: undefined }`. This is harmless for signing and sending, but any action provider that branches on `networkId` refuses to run on Sei. In practice, `AgentKit.from({...})` prints a warning like `The following action providers are not supported on the current network and will be unavailable: weth, x402` and silently drops those providers. If you expect an action and it is missing from `agentKit.getActions()`, check this warning first.

### CDP-managed wallets and Sei

AgentKit's `CdpEvmWalletProvider` (CDP-managed server wallets with built-in policies) currently supports only `base`, `base-sepolia`, `ethereum`, `ethereum-sepolia`, `polygon`, `arbitrum`, and `optimism`. **Sei is not a supported network.**

For managed cloud custody with a policy engine on Sei, use one of these options:

* **Privy server wallets** (below): TEE-isolated keys with a policy engine that works on any EVM chain, including Sei.
* **AgentKit and Privy combined**: Use `PrivyWalletProvider` inside AgentKit. You keep the 40+ action providers, and Privy handles custody and policy enforcement. See [Using AgentKit with Privy (combined)](#using-agentkit-with-privy-combined) below.

If you only need self-custodial keys, use `ViemWalletProvider` as shown above. In this setup, you hold the private key and there is no TEE. Enforce limits in your own application logic.

***

## Privy server wallets on Sei

[Privy](https://docs.privy.io/) offers wallet-as-a-service infrastructure for AI agents. Server wallets are programmatically managed wallets designed for backend use. They do not require user interaction. Keys are isolated in TEEs with Shamir secret sharing and never leave secure enclaves.

### Prerequisites

* A [Privy account](https://dashboard.privy.io/) with an App ID and App Secret
* An authorization keypair (generated in the Privy dashboard)

### Setup

<Tabs>
  <Tab title="REST API">
    <Steps>
      <Step title="Create a wallet">
        ```bash theme={null}
        curl --request POST https://api.privy.io/v1/wallets \
          -u "<your-app-id>:<your-app-secret>" \
          -H "privy-app-id: <your-app-id>" \
          -H 'Content-Type: application/json' \
          -d '{
            "chain_type": "ethereum",
            "policy_ids": ["your_policy_id"]
          }'
        ```

        Response:

        ```json theme={null}
        {
          "id": "wallet_abc123",
          "address": "0x1234...abcd",
          "chain_type": "ethereum",
          "policy_ids": ["your_policy_id"]
        }
        ```
      </Step>

      <Step title="Send a transaction on Sei">
        To target Sei Mainnet, use `eip155:1329` (CAIP-2 format):

        ```bash theme={null}
        curl --request POST https://api.privy.io/v1/wallets/wallet_abc123/rpc \
          -u "<your-app-id>:<your-app-secret>" \
          -H "privy-app-id: <your-app-id>" \
          -H "privy-authorization-signature: <authorization-signature>" \
          -H 'Content-Type: application/json' \
          -d '{
            "method": "eth_sendTransaction",
            "caip2": "eip155:1329",
            "params": {
              "transaction": {
                "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
                "value": "0x2386F26FC10000",
                "chain_id": 1329
              }
            }
          }'
        ```
      </Step>

      <Step title="Sign a message">
        ```bash theme={null}
        curl --request POST https://api.privy.io/v1/wallets/wallet_abc123/rpc \
          -u "<your-app-id>:<your-app-secret>" \
          -H "privy-app-id: <your-app-id>" \
          -H "privy-authorization-signature: <authorization-signature>" \
          -H 'Content-Type: application/json' \
          -d '{
            "method": "personal_sign",
            "caip2": "eip155:1329",
            "params": {
              "message": "Hello from Sei"
            }
          }'
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Node.js SDK">
    <Steps>
      <Step title="Install the SDK">
        ```bash theme={null}
        npm install @privy-io/server-auth
        ```
      </Step>

      <Step title="Create a wallet and send a transaction">
        ```typescript theme={null}
        import { PrivyClient } from '@privy-io/server-auth';
        import { parseEther } from 'viem';

        const privy = new PrivyClient('<your-app-id>', '<your-app-secret>', {
          walletApi: { authorizationPrivateKey: process.env.PRIVY_AUTH_KEY },
        });

        // Create a server wallet
        const wallet = await privy.walletApi.createWallet({ chainType: 'ethereum' });
        console.log('Wallet address:', wallet.address);

        // Send a transaction on Sei
        // NOTE: `value` must be a hex string — Privy's request signer can't
        // serialize a BigInt, so don't pass `parseEther(...)` directly.
        const { hash } = await privy.walletApi.ethereum.sendTransaction({
          walletId: wallet.id,
          caip2: 'eip155:1329', // Sei Mainnet
          transaction: {
            to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
            value: '0x' + parseEther('0.01').toString(16),
            chainId: 1329,
          },
        });
        console.log('Transaction hash:', hash);
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Python SDK">
    <Steps>
      <Step title="Install the SDK">
        ```bash theme={null}
        pip install privy-client
        ```
      </Step>

      <Step title="Create a wallet and send a transaction">
        ```python theme={null}
        from privy import PrivyAPI

        client = PrivyAPI(app_id="<your-app-id>", app_secret="<your-app-secret>")

        # Create a server wallet
        wallet = client.wallets.create(chain_type="ethereum")
        print(f"Wallet address: {wallet.address}")

        # Send a transaction on Sei
        result = client.wallets.rpc(
            wallet_id=wallet.id,
            method="eth_sendTransaction",
            caip2="eip155:1329",  # Sei Mainnet
            params={
                "transaction": {
                    "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
                    "value": "0x2386F26FC10000",
                    "chain_id": 1329,
                }
            },
        )
        print(f"Transaction hash: {result.hash}")
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

### Known quirks on Sei (Privy)

These quirks were verified with `@privy-io/server-auth` `1.32.5` against Sei Testnet (`eip155:1328`):

* **`value` must be a hex string, not a `BigInt`.** Privy's request signer uses RFC 8785 JSON canonicalization (`canonicalize`). If you pass a `BigInt` in any field of the `transaction` object, the signer throws `TypeError: Do not know how to serialize a BigInt`. Before you send, convert viem's `parseEther(...)` output with `'0x' + parseEther('0.01').toString(16)`.
* **`authorizationKeyIds` on `createWallet` expects the public-key registration ID, not the dashboard key ID.** If you pass the ID shown next to a key in the Privy dashboard, the call can fail with `400 Invalid authorization key IDs`. If you only need an app-owned wallet (app credentials and `authorizationPrivateKey` for request signing), omit `authorizationKeyIds`. The wallet is still fully operable.

### Privy with LangChain

Privy publishes a LangChain integration (`langchain-privy`) that exposes wallet operations as a single LangChain tool. The tool reads `PRIVY_APP_ID` and `PRIVY_APP_SECRET` from the environment. You bind it directly to the LLM:

```python theme={null}
import os
from langchain_privy import PrivyWalletTool
from langchain_openai import ChatOpenAI

os.environ["PRIVY_APP_ID"] = "<your-app-id>"
os.environ["PRIVY_APP_SECRET"] = "<your-app-secret>"

tool = PrivyWalletTool()
print(f"Wallet: {tool.wallet_address}")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
llm_with_tools = llm.bind_tools([tool])

response = llm_with_tools.invoke("What is my wallet address?")
```

<Warning>
  For Sei, use one of these options instead of the built-in LangChain tool:

  * Call Privy's REST API or server-auth SDK directly with `caip2: eip155:1329`, as shown above.
  * Use AgentKit's `PrivyWalletProvider` with a LangChain adapter (`@coinbase/agentkit-langchain`). See [Using AgentKit with Privy (combined)](#using-agentkit-with-privy-combined) below.

  As of `langchain-privy@0.1.0`, the library's `Chain` enum does not include Sei. The built-in tool targets only Ethereum, Base, Optimism, Arbitrum, Polygon, Zora, Avalanche, BSC, Celo, Linea, Solana, and Bitcoin.
</Warning>

### Privy policy engine

Privy's policy engine evaluates policies server-side before signing. Each rule pairs an `ALLOW` or `DENY` action with an RPC `method` and a list of `conditions` on transaction fields. To attach one or more policies to a wallet, use `updateWallet`.

<Warning>
  Always start from an explicit `ALLOW` rule that describes the happy path. Then add `DENY` rules on top. **Privy's engine is default-deny.** It allows a request only when at least one `ALLOW` rule matches and no `DENY` rule matches. A policy built only from `DENY` rules blocks every transaction, including transactions you expect to pass.
</Warning>

```typescript theme={null}
// "Cap sends at 10 SEI and block a specific address."
// Rule 1 (ALLOW) defines the happy path; without it, every request is denied.
// Rule 2 (DENY) carves a specific hole in that allow.
const policy = await privy.walletApi.createPolicy({
  name: 'sei-agent-policy',
  version: '1.0',
  chainType: 'ethereum',
  rules: [
    {
      name: 'Allow sends up to 10 SEI',
      action: 'ALLOW',
      method: 'eth_sendTransaction',
      conditions: [
        {
          fieldSource: 'ethereum_transaction',
          field: 'value',
          operator: 'lte',
          value: '10000000000000000000', // 10 SEI in wei
        },
      ],
    },
    {
      name: 'Deny sends to blocklisted address',
      action: 'DENY',
      method: 'eth_sendTransaction',
      conditions: [
        {
          fieldSource: 'ethereum_transaction',
          field: 'to',
          operator: 'in',
          value: ['0xdEAD000000000000000042069420694206942069'],
        },
      ],
    },
  ],
});

// Attach policy to wallet
await privy.walletApi.updateWallet({
  id: wallet.id,
  policyIds: [policy.id],
});
```

<Info>
  Conditions support the `eq`, `gt`, `gte`, `lt`, `lte`, and `in` operators against `ethereum_transaction` fields (`to`, `value`) or `ethereum_calldata` fields. The operand order is `tx_field <operator> rule_value`. For example, `operator: 'lte'` with `value: '10000000000000000000'` means "transaction value ≤ 10 SEI". `method` must be `eth_sendTransaction` or `eth_signTransaction`. Chain restriction is not a policy condition. To keep an agent on Sei, enforce `caip2: 'eip155:1329'` at the call site.
</Info>

Privy also has features beyond the policy engine:

* **Key quorums**: require multiple authorization keys to approve high-value transactions
* **Webhook notifications**: get notifications for all wallet activity, on any chain

***

## Using AgentKit with Privy (combined)

AgentKit includes a built-in `PrivyWalletProvider`. With it, you can use Privy's wallet infrastructure and policy engine as the backend, and AgentKit's 40+ action providers for onchain operations.

Because of the `authorizationKeyIds` quirk noted above, the simplest working pattern has two steps. First, create the wallet once with the Privy SDK (or the dashboard). Then pass the resulting `walletId` to AgentKit:

```typescript theme={null}
import { AgentKit, PrivyWalletProvider, walletActionProvider, erc20ActionProvider } from '@coinbase/agentkit';
import { PrivyClient } from '@privy-io/server-auth';

// Step 1 — create (or look up) a server wallet via the Privy SDK.
// Omit authorizationKeyIds here; attach policies with updateWallet if needed.
const privy = new PrivyClient(process.env.PRIVY_APP_ID!, process.env.PRIVY_APP_SECRET!, {
  walletApi: { authorizationPrivateKey: process.env.PRIVY_AUTH_KEY },
});
const wallet = await privy.walletApi.createWallet({ chainType: 'ethereum' });

// Step 2 — wrap the existing wallet in AgentKit's PrivyWalletProvider.
const walletProvider = await PrivyWalletProvider.configureWithWallet({
  appId: process.env.PRIVY_APP_ID!,
  appSecret: process.env.PRIVY_APP_SECRET!,
  chainId: '1329', // Sei Mainnet
  walletId: wallet.id,
  authorizationPrivateKey: process.env.PRIVY_AUTH_KEY,
});

const agentKit = await AgentKit.from({
  walletProvider,
  actionProviders: [
    walletActionProvider(),
    erc20ActionProvider(),
  ],
});
```

This setup combines Privy's fine-grained policies and key quorums with AgentKit's action library.

<Warning>
  Always create the wallet first and pass `walletId`. If you call `PrivyWalletProvider.configureWithWallet` **without** a `walletId`, AgentKit tries to create a new wallet for you. It passes `authorizationKeyId` through to Privy, which causes the same `400 Invalid authorization key IDs` failure described in the Privy quirks above.
</Warning>

***

## Feature matrix

### Wallet creation & key management

| Capability | Coinbase AgentKit | Privy |
| - | - | - |
| Programmatic wallet creation on Sei | Yes, self-custodial with `ViemWalletProvider` (you hold the key). CDP-managed server wallets do not currently support Sei. | Yes, with server wallets on any EVM chain |
| TEE-secured key isolation on Sei | No. CDP's TEE signer is scoped to Base/Ethereum/Polygon/Arbitrum/Optimism. Use Privy (standalone or through `PrivyWalletProvider` in AgentKit). | Yes, with TEE + key sharding |
| Managed cloud custody on Sei | Not through CDP. Yes, through `PrivyWalletProvider`. | Yes, with server wallets and `eip155:1329` |
| Multi-party key quorum | No | Yes, with authorization key quorums through the dashboard |
| Key export / portability | Yes | Yes |

### Policy engine & guardrails

| Capability | Coinbase AgentKit | Privy |
| - | - | - |
| Spending limits (per-tx) on Sei | Only through app-level checks with `ViemWalletProvider`. CDP's `ethValue` policy does not apply on Sei. | Yes, with the policy engine on any chain |
| Contract / address allowlisting on Sei | Only through app-level checks with `ViemWalletProvider`. CDP's `evmAddress` policy does not apply on Sei. | Yes, with contract allowlist rules |
| Network restriction policies on Sei | N/A. CDP networkIds do not include Sei. | Yes, with chain restrictions |
| Time-based access controls | No | Yes |
| Transaction simulation | No | No. Needs a Sei-specific RPC. |

### Gas & transaction management

| Capability | Coinbase AgentKit | Privy |
| - | - | - |
| Gasless / sponsored transactions on Sei | No. Gasless is Base-only. | No. Requires a Sei-native paymaster. |
| Smart wallet (ERC-4337) on Sei | No. Smart Accounts do not include Sei. | No, but possible through a ZeroDev or Biconomy integration |
| Batch transactions on Sei | No. Requires Smart Accounts. | Yes |
| Basic send / transfer on Sei | Yes | Yes |
| ERC-20 token operations on Sei | Yes, with `erc20ActionProvider` | Yes, with standard EVM operations |

### Agentic DeFi actions

| Capability | Coinbase AgentKit | Privy |
| - | - | - |
| Token swaps on Sei DEXs | No. Built-in swap providers (Jupiter, 0x, Sushi, Enso) do not route Sei DEXs. | No |
| Yield / lending on Sei | No. Built-in lending providers (Morpho, Moonwell, Compound, Yelay) are not deployed on Sei. | No |
| Liquidity provision on Sei | No | No |
| Cross-chain bridge to/from Sei | No. Sei is not a listed Across route. | No |
| Pyth oracle price feeds | Yes, `pythActionProvider` works on Sei | No |

<Info>
  For Sei-native DeFi actions, use the [Cambrian Agent Kit](/ai/cambrian-agent-kit). It includes built-in integrations for Symphony, DragonSwap, Silo, Takara, and Citrex.
</Info>

### x402 & machine-to-machine payments

| Capability | Coinbase AgentKit | Privy |
| - | - | - |
| x402 protocol support on Sei | Not with the built-in `x402ActionProvider` (its allowlist is Base + Solana only). Possible with a custom action provider. | Yes. Works wherever the agent holds stablecoins. |
| Agent-to-agent USDC transfers | Yes, with ERC-20 transfers of Sei USDC | Yes, with server wallet transfers |
| Stablecoin operations on Sei | Yes, with `erc20ActionProvider` + Sei USDC | Yes, with standard ERC-20 operations |

### Developer experience

| Capability | Coinbase AgentKit | Privy |
| - | - | - |
| MCP server integration | Yes, through the AgentKit MCP framework extension | No |
| LangChain / Vercel AI SDK | Yes, with framework extensions for both | Yes, with `langchain-privy` |
| OpenAI Agents SDK | Yes, with a native extension | No |
| Webhook / event monitoring on Sei | No. Webhooks are for supported networks only. | Yes, with chain-agnostic webhooks |
| Multi-language SDKs | TypeScript, Python | TypeScript, Python, Java, Rust, Go + REST |

***

## Other agentic wallet solutions

Coinbase AgentKit and Privy are the most mature options for Sei. Several other platforms also support agentic wallet use cases:

| Platform | Approach | Sei support | Best for |
| - | - | - | - |
| [Turnkey](https://docs.turnkey.com/products/embedded-wallets/features/agentic-wallets) | TEE-based key isolation, sub-100ms signing, granular policies | Yes (any EVM) | Enterprise agents that need fine-grained policies |
| [Lit Protocol](https://developer.litprotocol.com/) | Decentralized key management (DKG), programmable key pairs as NFTs | Yes (any EVM) | Decentralized, user-owned agent delegation |
| [Dynamic](https://www.dynamic.xyz/ecosystems/sei) | MPC or smart contract wallets, strong onboarding UX | Yes (explicit Sei support) | dApps that serve both humans and agents |
| [thirdweb](https://thirdweb.com/) | Backend wallets + account abstraction, session keys | Yes (any EVM) | Broadest AI framework support (6+ frameworks) |
| [Openfort](https://www.openfort.io/solutions/ai-agents) | TEE server wallets, sub-125ms signing, 25+ EVM chains | Yes (any EVM) | Gaming and high-throughput agent workloads |

***

## Sei network configuration reference

Use these values when you configure any agentic wallet provider for Sei:

| Parameter | Mainnet | Testnet |
| - | - | - |
| **Chain ID** | `1329` | `1328` |
| **Chain ID (hex)** | `0x531` | `0x530` |
| **CAIP-2** | `eip155:1329` | `eip155:1328` |
| **RPC URL** | `https://evm-rpc.sei-apis.com` | `https://evm-rpc-testnet.sei-apis.com` |
| **Currency** | SEI (18 decimals) | SEI (18 decimals) |
| **Block explorer** | [seiscan.io](https://seiscan.io) | [testnet.seiscan.io](https://testnet.seiscan.io) |
| **Finality** | \~400ms | \~400ms |

<Warning>
  **Security reminders:**

  * Never expose private keys or authorization secrets to the LLM or agent process.
  * Always use dedicated wallets for agent operations. Never use your main wallet.
  * Start on Sei Testnet (`eip155:1328`) before you deploy to Sei Mainnet.
  * Before you go live, set spending limits and contract allowlists in the policy engine.
  * Monitor agent wallet activity with block explorers or webhook notifications.
</Warning>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.