Description

Trade Kalshi prediction markets through conversation, powered by Fuku sports model predictions. Use when a user asks about Kalshi markets, wants sports predi...

README (SKILL.md)

Fuku Predictions — Conversational Kalshi Trading Skill

Name: Fuku Predictions
Author: cryptopunk2070

Trade prediction markets through conversation. The agent learns what you care about, builds a personalized profile, then scans Kalshi markets for opportunities that match your style.

Three Modes

1. Profile Building (Interactive)

User describes preferences → agent builds a trading profile → saves for reuse.

2. Conversational Scanning

Agent scans markets using the profile → presents matching opportunities → user approves trades.

3. Autonomous Trading

Agent scans and trades automatically within risk limits.

Setup

Dependencies

pip install httpx cryptography python-dotenv

Kalshi API Key

Create .env in the skill directory:

KALSHI_API_KEY_ID=your_key_id
KALSHI_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----"

Get credentials: https://kalshi.com/profile/api

Defining Preferences

Users express what they care about in natural language:

Situational: "I want home dogs getting 7+ points in CBB" · "Show me letdown spots after big wins" · "Find revenge games where the underdog lost by 15+ last time"

Player Mismatches: "Games where the best player has a 50+ FPR gap" · "Matchups when a star player is injured"

Statistical: "Only games with top 30 defenses" · "Pace mismatches (fast vs slow)" · "Spreads under 3 points"

Risk & Sizing: "$5 bets on highest confidence plays" · "Max 8 trades per day" · "Quarter-Kelly sizing"

Agent Tools

Profile Management

# Process user preference input
python3 scripts/agent_interface.py --input "I want home dogs getting 7+ points in CBB"

# Scan using a profile
python3 scripts/agent_interface.py --scan --profile default

# List profiles
python3 scripts/agent_interface.py --input "list my profiles"

Market Browser

# Tonight's markets with predictions and edges
python3 scripts/browse.py

# Filter by sport or game
python3 scripts/browse.py --sport cbb
python3 scripts/browse.py --game "Duke" --date 2026-03-03

# Change bet display amount (default $5)
python3 scripts/browse.py --bet 10

Direct Kalshi Access

python3 scripts/kalshi_client.py balance
python3 scripts/kalshi_client.py positions
python3 scripts/kalshi_client.py markets --series KXNBASPREAD

Presenting Markets to Users

Always include: the market, price (dollars), model prediction, edge, payout, and recommendation.

Talk in dollars, not contracts. Users say "$5 on Boston" — convert to contracts internally.

Three-tier display per market type:

Main line — contract closest to 50¢ (market consensus)
🔒 Safer — highest edge (high confidence, modest payout)
🎰 Riskier — near model's predicted line (~50% model probability, bigger payout, ≥3% edge required)

Edge icons: 🔥 ≥20% · ✅ ≥10% · 📊 ≥5% · ➖ \x3C5%

Example:

🏀 Boston @ Milwaukee — 7:30 PM
📊 Our model: BOS -8.4 | Total 224.1

• BOS -2.5 at 50¢ → 70% model (+20% edge 🔥) — $5 pays $10
  ↳ 🔒 Safer: BOS -1.5 at 57¢ → 82% model (+25% edge) — $5 pays $8
  ↳ 🎰 Riskier: BOS -8.5 at 31¢ → 50% model (+19% edge) — $5 pays $16
• Over 215.5 at 52¢ → 79% model (+27% edge 🔥) — $5 pays $9

💰 Balance: $49.95
Want me to put money on any of these?

Dollar-to-Contract Math

"$5 on BOS -8.5" at 31¢ → floor($5 / $0.31) = 16 contracts × $0.31 = $4.96 cost → $16.00 payout if YES → $11.04 profit.

Trading

from kalshi_client import KalshiClient
c = KalshiClient()

# Buy
c.place_order(ticker="KXNBA...", side="yes", action="buy",
              count=16, order_type="limit", yes_price=31)

# Sell to exit
c.place_order(ticker="KXNBA...", side="yes", action="sell",
              count=16, order_type="limit", yes_price=current_bid)

Edge Math

Normal distribution probability conversion (no scipy):

Uses math.erfc for CDF
Sport-specific σ: CBB spread 12.0 / total 11.0, NBA 11.0 / 10.5, NHL 1.5 / 1.3, Soccer 1.2 / 1.1
Player props: σ = 30% of predicted value (min 2.0)

