Agentic Wallets - Sei Docs

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.

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.

How it works

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

Agent decides: The LLM reasons about what onchain action to take (for example, “send 5 USDC to 0x…”).
SDK prepares: The wallet SDK builds and validates the transaction.
Policy check: The policy engine evaluates the transaction against spending limits, allowlists, and other guardrails.
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.
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 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 (for CDP wallet providers, not required for Viem)
A funded wallet on Sei

Setup

TypeScript
Python

Install packages

npm install @coinbase/agentkit @coinbase/agentkit-langchain viem

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.

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
  ],
});

Wire into LangChain

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?' }],
});

Install packages

pip install coinbase-agentkit coinbase-agentkit-langchain

Create the wallet provider

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))

Wire into LangChain

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?"}]
})

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

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 alongside AgentKit, or write custom action providers.

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) 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 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 with an App ID and App Secret
An authorization keypair (generated in the Privy dashboard)

Setup

REST API
Node.js SDK
Python SDK

Create a wallet

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:

{
  "id": "wallet_abc123",
  "address": "0x1234...abcd",
  "chain_type": "ethereum",
  "policy_ids": ["your_policy_id"]
}

Send a transaction on Sei

To target Sei Mainnet, use eip155:1329 (CAIP-2 format):

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
      }
    }
  }'

Sign a message

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"
    }
  }'

Install the SDK

npm install @privy-io/server-auth

Create a wallet and send a transaction

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);

Install the SDK

pip install privy-client

Create a wallet and send a transaction

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}")

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:

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?")

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) 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.

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.

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.

// "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],
});

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.

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:

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.

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.

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

For Sei-native DeFi actions, use the Cambrian Agent Kit. It includes built-in integrations for Symphony, DragonSwap, Silo, Takara, and Citrex.

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

Platform	Approach	Sei support	Best for
Turnkey	TEE-based key isolation, sub-100ms signing, granular policies	Yes (any EVM)	Enterprise agents that need fine-grained policies
Lit Protocol	Decentralized key management (DKG), programmable key pairs as NFTs	Yes (any EVM)	Decentralized, user-owned agent delegation
Dynamic	MPC or smart contract wallets, strong onboarding UX	Yes (explicit Sei support)	dApps that serve both humans and agents
thirdweb	Backend wallets + account abstraction, session keys	Yes (any EVM)	Broadest AI framework support (6+ frameworks)
Openfort	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	testnet.seiscan.io
Finality	~400ms	~400ms

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.

​How it works

​Quick comparison

​Coinbase AgentKit on Sei

​Architecture

​Prerequisites

​Setup

​Available action providers on Sei

​Known quirks on Sei

​CDP-managed wallets and Sei

​Privy server wallets on Sei

​Prerequisites

​Setup

​Known quirks on Sei (Privy)

​Privy with LangChain

​Privy policy engine

​Using AgentKit with Privy (combined)

​Feature matrix

​Wallet creation & key management

​Policy engine & guardrails

​Gas & transaction management

​Agentic DeFi actions

​x402 & machine-to-machine payments

​Developer experience

​Other agentic wallet solutions

​Sei network configuration reference

How it works

Quick comparison

Coinbase AgentKit on Sei

Architecture

Prerequisites

Setup

Available action providers on Sei

Known quirks on Sei

CDP-managed wallets and Sei

Privy server wallets on Sei

Prerequisites

Setup

Known quirks on Sei (Privy)

Privy with LangChain

Privy policy engine

Using AgentKit with Privy (combined)

Feature matrix

Wallet creation & key management

Policy engine & guardrails

Gas & transaction management

Agentic DeFi actions

x402 & machine-to-machine payments

Developer experience

Other agentic wallet solutions

Sei network configuration reference