Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
{"openclaw":{"requires":{"env":["KRYPTOGO_API_KEY","SOLANA_PRIVATE_KEY","SOLANA_WALLET_ADDRESS"],"bins":["python3","pip","openclaw"],"network":["wallet-data.kryptogo.app"],"permissions":["filesystem:write:~/.openclaw/workspace/.env","filesystem:write:~/.openclaw/workspace/memory/"],"runtime_installs":["pip: solders, requests (installed by scripts/setup.py on first run)"],"primaryEnv":"KRYPTOGO_API_KEY"}}}
KryptoGO Meme Trader Agent Skill
Overview
This skill enables an AI agent to autonomously analyze and trade meme coins through the KryptoGO platform. It combines deep on-chain cluster analysis with automated trade execution.
Tell the agent "I've set my API key in .env" — the agent will verify it works by calling /agent/account
Do NOT paste your API key directly in chat. Chat histories may be stored and could expose your key. Always set secrets via .env file or environment variables.
All credentials are stored in ~/.openclaw/workspace/.env — the OpenClaw workspace root. This ensures heartbeat/cron sessions can find them automatically.
The API key is tied to your KryptoGO account (for billing/tier), NOT to a specific wallet.
Your login wallet on kryptogo.xyz may differ from the agent's trading wallet.
2. Generate Agent Wallet
Run the setup script to create a dedicated Solana keypair:
python3 scripts/setup.py
This will:
Check Python 3.10+ and install solders + requests if missing
Generate a new Solana keypair
Save the private key (base58) and public address to ~/.openclaw/workspace/.env
Set .env permissions to 600 (owner read/write only)
Print the public address for the user to fund with SOL
3. Fund the Wallet
Send SOL to the agent's public address (minimum 0.1 SOL for gas + trading capital).
Security Rules
NEVER print, log, or include the private key in any message or CLI argument
NEVER accept secrets (API keys, private keys) pasted directly in chat — instruct users to set them in .env
NEVER commit .env to version control
NEVER use the Read tool on ~/.openclaw/workspace/.env — load credentials via source command only, which doesn't expose values in tool output
The private key stays in memory only during local signing — it is never sent to any server
.env must always have chmod 600
See Safety Guardrails for full credential handling and trading limits
Quickstart Checklist
After installing this skill, complete these steps in order:
All endpoints require Bearer token authentication:
Authorization: Bearer sk_live_<48 hex chars>
Some features (signal dashboard, KOL finder) additionally require Pro or Alpha tier subscription.
Tier
Daily API Calls
Trading Fee
Signal Dashboard
KOL Finder
Free
50 calls/day
1%
No
No
Pro
500 calls/day
0.5%
Yes
Yes
Alpha
5,000 calls/day
0%
Yes
Yes
Agent Behavior
Session Initialization
On every session start (including heartbeat/cron), the agent MUST load credentials before making any API calls:
source ~/.openclaw/workspace/.env
This makes KRYPTOGO_API_KEY, SOLANA_PRIVATE_KEY, and SOLANA_WALLET_ADDRESS available as environment variables. Do NOT use the Read tool on .env — the source command loads values without exposing them in tool output.
Autonomous Mode (Default)
Automatic actions (no user confirmation needed):
Scanning trending tokens (default: top 10 per scan)
Running full analysis pipeline on candidate tokens
Checking portfolio status and PnL
Executing trades that pass ALL criteria in the Bullish Checklist
Stop-loss sells when unrealized loss exceeds threshold
Take-profit sells when gain exceeds target
Requires user confirmation:
Risk level is "medium" (ambiguous signals)
Position size exceeds user-defined max
Selling at a loss outside stop-loss rules
Any action outside the defined entry/exit strategies
Reporting:
After each trade: summarize analysis result + trade details to the user (concise text, not raw JSON)
After each scan: brief summary of tokens scanned, why they passed/failed
On errors: report the issue and suggest next steps
User Preferences
The user can customize behavior by telling the agent their preferences. Store in memory/trading-preferences.json:
"conservative" (skip medium risk), "moderate" (ask on medium), "aggressive" (auto-trade medium)
chains
["solana"]
Chains to scan for analysis
Safety Guardrails
This skill handles real funds. These guardrails limit blast radius if credentials are mishandled or the agent malfunctions.
Credential Isolation
API key and private key are stored ONLY in ~/.openclaw/workspace/.env with chmod 600 (owner read/write)
The agent reads credentials via environment variables (source ~/.openclaw/workspace/.env) — they are never printed, logged, passed as CLI arguments, or included in chat messages
The agent must never use the Read tool on .env — the source command keeps values out of tool output
If a user pastes a secret in chat, the agent should warn them and suggest rotating it
Trading Limits (Hard Caps)
These limits apply even if user preferences set higher values:
Limit
Default
Can User Override?
Max single trade
0.1 SOL
Yes, via max_position_size in preferences
Max concurrent positions
5
Yes, via max_open_positions (default: 5)
Max daily trade count
20
Yes, via max_daily_trades (default: 20)
Price impact abort
>10%
No — always abort
Price impact warn
>5%
No — always warn user
If any limit is hit, the agent must stop and notify the user — never silently skip.
Autonomous Trading Scope
The agent only executes trades that pass ALL criteria in the Bullish Checklist (Step 6)
Ambiguous signals (risk = "medium") always require user confirmation
The agent cannot modify its own trading parameters — only propose changes for user approval
All trade executions are immediately reported to the user via the configured channel (Telegram, Discord, etc.)
Kill Switch
To immediately stop all autonomous trading:
Remove the Trading Agent section from HEARTBEAT.md — stops heartbeat-triggered trading
Run openclaw cron remove <name> — stops cron-triggered trading
Remove or rename .env — prevents any API calls or signing
The agent has no persistence mechanism beyond HEARTBEAT.md and cron entries. Removing those stops all autonomous behavior.
trading-journal.json — complete trade history with reasoning
trading-state.json — current positions and last scan time
trading-lessons.md — post-mortem analysis
These files are human-readable and can be reviewed at any time.
Heartbeat & Cron Integration
First-Time Auto-Setup
Agent instruction: The first time this skill is loaded in a conversation, check if HEARTBEAT.md already contains a "Trading Agent" section. If not, proactively offer to add it — ask the user: "I can set up periodic trading monitoring. Should I add it to your HEARTBEAT.md?" If confirmed, append the heartbeat block below.
Note: OpenClaw does not auto-modify HEARTBEAT.md on skill install. The agent must do this on first use.
Heartbeat — Periodic Monitoring (~30 min intervals)
Add the following to your HEARTBEAT.md:
## Trading Agent- Check portfolio: call /agent/portfolio, execute stop-loss/take-profit if triggered
- Scan for opportunities: use signal dashboard (Pro/Alpha) or trending tokens API
- Execute qualifying trades in autonomous mode
- Log closed trades to journal, run post-trade reflection, trigger strategy review if due
- ALWAYS report any trade executed to the user — never silent HEARTBEAT_OK after trading
Heartbeat is best for: 30-minute-level monitoring where slight timing drift is acceptable. Multiple checks (portfolio + scan) batch into a single heartbeat turn, saving API calls.
Cron — Precise Scheduling (5-15 min intervals)
For more frequent or precisely timed scans, use OpenClaw cron instead of heartbeat:
# Example: scan every 15 minutes during market hours (UTC)
openclaw cron add --every 15m --name "trading-scan" --prompt "Run the kryptogo-meme-trader scan workflow: check portfolio for stop-loss/take-profit, then scan top 10 trending tokens. Execute qualifying trades. Report any actions taken."# Example: daily portfolio summary at 9 AM Taipei time (1 AM UTC)
openclaw cron add --cron "0 1 * * *" --name "daily-portfolio" --prompt "Call /agent/portfolio and send me a daily summary of all open positions with PnL."# List active crons
openclaw cron list
# Remove a cron
openclaw cron remove trading-scan
Cron is best for: exact timing, high-frequency scans (every 5-15 min), standalone tasks that don't need conversational context, or when you want a different model/thinking level.
Recommendation: Use heartbeat for casual monitoring (check every ~30 min). Switch to cron if you want aggressive 5-15 min scan intervals or precise daily reports.
Heartbeat Workflow
Portfolio check → Call /agent/portfolio with agent's wallet address
Execute stop-loss if unrealized loss > stop_loss_pct
Execute take-profit if unrealized gain > take_profit_pct
Flag stale positions (held > 7 days with no significant movement)
Signal scan → Choose source based on subscription tier:
Pro/Alpha tier: Use /signal-dashboard first — these are system-curated accumulation signals (clusters actively buying). Higher quality than raw trending lists because they're pre-filtered for smart money activity. Parameters: chain_id, sort_by=signal_count, page_size=10.
Free tier: Fall back to /agent/trending-tokens with filters (min_market_cap, min_liquidity, etc.)
Run top results through the 7-step analysis pipeline
Auto-trade if all criteria pass; ask user if risk = "medium"
State persistence → Save to memory/trading-state.json
Tracks: last scan time, open positions, pending user reviews
On next session/heartbeat, read this file to resume state
Learning check → If any trades were closed since last check:
Log outcome to memory/trading-journal.json
Run post-trade reflection (mandatory for every closed trade)
If loss >20%, trigger Loss Post-Mortem
If 20+ trades accumulated or 7+ days since last review, trigger Strategy Review
Notification Rules
Mandatory — agent MUST message the user (never silent HEARTBEAT_OK) when:
Any trade is executed (buy or sell)
A stop-loss or take-profit is triggered
A position is flagged for manual review (medium risk, stale, etc.)
An error prevents normal operation (API down, insufficient SOL, quota exceeded)
Silent HEARTBEAT_OK is OK when:
Portfolio checked, no action needed
Tokens scanned, none qualified
Everything nominal
Failure Recovery
If the agent crashes or session ends mid-trade:
On startup, ALWAYS call /agent/portfolio first to check current holdings
Compare with memory/trading-state.json to detect any untracked positions
When a position is closed (sell), update the corresponding BUY entry's outcome:
{"outcome":{"exit_price":0.0000468,"exit_timestamp":"2026-02-26T09:15:00Z","exit_reason":"take_profit","pnl_sol":0.1,"pnl_pct":100.0,"holding_duration_hours":18.75,"cluster_ratio_at_exit":0.28,"lesson":"Cluster started distributing 2h before exit — could have sold earlier at higher price"}}
Mandatory Post-Trade Reflection
After every SELL (win or loss), the agent MUST:
Compare the entry reasoning with the actual outcome
Identify what the analysis got right and what it missed
Write a one-sentence lesson in the outcome record
If the loss was >20%, do a Loss Post-Mortem (see below)
Loss Post-Mortem
When a trade results in a loss >20%, the agent MUST perform a detailed post-mortem:
Re-run analysis on the token at current state — what changed since entry?
Identify the miss: Was it a signal that was there but ignored? An unexpected event? A parameter that was too loose?
Classify the loss type:
signal_miss — warning signs existed at entry but weren't weighted enough
timing_error — analysis was correct but entry/exit timing was wrong