Kalshi Market Structure

Series (sport): KXNBASPREAD, KXNBATOTAL, KXNBAGAME
Event (game): KXNBASPREAD-26MAR02BOSMIL
Market (contract): KXNBASPREAD-26MAR02BOSMIL-BOS7 → "Boston wins by over 7.5?"

Pricing: YES/NO in cents (1-99). YES 31¢ = 31% implied. 1 contract = $1 max payout.

Supported Sports

Sport	Spread	Total	ML	Props
NBA	`KXNBASPREAD`	`KXNBATOTAL`	`KXNBAGAME`	—
CBB	`KXNCAAMBSPREAD`	`KXNCAAMBTOTAL`	`KXNCAABGAME`	—
NHL	`KXNHLSPREAD`	`KXNHLTOTAL`	`KXNHLGAME`	Goals/Pts/Ast
Soccer	Per-league (EPL/La Liga/Serie A/Bundesliga/Ligue 1/UCL/MLS)	Per-league	Per-league	BTTS

Autopilot Config

config/config.json:

{
  "strategy": "model_follower",
  "sports": ["nba", "cbb"],
  "min_edge_pct": 3.0,
  "max_daily_loss_pct": 10,
  "max_daily_bets": 15,
  "sizing": "quarter_kelly",
  "mode": "approve"
}

Modes: dry_run (log only) · approve (ask user) · auto (hands-free)

Safety

Max daily loss limit (default 10%)
Position size caps (default 5% per trade)
Kill switch: touch KILL_SWITCH in skill directory
All trades logged locally to trades.json
API keys never leave the machine

Kalshi API Auth

RSA-PSS signatures. The client handles this automatically.

Signing quirk: Portfolio endpoints sign path WITHOUT query strings. Market endpoints sign WITH. See _SIGN_PATH_ONLY in kalshi_client.py.

Fuku Prediction API (Public)

Base: https://cbb-predictions-api-nzpk.onrender.com

Endpoint	Data
`/api/public/cbb/predictions?date=YYYY-MM-DD`	CBB predictions
`/api/public/nba/predictions?date=YYYY-MM-DD`	NBA predictions
`/api/public/nhl/predictions?date=YYYY-MM-DD`	NHL predictions
`/api/public/soccer/predictions?date=YYYY-MM-DD`	Soccer predictions
`/api/public/cbb/rankings?limit=N`	Team FPR rankings
`/api/public/cbb/players?team=X&limit=N`	Player FPR data

Files

File	Purpose
`scripts/browse.py`	Primary — markets with predictions, edges, payouts
`scripts/agent_interface.py`	Conversational profile building + scanning
`scripts/profile_engine.py`	Profile-based opportunity scoring
`scripts/profile_builder.py`	Natural language → profile JSON
`scripts/autopilot.py`	Autonomous scanning + trading pipeline
`scripts/kalshi_client.py`	Kalshi API client (auth, orders, markets)
`scripts/scanner.py`	Full edge scanner (all contracts)
`scripts/executor.py`	Trade execution with risk management
`scripts/portfolio.py`	Position tracking and P&L
`scripts/setup.py`	Interactive setup wizard
`config/config.json`	Strategy and risk settings
`config/profiles/*.json`	User trading profiles
`references/strategies.md`	Strategy explanations
`references/kalshi-markets.md`	How Kalshi markets work

Usage Guidance

