back
loading skill details...
Set up a complete self-funding agent lifecycle in one command. Orchestrates 5 agents to take an agent from zero to self-sustaining: provisions wallet, optionally deploys token with V4 pool, configures treasury management, registers identity on ERC-8004, and sets up x402 micropayments. Use when user wants to make their agent self-funding, earn and manage its own revenue, or configure autonomous agent operations end-to-end.
---
name: self-funding-setup
description: >-
Set up a complete self-funding agent lifecycle in one command. Orchestrates
5 agents to take an agent from zero to self-sustaining: provisions wallet,
optionally deploys token with V4 pool, configures treasury management,
registers identity on ERC-8004, and sets up x402 micropayments. Use when
user wants to make their agent self-funding, earn and manage its own
revenue, or configure autonomous agent operations end-to-end.
model: opus
allowed-tools:
- Task(subagent_type:wallet-provisioner)
- Task(subagent_type:token-deployer)
- Task(subagent_type:treasury-manager)
- Task(subagent_type:identity-verifier)
- Read
- Write
- Edit
- Glob
- Grep
- mcp__uniswap__get_supported_chains
- mcp__uniswap__get_agent_balance
- mcp__uniswap__check_safety_status
---
# Self-Funding Setup
## Overview
The most complex composite skill in the system. Orchestrates 5 specialized agents in sequence to take an agent from zero infrastructure to a fully self-sustaining economic entity -- wallet, optional token, treasury management, on-chain identity, and payment acceptance -- in a single command.
**Why this is 10x better than setting up each component manually:**
1. **5 domains compressed into 1 command**: Wallet provisioning, token deployment, treasury management, identity registration, and payment configuration each require different expertise and tooling. Manually coordinating these takes hours and requires deep knowledge of Privy/Turnkey APIs, Uniswap V4 pool creation, DCA strategies, ERC-8004 registries, and x402 protocol. This skill handles all five.
2. **Context flows between stages**: Each agent receives the output of all prior agents. The treasury-manager knows the wallet address from Step 1 and the token address from Step 2. The identity-verifier registers the wallet from Step 1 with the capabilities demonstrated by Steps 2-3. Without this skill, you'd manually copy-paste addresses and configuration between five separate tools.
3. **Conditional pipeline**: Token deployment (Step 2) is optional -- skip it for agents that earn through services rather than token economics. The skill adapts the remaining steps based on which revenue model is selected.
4. **Rollback awareness**: If Step 3 fails, Steps 1 and 2 are still valid and preserved. The skill reports exactly which steps succeeded and which failed, so you can fix the issue and re-run from the failure point rather than starting over.
5. **Progressive output**: You see each stage complete in real-time with a running summary. By the end, you have a complete "agent identity card" showing every component of the self-funding infrastructure.
## When to Use
Activate when the user says anything like:
- "Set up my agent to be self-funding"
- "Make my agent earn and manage its own revenue"
- "Configure autonomous agent operations end-to-end"
- "I want my agent to be self-sustaining"
- "Set up the full agent economy stack"
- "Bootstrap my agent's financial infrastructure"
- "Create a self-funding agent from scratch"
- "Full agent setup: wallet, token, treasury, identity, payments"
**Do NOT use** when the user only wants one component (use the individual skills: `setup-agent-wallet`, `deploy-agent-token`, `manage-treasury`, `verify-agent`, or `configure-x402` respectively), or when the agent is already partially set up and only needs one missing piece.
## Parameters
| Parameter | Required | Default | How to Extract |
| ---------------- | -------- | ------- | ----------------------------------------------------------------------- |
| walletProvider | No | privy | "privy" (dev), "turnkey" (production), or "safe" (max security) |
| deployToken | No | false | Whether to deploy an agent token: "yes", "with token", "launch token" |
| tokenName | If token | -- | Token name if deploying: "AgentCoin", "MyBot Token" |
| tokenSymbol | If token | -- | Token symbol if deploying: "AGENT", "BOT" |
| chains | No | base | Operating chains: "base", "ethereum", "base,ethereum" |
| revenueModel | No | x402 | "x402" (micropayments), "token-fees" (swap fees), "lp-fees", or "all" |
| environment | No | dev | "dev" (development), "staging", or "production" |
| initialFunding | No | -- | Initial funding amount: "$100", "0.1 ETH" |
If the user says "with token" or "launch a token", set `deployToken=true` and ask for `tokenName` and `tokenSymbol` if not provided.
## Workflow
```
SELF-FUNDING SETUP PIPELINE
┌──────────────────────────────────────────────────────────────────────┐
│ │
│ Step 1: WALLET PROVISIONING (wallet-provisioner) │
│ ├── Determine provider: privy (dev) / turnkey (prod) / safe (max) │
│ ├── Provision wallet with signing capabilities │
│ ├── Configure spending policies │
│ ├── Fund with gas (2x estimated need) │
│ └── Output: Wallet address, provider, policies │
│ │ │
│ ▼ wallet address feeds into all subsequent steps │
│ │
│ Step 2: TOKEN DEPLOYMENT (token-deployer) [OPTIONAL] │
│ ├── Deploy ERC-20 token contract │
│ ├── Create Uniswap V4 pool with anti-snipe hooks │
│ ├── Bootstrap initial liquidity │
│ ├── Lock LP tokens (10 years default) │
│ └── Output: Token address, pool address, LP position │
│ │ │
│ ▼ token + pool info feeds into treasury config │
│ │
│ Step 3: TREASURY MANAGEMENT (treasury-manager) │
│ ├── Configure auto-conversion of earned fees to stablecoins │
│ ├── Set up DCA strategy for volatile holdings │
│ ├── Configure yield optimization for idle capital │
│ ├── Set circuit breaker thresholds │
│ └── Output: Treasury config, burn rate, runway projection │
│ │ │
│ ▼ wallet + capabilities feed into identity registration │
│ │
│ Step 4: IDENTITY REGISTRATION (identity-verifier) │
│ ├── Register agent on ERC-8004 Identity Registry │
│ ├── Set capabilities metadata (trading, LP, services) │
│ ├── Initialize reputation score │
│ └── Output: ERC-8004 identity, trust tier, registry tx │
│ │ │
│ ▼ identity + wallet feed into payment config │
│ │
│ Step 5: PAYMENT CONFIGURATION (direct) │
│ ├── Configure x402 micropayment acceptance │
│ ├── Set per-tool pricing │
│ ├── Generate .well-known/x402-manifest.json │
│ ├── Verify USDC balance for pay mode │
│ └── Output: x402 config, pricing, manifest │
│ │
│ ═══════════════════════════════════════════════════════════ │
│ FINAL: AGENT IDENTITY CARD │
│ ├── Wallet, token, treasury, identity, payments -- all linked │
│ └── Complete self-funding infrastructure report │
│ │
└──────────────────────────────────────────────────────────────────────┘
```
### Step 1: Wallet Provisioning
Delegate to `Task(subagent_type:wallet-provisioner)`:
```
Provision an agent wallet for self-funding operations:
- Provider: {walletProvider}
- Chains: {chains}
- Environment: {environment}
- Spending limit: $10,000/day (default for self-funding agents)
- Initial funding: {initialFunding} (or 2x estimated gas need)
This wallet will be used for:
- Token deployment (if enabled)
- Treasury management (fee conversion, LP)
- x402 payment settlement
- General agent operations
Configure appropriate spending policies for a self-funding agent.
```
**Present to user after completion:**
```text
Step 1/5: Wallet Provisioned
Address: 0xABCD...1234
Provider: Privy (development)
Chain: Base (8453)
Funded: 0.05 ETH ($98.00)
Policies: $10,000/day, Router + Permit2 approved
Proceeding to token deployment...
```
**If wallet already exists**, detect it via `mcp__uniswap__get_agent_balance` and skip to Step 2:
```text
Step 1/5: Wallet Already Configured (skipped)
Address: 0xABCD...1234
Balance: 0.12 ETH + 500 USDC
Status: Active
Skipping to next step...
```
### Step 2: Token Deployment (Optional)
**Only execute if `deployToken=true`.** Otherwise, skip to Step 3.
Delegate to `Task(subagent_type:token-deployer)`:
```
Deploy an agent token for self-funding:
- Token name: {tokenName}
- Token symbol: {tokenSymbol}
- Chain: {chains[0]} (primary chain)
- Wallet: {wallet address from Step 1}
- Paired token: WETH
- Hooks: anti-snipe (2-block delay) + revenue-share (5%)
- LP lock: 10 years
- Initial liquidity: {derive from initialFunding or suggest minimum}
This token is part of a self-funding agent setup. The revenue-share hook
directs 5% of swap fees to the agent wallet for treasury management.
```
**Present to user after completion:**
```text
Step 2/5: Token Deployed
Token: AgentCoin (AGENT)
Address: 0x5678...efgh
Chain: Base (8453)
Pool: AGENT/WETH V4 (0.3%, anti-snipe + revenue-share)
LP Lock: 10 years (unlocks 2036-02-10)
Revenue: 5% of swap fees -> agent wallet
Proceeding to treasury management...
```
**If `deployToken=false`:**
```text
Step 2/5: Token Deployment (skipped)
No token deployment requested.
Revenue model: {revenueModel} (no token economics)
Proceeding to treasury management...
```
### Step 3: Treasury Management
Delegate to `Task(subagent_type:treasury-manager)`:
```
Configure treasury management for a self-funding agent:
- Wallet: {wallet address from Step 1}
- Chains: {chains}
- Action: assess + configure (initial setup, not full operations)
Revenue sources:
{if deployToken: "- Token swap fees (5% revenue share from AGENT/WETH pool)"}
{if revenueModel includes x402: "- x402 micropayments (USDC on Base)"}
{if revenueModel includes lp-fees: "- LP fee earnings"}
Configure:
- Auto-convert non-stablecoin earnings to USDC
- Conversion threshold: $10 minimum
- DCA enabled for large conversions
- Circuit breaker: halt if treasury drops below $100
- Operating reserve: 30 days of estimated burn rate
```
**Present to user after completion:**
```text
Step 3/5: Treasury Configured
Treasury Value: $98.00 (initial funding)
Auto-Convert: Enabled (non-stables -> USDC, threshold: $10)
DCA: Enabled for conversions > 0.1% pool TVL
Circuit Breaker: $100 minimum (INACTIVE -- above threshold)
Burn Rate: ~$0/day (no operations yet)
Runway: Indefinite (no burn rate established)
Proceeding to identity registration...
```
### Step 4: Identity Registration
Delegate to `Task(subagent_type:identity-verifier)`:
```
Register this agent on ERC-8004:
- Agent address: {wallet address from Step 1}
- Chain: ethereum (ERC-8004 registries are on mainnet)
Capabilities to register:
{if deployToken: "- Token deployment and pool management"}
{if revenueModel includes x402: "- x402 service provider"}
- Uniswap trading and LP management
- Treasury management
After registration, query the trust tier to confirm.
```
**Present to user after completion:**
```text
Step 4/5: Identity Registered
ERC-8004: Registered on Identity Registry
Address: 0xABCD...1234
Trust Tier: BASIC (new registration)
Reputation: 0/100 (initial -- builds with activity)
Registry Tx: https://etherscan.io/tx/0x...
Proceeding to payment configuration...
```
### Step 5: Payment Configuration
Configure x402 micropayment acceptance directly (no agent needed):
1. Verify the wallet has USDC on the settlement chain (Base recommended).
2. Write `.uniswap/x402-config.json` with payment configuration.
3. Write `.well-known/x402-manifest.json` for service discovery.
```text
Step 5/5: Payments Configured
Mode: Accept (x402 micropayments)
Chain: Base (8453)
Wallet: 0xABCD...1234
Facilitator: Auto-selected
Pricing:
Price quotes: $0.001/call
Pool analytics: $0.003/call
Route optimization: $0.005/call
Simulation: $0.010/call
Execution: $0.050/call
Config Files:
.uniswap/x402-config.json
.well-known/x402-manifest.json
```
## Output Format
### Full Setup (with token)
```text
Self-Funding Agent Setup Complete
══════════════════════════════════════════════
AGENT IDENTITY CARD
══════════════════════════════════════════════
Wallet:
Address: 0xABCD...1234
Provider: Privy (development)
Chain: Base (8453)
Balance: 0.05 ETH + 0 USDC
Token:
Name: AgentCoin (AGENT)
Address: 0x5678...efgh
Pool: AGENT/WETH V4 (0.3%)
Hooks: Anti-snipe + Revenue Share (5%)
LP Lock: 10 years
Treasury:
Auto-Convert: Enabled (-> USDC)
Circuit Break: $100 minimum
Burn Rate: ~$0/day (initial)
Runway: Indefinite
Identity:
ERC-8004: Registered (BASIC tier)
Reputation: 0/100 (builds with activity)
Registry: 0x7177...09A
Payments:
x402: Accepting micropayments
Settlement: USDC on Base
Pricing: $0.001 - $0.050 per call
══════════════════════════════════════════════
Pipeline: Wallet -> Token -> Treasury -> Identity -> Payments
Status: ALL 5 STEPS COMPLETE
Next Steps:
1. Fund the wallet with USDC for x402 pay mode
2. Share your x402 manifest for service discovery
3. Start operations to build reputation (rep: 0 -> basic -> verified)
4. Monitor treasury health with /manage-treasury
```
### Setup Without Token
```text
Self-Funding Agent Setup Complete
══════════════════════════════════════════════
AGENT IDENTITY CARD
══════════════════════════════════════════════
Wallet:
Address: 0xABCD...1234
Provider: Privy (development)
Chain: Base (8453)
Balance: 0.05 ETH
Token: Not deployed (service-based revenue model)
Treasury:
Auto-Convert: Enabled (-> USDC)
Circuit Break: $100 minimum
Revenue: x402 micropayments
Identity:
ERC-8004: Registered (BASIC tier)
Reputation: 0/100
Payments:
x402: Accepting micropayments
Settlement: USDC on Base
══════════════════════════════════════════════
Pipeline: Wallet -> (Token skipped) -> Treasury -> Identity -> Payments
Status: ALL STEPS COMPLETE (4/5, token skipped)
```
### Partial Failure
```text
Self-Funding Agent Setup -- Partial
Step 1: Wallet COMPLETE (0xABCD...1234)
Step 2: Token COMPLETE (AGENT at 0x5678...efgh)
Step 3: Treasury FAILED (Could not configure auto-convert)
Step 4: Identity SKIPPED (depends on Step 3)
Step 5: Payments SKIPPED (depends on Step 4)
Error at Step 3: "Insufficient USDC balance for initial DCA configuration."
What's preserved:
- Wallet is provisioned and funded (Step 1)
- Token is deployed with pool and locked LP (Step 2)
To resume:
1. Fund wallet with USDC: send USDC to 0xABCD...1234
2. Re-run: "Set up self-funding" (will detect existing wallet + token)
```
## Important Notes
- **This is the most complex composite skill.** It orchestrates 5 agents sequentially, each feeding context to the next. Expect the full pipeline to take 2-5 minutes depending on chain conditions and whether token deployment is included.
- **Token deployment is irreversible.** Once a token is deployed and the pool is created, it cannot be undone. The skill simulates everything via safety-guardian before execution, but make sure the token name, symbol, and parameters are correct before confirming.
- **The pipeline is resumable.** If a step fails, prior steps are preserved. Re-running the skill detects existing wallet and token, skipping completed steps automatically.
- **ERC-8004 registration is on Ethereum mainnet.** Even if your agent operates on Base, the identity registry is on Ethereum. This requires a small amount of ETH on mainnet for the registration transaction.
- **Reputation starts at 0.** The initial trust tier is BASIC. Building reputation requires completing trades, providing liquidity, and receiving positive feedback from counterparties. Use the agent actively to progress from basic -> verified -> trusted.
- **x402 payments settle on Base by default.** Base has ~200ms settlement and low gas costs, making it ideal for micropayments. The wallet must hold USDC on Base to accept payments.
- **Revenue model affects treasury configuration.** "x402" mode configures for micropayment income. "token-fees" mode configures for swap fee revenue. "lp-fees" mode configures for LP earnings. "all" enables all three.
- **Development vs production providers.** Privy is recommended for development (fast setup, easy testing). Turnkey or Safe is recommended for production (TEE-backed signing, hardware security). The skill selects based on the `environment` parameter.
## Error Handling
| Error | User-Facing Message | Suggested Action |
| ----------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------- |
| Wallet provisioning failed | "Could not provision wallet: {reason}." | Check provider credentials and retry |
| Wallet already exists | "Agent wallet already configured. Skipping to next step." | Proceeds automatically with existing wallet |
| Token deployment failed | "Token deployment failed at step: {reason}. Wallet is preserved." | Fix the issue and re-run (wallet will be reused) |
| Token already deployed | "Token {symbol} already deployed. Skipping to treasury." | Proceeds automatically with existing token |
| Treasury config failed | "Treasury configuration failed: {reason}. Wallet and token preserved." | Fund wallet and re-run |
| ERC-8004 registration failed | "Could not register on ERC-8004: {reason}. Prior steps preserved." | Check ETH balance on mainnet and retry |
| x402 config failed | "Could not write x402 configuration: {reason}." | Check file permissions and retry |
| Insufficient funding | "Wallet needs at least {X} ETH for gas. Current: {Y} ETH." | Fund the wallet before proceeding |
| Chain not supported | "{chain} does not support all required features." | Use Base or Ethereum for full feature support |
| Partial pipeline failure | "Setup completed partially. Failed at step {N}: {reason}." | Fix the failed step and re-run from that point |
| Provider not configured | "Wallet provider '{provider}' requires credentials not found in environment." | Set required env vars (PRIVY_APP_ID, etc.) |
don't have the plugin yet? install it then click "run inline in claude" again.