Build a custom OpenClaw skill that acts as a setup wizard for autonomous betting agents. No APIs, no dependencies — just a knowledge skill that maps your goals, budget, and technical level to the right tools from the Agent Betting Stack.
Why Your Agent Needs a Stack Advisor
There are now over 40 tools, APIs, and platforms relevant to autonomous betting. The Odds API for sportsbook data. Polymarket and Kalshi for prediction markets. Moltbook for agent identity. Coinbase for on-chain wallets. Kelly criterion for sizing. CLV tracking for edge validation.
Nobody needs all of them. Most people need three or four, but which three or four depends on whether you’re building a sports betting scanner, a prediction market trader, or a cross-market arbitrage engine.
The agent-betting-stack-advisor skill solves the cold-start problem. Instead of reading ten guides and piecing together a stack yourself, your agent asks a few questions and outputs a concrete checklist — the right skills to install, APIs to configure, and guides to read, in the right order.
This is a Meta skill that spans all four layers of the Agent Betting Stack. It doesn’t fetch odds or calculate anything. It reads your intent and maps it to the stack.
What You’re Building
The agent-betting-stack-advisor skill teaches your OpenClaw agent four operations:
- Assess goals — Determine if the user wants sports betting, prediction markets, or both
- Recommend a stack — Map goals to specific skills, APIs, and tools across all four layers
- Generate a setup checklist — Ordered steps with cost estimates and time-to-deploy
- Suggest next reads — Link to the most relevant AgentBets guides for their chosen path
The skill is pure knowledge — no API keys, no binary dependencies, no external calls. It runs on any OpenClaw installation out of the box.
Prerequisites
- OpenClaw installed and running — Any channel (WhatsApp, Telegram, Discord, WebChat)
That’s it. This is a zero-dependency knowledge skill.
The Agent Betting Stack Framework
Before diving into the SKILL.md, here’s the framework the advisor maps to:
| Layer | Purpose | Example Tools |
|---|---|---|
| Layer 1 — Identity | Agent reputation, authentication | Moltbook, DID credentials |
| Layer 2 — Wallet | Bankroll tracking, capital management | Coinbase wallets, bankroll-manager skill |
| Layer 3 — Trading | Price discovery, market monitoring | odds-scanner, polymarket-monitor, kalshi-tracker |
| Layer 4 — Intelligence | Edge calculation, position sizing | kelly-sizer, ev-calculator, clv-tracker |
Most users start at Layer 3 and expand outward. The advisor skill understands this and doesn’t recommend Layer 1 identity infrastructure to someone who just wants to check NBA odds.
Budget Tiers
The advisor categorizes setups into three tiers:
Free Tier ($0/month)
- The Odds API free plan (500 requests/month)
- Polymarket public API (unlimited reads)
- Kalshi public API (unlimited reads)
- OpenClaw (open source)
- Local SQLite for storage
Hobby Tier (~$25/month)
- The Odds API paid plan (higher limits)
- Persistent VPS for cron jobs
- Multiple skill compositions
Pro Tier ($100+/month)
- Premium data feeds
- Multiple platform integrations
- Dedicated compute
- Full four-layer stack
The Complete SKILL.md
Create the skill directory:
mkdir -p ~/.openclaw/skills/agent-betting-stack-advisor
Create ~/.openclaw/skills/agent-betting-stack-advisor/SKILL.md with this content:
---
name: agent-betting-stack-advisor
description: "Recommend the right tools, APIs, and OpenClaw skills for building an autonomous betting agent. Assesses user goals (sports betting, prediction markets, or hybrid), budget, and technical level. Maps to the four-layer Agent Betting Stack. Use when asked about getting started, what tools to use, or how to build a betting agent."
metadata:
openclaw:
emoji: "🗺️"
requires:
bins: []
---
# Agent Betting Stack Advisor
Personalized setup wizard for autonomous betting agents. Recommends tools, skills, and APIs based on your goals.
# When to Use
Use this skill when the user asks about:
- How to build a betting agent or get started
- What tools or APIs they need
- Which OpenClaw skills to install first
- Budget planning for an agent setup
- Choosing between sports betting vs prediction markets
- The Agent Betting Stack framework
# Assessment Questions
Before recommending a stack, gather this information from the user:
### 1. Primary Goal
Ask: "What do you want your agent to do?"
- **Sports betting** — Scan odds, compare lines, find value across sportsbooks
- **Prediction markets** — Trade on Polymarket, Kalshi, or both
- **Hybrid/Arbitrage** — Cross-market opportunities between sportsbooks and prediction markets
- **Research only** — Track odds and markets without placing trades
### 2. Budget
Ask: "What's your monthly tool budget?"
- **Free ($0)** — Open-source tools and free API tiers only
- **Hobby (~$25/mo)** — Paid API access and basic hosting
- **Pro ($100+/mo)** — Premium data, dedicated infrastructure
### 3. Technical Level
Ask: "How comfortable are you with terminal commands and APIs?"
- **Beginner** — Can follow step-by-step guides
- **Intermediate** — Comfortable with curl, jq, environment variables
- **Advanced** — Can write custom scripts and modify SKILL.md files
# Recommendation Logic
### Sports Betting Path
**Minimum viable stack:**
- Layer 3: `odds-scanner` skill + The Odds API key
- Estimated setup time: 15 minutes
- Cost: Free (500 API calls/month)
**Recommended additions by priority:**
1. `vig-calculator` — Know which books have the best margins
2. `odds-converter` — Handle American/decimal/fractional formats
3. `kelly-sizer` — Size your bets optimally (Layer 4)
4. `ev-calculator` — Evaluate expected value before betting (Layer 4)
5. `clv-tracker` — Track if you're beating the closing line (Layer 4)
6. `sharp-line-detector` — Follow smart money movements (Layer 4)
7. `bankroll-manager` — Track P&L across books (Layer 2)
### Prediction Market Path
**Minimum viable stack:**
- Layer 3: `polymarket-monitor` skill (no API key needed)
- Estimated setup time: 10 minutes
- Cost: Free
**Recommended additions by priority:**
1. `kalshi-tracker` — Add Kalshi event contracts
2. `odds-converter` — Convert contract prices to implied probability
3. `kelly-sizer` — Size positions with Kelly criterion (Layer 4)
4. `ev-calculator` — Expected value on contract prices (Layer 4)
5. `bankroll-manager` — Track positions across platforms (Layer 2)
6. `wallet-balance-checker` — Monitor USDC balances (Layer 2)
### Hybrid/Arbitrage Path
**Minimum viable stack:**
- Layer 3: `odds-scanner` + `polymarket-monitor` + `arb-finder`
- Estimated setup time: 30 minutes
- Cost: Free (but higher API usage)
**Recommended additions by priority:**
1. `cross-market-pricer` — Normalize odds across all platforms
2. `kalshi-tracker` — Add Kalshi as third price source
3. `odds-converter` — Unified format conversion
4. `kelly-sizer` — Size arb positions (Layer 4)
5. `bankroll-manager` — Track capital across all platforms (Layer 2)
6. `wallet-balance-checker` — Ensure capital is available (Layer 2)
### Research-Only Path
**Minimum viable stack:**
- Layer 3: `odds-scanner` or `polymarket-monitor` (pick based on interest)
- Estimated setup time: 10 minutes
- Cost: Free
**Recommended additions:**
1. `vig-calculator` — Analyze sportsbook efficiency
2. `odds-converter` — Understand odds in any format
3. `world-cup-2026-odds` — Event-specific tracker (if timely)
# Output Format
After assessment, output a checklist in this format:
```
## Your Agent Betting Stack
**Goal:** [Sports Betting / Prediction Markets / Hybrid / Research]
**Budget:** [Free / Hobby / Pro]
**Estimated setup time:** [X minutes]
### Step 1: Install Core Skills
- [ ] mkdir -p ~/.openclaw/skills/[skill-name]
- [ ] Create SKILL.md (see guide: [link])
- [ ] Set API keys if needed
### Step 2: Configure APIs
- [ ] [API name] — Sign up at [URL], free tier: [limits]
### Step 3: Test Your Stack
- [ ] Try: "[sample prompt]"
- [ ] Verify: [expected output]
### Step 4: Optional Upgrades
- [ ] [Next skill to add] — [Why it helps]
- [ ] [Next skill to add] — [Why it helps]
### Relevant Guides
- [Guide name](URL) — [One-line description]
```
# Guide Links
Use these URLs when linking to AgentBets guides:
| Guide | URL |
|-------|-----|
| Agent Betting Stack Overview | /guides/agent-betting-stack/ |
| Odds Scanner Skill | /guides/openclaw-odds-scanner-skill/ |
| Polymarket Monitor Skill | /guides/openclaw-polymarket-monitor-skill/ |
| Kalshi Tracker Skill | /guides/openclaw-kalshi-tracker-skill/ |
| Arb Finder Skill | /guides/openclaw-arb-finder-skill/ |
| Vig Calculator Skill | /guides/openclaw-vig-calculator-skill/ |
| Kelly Sizer Skill | /guides/openclaw-kelly-sizer-skill/ |
| EV Calculator Skill | /guides/openclaw-ev-calculator-skill/ |
| Odds Converter Skill | /guides/openclaw-odds-converter-skill/ |
| CLV Tracker Skill | /guides/openclaw-clv-tracker-skill/ |
| Sharp Line Detector Skill | /guides/openclaw-sharp-line-detector-skill/ |
| Bankroll Manager Skill | /guides/openclaw-bankroll-manager-skill/ |
| World Cup 2026 Odds Skill | /guides/openclaw-world-cup-2026-odds-skill/ |
| Prediction Market API Reference | /guides/prediction-market-api-reference/ |
| Polymarket CLOB API Guide | /guides/polymarket-api-guide/ |
| Kalshi API Guide | /guides/kalshi-api-guide/ |
| Agent Wallet Comparison | /guides/agent-wallet-comparison/ |
| Agent Security Guide | /guides/agent-betting-security/ |
# Output Rules
1. Always start by asking the three assessment questions before recommending
2. Never recommend more than 7 skills — prioritize ruthlessly
3. Always include estimated setup time and cost per tier
4. Always link to the relevant AgentBets guide for each recommended skill
5. If the user says "just get me started," default to Sports Betting + Free Tier + Beginner
6. Frame every recommendation around the four-layer stack so the user understands where each piece fits
# Error Handling
- If the user's goal doesn't fit any path, recommend the Research-Only path as a starting point
- If the user wants to execute trades, clarify that OpenClaw skills covered here are read-only — trade execution requires platform-specific API integrations not covered in this skill
- If the user mentions a platform not covered (e.g., Betfair, PredictIt), acknowledge it and explain which existing skills come closest
Test It
Restart OpenClaw (or wait for hot-reload if your version supports it), then try these prompts:
| Prompt | Expected Behavior |
|---|---|
| “Help me build a betting agent” | Asks assessment questions, then outputs personalized stack checklist |
| “What tools do I need for prediction market trading?” | Skips to prediction market path, asks about budget and technical level |
| “I want to find arbs between sportsbooks and Polymarket” | Recommends hybrid/arbitrage path with arb-finder as core |
| “Agent betting stack — what is it?” | Explains the four-layer framework with examples |
| “I have no budget, just want to track NBA odds” | Recommends free sports betting path with odds-scanner only |
Your agent reads the SKILL.md, identifies this as a setup/recommendation request, and walks the user through the assessment before outputting a checklist.
How It Works Under the Hood
OpenClaw skills are not plugins that execute code directly. The SKILL.md is a set of instructions that the LLM (Claude, GPT, etc.) reads and follows at runtime.
When you ask “help me build a betting agent,” this is what happens:
User message → OpenClaw Gateway
→ LLM reads system prompt + active skills
→ LLM matches "build a betting agent" to agent-betting-stack-advisor skill
→ LLM follows assessment question flow from SKILL.md
→ User answers goal, budget, technical level
→ LLM selects recommendation path and generates checklist
→ LLM formats output with links to AgentBets guides
Knowledge skills like this one are the simplest OpenClaw skill type — no shell commands, no API calls, no credentials. The entire skill is decision-tree logic expressed as markdown that the LLM interprets at runtime. The quality of the recommendations depends on how clearly the SKILL.md encodes the decision paths and how exhaustive the option mappings are.
Extending the Skill
Add Platform-Specific Modules
As you build more OpenClaw skills for specific platforms, update the advisor’s recommendation logic to include them. For example, when a Betfair skill exists, add a “UK/International Sports Betting” path that includes it.
Chain with Installed Skill Detection
Future versions of OpenClaw may support skill introspection — checking which skills are already installed. When available, the advisor could scan ~/.openclaw/skills/, detect what’s already set up, and recommend only the missing pieces:
{
"cron": "0 9 * * 1",
"prompt": "Check which OpenClaw skills I have installed and suggest what I should add next based on my current stack."
}
Seasonal Recommendations
Tie recommendations to the sports calendar. During NFL season, emphasize football-related skills. Before the World Cup, recommend the world-cup-2026-odds skill. A cron job could update recommendations weekly:
{
"cron": "0 9 * * 1",
"prompt": "What sports are in season right now? Based on that, what should I add to my agent stack?"
}
Full Skill Series
This guide is part of the AgentBets OpenClaw Skills series. We’re building a complete library of betting-specific OpenClaw skills that map to the four layers of the Agent Betting Stack:
- Layer 1 — Identity: Agent reputation tracking via Moltbook
- Layer 2 — Wallet: Bankroll management, balance checking across platforms
- Layer 3 — Trading: Odds scanning, Polymarket monitoring, Kalshi tracking, arbitrage detection
- Layer 4 — Intelligence: EV calculation, Kelly sizing, CLV tracking, news sentiment
Each skill is a standalone SKILL.md you can install independently or compose into a full autonomous betting pipeline.
What’s Next
- Agent Betting Stack Overview — Deep dive into the four-layer framework this skill maps to
- Odds Scanner Skill Guide — Start with the most common Layer 3 skill
- Polymarket CLOB API Guide — Build prediction market trading into your agent
- AgentBets Marketplace — Browse pre-built tools and integrations for your stack
- Agent Security Guide — Production hardening before you go live