Before installing or providing credentials: - Do not place your Kalshi RSA private key into .env until you inspect kalshi_client.py to verify it only signs requests locally and never sends the raw private key to external services. If you are not comfortable reading code, ask a developer you trust to audit kalshi_client.py and any network code. - Investigate the external predictions host (fuku_api_base = https://cbb-predictions-api-nzpk.onrender.com). Determine who runs it and what data you will send to it (player/game queries, your profile, or account info). If the skill sends trade intent or account identifiers to that service, your model/strategy and possibly account activity could be exposed. - The registry metadata claims no env vars but the skill requires Kalshi credentials; treat that as a red flag for sloppy packaging. Prefer a skill that declares required credentials formally in metadata. - Start in dry_run mode and keep auto_trade disabled. Test the skill locally without real money, monitor network calls (e.g., with a transparent proxy like mitmproxy if you can) and confirm no unexpected outbound requests carry secrets. - The code spawns subprocesses with a hardcoded 'arch -arm64' wrapper; test on your host in a safe environment to ensure it behaves as expected. This is odd but not necessarily malicious. - If you cannot or will not perform the checks above, avoid supplying the Kalshi private key and avoid enabling 'auto' mode. Treat this skill as untrusted until audited.

Capability Analysis

Type: OpenClaw Skill Name: fuku-predictions Version: 1.0.0 The skill is designed for legitimate automated trading on Kalshi prediction markets, handling API keys securely (local .env, RSA-PSS signing). However, it contains significant vulnerabilities. The `scripts/agent_interface.py` uses `subprocess.run` to execute `autopilot.py` with a `profile_name` derived from user input, creating a potential shell injection vector. Additionally, `scripts/profile_engine.py`'s `load_profile` function could load a profile from an arbitrary absolute path if user input is crafted, leading to malicious configuration. The `scripts/setup.py` also modifies the user's crontab, a high-privilege action, although the command itself is constructed from internal paths. These are critical vulnerabilities that could be exploited for arbitrary code execution or malicious configuration, but there is no clear evidence of intentional malicious behavior (e.g., data exfiltration to an attacker-controlled server, backdoors, or obfuscation).

Capability Assessment

ℹ Purpose & Capability

Name/description match the code: the package is an autopilot/trading suite for Kalshi using a Fuku sports model. However the registry metadata declares no required credentials while SKILL.md and the code expect a Kalshi API key (RSA private key + id) in a local .env — that mismatch is a coherence issue. Also config points to a third-party predictions endpoint (fuku_api_base on onrender.com) which is not explained in the public description; it's plausible for a model-backed skill but should be documented and justified.

⚠ Instruction Scope

SKILL.md instructs to store Kalshi credentials locally and claims 'API key stored locally — never transmitted externally.' The codebase references an external predictions API (fuku_api_base) and performs network calls and subprocess execution (e.g., launching autopilot.py). Those external requests could receive request metadata or parameters — the README claim that keys never leave the machine is not verifiable without auditing kalshi_client.py and network calls. agent_interface.py spawns subprocesses using a hardcoded command ('arch -arm64 python3 autopilot.py'), which is unexpected and may fail or behave differently on non-arm64 hosts.

ℹ Install Mechanism

There is no install spec in the registry (instruction-only), which limits automatic system changes. SKILL.md suggests pip installing httpx, cryptography, python-dotenv — a reasonable minimal dependency set for HTTP requests and local secret handling. Because code files are bundled, the skill will execute arbitrary Python code when invoked; that is normal for this type of skill but increases the need for code review.

⚠ Credentials

The registry lists no required env vars or primary credential, but SKILL.md asks the user to create a .env containing KALSHI_API_KEY_ID and KALSHI_PRIVATE_KEY (private RSA key). That is a clear mismatch. The private key is powerful: it allows API calls and signing for your Kalshi account; you should only provide it if you trust the code. The skill claims keys 'never transmitted externally,' but the presence of a third-party predictions API and networked components means you must audit the code to confirm the private key is only used locally to sign requests to Kalshi and never sent elsewhere.

ℹ Persistence & Privilege

always:false (no forced always-on) and autonomous invocation is allowed (default). The skill can run 'auto' trading mode that places real trades; combined with access to your Kalshi credentials this is powerful. This is not an immediate disqualifier, but you should restrict autonomous/auto modes until you verify behavior. The skill writes local files (trades.json, optional KILL_SWITCH file) which is expected for a trading agent and is limited to its directory.

Version History

v1.0.0

Initial release: conversational Kalshi trading with personalized profiles, 4 sports, autopilot mode

Metadata

Slug fuku-predictions

Version 1.0.0

License —

All-time Installs 0

Active Installs 0

Total Versions 1

Frequently Asked Questions

What is Fuku Predictions?

Trade Kalshi prediction markets through conversation, powered by Fuku sports model predictions. Use when a user asks about Kalshi markets, wants sports predi... It is an AI Agent Skill for Claude Code / OpenClaw, with 398 downloads so far.

How do I install Fuku Predictions?

Run "/install fuku-predictions" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Fuku Predictions free?

Yes, Fuku Predictions is completely free (open-source). You can download, install and use it at no cost.

Which platforms does Fuku Predictions support?

Fuku Predictions is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Fuku Predictions?

It is built and maintained by cryptopunk2070 (@cryptopunk2070); the current version is v1.0.0.

More Skills

Fuku Predictions