記事一覧へ
X（旧Twitter）のほとんどのインフルエンサーはあなたに嘘をついています。彼らの「clawdbots」は何百万も稼いでいません。本物のAIエージェントの作り方と、実際に何ができるかを紹介します。嘘偽りなく。
## はじめに
毎日フィードをスクロールすると、「今週のPolymarketで$50kを稼いだ」という投稿が見えます。
私は即座にブロックボタンを押します。
実際に起きていることはこうです：1回の取引でたまたま運が良かった、ボットとは関係なかった、またはスクリーンショットが偽物かのどれかです。
Polymarket向けの本物のAIエージェントはお金の印刷機ではありません。
より賢く取引するのを助けてくれる個人アシスタントです。
それがこの記事の主旨です。
決断は常にあなたのものです。必ず。
## なぜエージェントが必要か
Polymarketでの手動取引は疲弊します。
どの瞬間にも何百ものマーケットがアクティブです。全部読めません。オッズがいつ動くか追跡できません。
本物のエージェントがあなたのためにすること：
- あなたが寝ている間に毎朝50以上のマーケットをスキャン
- 現在のオッズが公正か誤価格かを推定
- バンクロールに基づいてベット額を正確に計算
- 興味深いものが現れたらTelegramメッセージを送信
- 全取引をログに記録して決断をレビューできるようにする
あなたの判断を置き換えません。判断により良いインプットを与えます。
## 始める前に
コードを1行書く前に、以下を準備してください：
**アカウントとキー：**
- Polymarketアカウント（APIアクセス付き）> docs.polymarket.com
- Anthropic APIキー > console.anthropic.com
- TelegramボットトークンI > TGで@BotFatherにメッセージ
- ウォレットの秘密鍵（Polymarketに接続されているもの）
**マシンに必要なツール：**
- Python 3.9以上
- pip（Pythonに付属）
- テキストエディター（VS Codeで十分）
**24時間365日稼働させるサーバー：**
- 安価なVPSなら何でも
- 月$5〜6で1 vCPUと1GB RAM——十分以上
プロジェクトフォルダに.envファイルを作成してキーをそこに入れます：
```bash
PRIVATE_KEY=your_wallet_private_key
FUNDER_ADDRESS=your_polymarket_wallet_address
ANTHROPIC_API_KEY=your_key
TELEGRAM_TOKEN=your_bot_token
TELEGRAM_CHAT_ID=your_chat_id
```
このファイルを絶対に共有しないこと。GitHubにプッシュしないこと。
## Polymarketに接続する
依存関係をインストールします：
```bash
pip install py-clob-client python-dotenv anthropic httpx schedule requests
```
PolymarketI に接続してライブマーケットを取得します。マーケット発見にはGamma APIを使います——メタデータ付きのアクティブなマーケットのリストを取得する正しい方法です：
```python
# 正しいインポート — アンダースコアに注意：py_clob_client
from py_clob_client.client import ClobClient
from dotenv import load_dotenv
import requests
import os
load_dotenv()
# 価格データ用の読み取り専用クライアント（認証不要）
clob = ClobClient("https://clob.polymarket.com")
def get_active_markets(limit=50):
"""Gamma APIでアクティブなマーケットを取得"""
url = "https://gamma-api.polymarket.com/markets"
params = {
"active": "true",
"closed": "false",
"limit": limit,
"order": "volume24hr",
"ascending": "false"
}
resp = requests.get(url, params=params)
resp.raise_for_status()
return resp.json()
markets = get_active_markets()
for m in markets:
print(m["question"], "| 24h出来高:", m.get("volume24hr", "n/a"))
```
これを実行すると、24時間出来高でソートされたアクティブなマーケットのリストが表示されます。動作したら——データレイヤーがライブになっています。
重要な注意：YESの価格が5%未満または95%以上のマーケットはスキップします。ほぼ確実なマーケットは残されたエッジがほとんどありません——群衆がすでに正しく価格付けています。
## AI確率推定
ここでClaudeが登場します。各マーケットについて、質問と現在の価格をAPIに送信し、真の確率を推定するよう依頼します。Claudeの推定とマーケット価格の差があなたの潜在的なエッジです：
```python
import anthropic
import json
claude = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
def get_market_price(token_id: str) -> float:
"""トークンの現在のミッドポイント価格を取得"""
try:
mid = clob.get_midpoint(token_id)
return float(mid["mid"])
except Exception:
return 0.5 # 価格が利用できない場合のフォールバック
def estimate_probability(market_question: str, current_yes_price: float) -> dict:
prompt = f"""あなたは予測市場アナリストです。このマーケットの質問を分析して真の確率を推定してください。
マーケット：{market_question}
PolymarketのYES価格：{current_yes_price}（= マーケットが示す確率）
考慮すること：
1. このタイプのイベントのベースレート
2. あなたが知っている現在のニュースとコンテキスト
3. マーケット価格が公正か、高すぎるか、低すぎるか
次の正確なJSON形式のみで回答してください、それ以外は何も：
{{
"estimated_probability": 0.XX,
"confidence": "high/medium/low",
"edge": 0.XX,
"reasoning": "最大1文"
}}
edge = あなたの推定 - 現在のマーケット価格。正 = マーケットが低く見積もっている。"""
response = claude.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=300,
messages=[{"role": "user", "content": prompt}]
)
raw = response.content[0].text.strip()
# Claudeがマークダウンフェンスを追加した場合に除去
raw = raw.replace("json", "").replace("", "").strip()
return json.loads(raw)
```
このステップについていくつかの重要なこと：
プロンプトはClaudeに厳密なJSONで回答させます——パースエラーなし、サプライズなし。マークダウンフェンスも除去します（モデルが出力をそれで囲む場合）。
モデルは理由を1文で説明しなければなりません——推定が理にかなっているかどうかをサニティーチェックするのに役立ちます。
回答を盲目的に信用しないこと。Claudeには知識のカットオフがあり、ライブニュースは見えません。推定を出発点として扱い、教義としてではなく。
## ケリー基準でのポジションサイジング
ほとんどのトレーダーが負けるのは、間違ったマーケットを選ぶからではなく、各マーケットに賭けすぎるからです。ケリー基準はこれを数学的に解決します。
推定したエッジを考慮して、バンクロールのどの割合をリスクにさらすかを正確に教えてくれます。
完全なケリーの代わりにクォーターケリー（0.25倍）を使います。完全なケリーは理論上は素晴らしく見えますが、分散があなたを勝っているポジションを慌てて閉じさせます。クォーターケリーなら眠れます：
```python
def kelly_position_size(
bankroll: float,
probability: float,
market_price: float,
fraction: float = 0.25
) -> float:
if not (0 < market_price < 1):
return 0.0
b = (1 / market_price) - 1 # 十進オッズ
q = 1 - probability
kelly = (probability * b - q) / b
if kelly <= 0:
return 0.0 # エッジなし — スキップ
```
## SQLiteでのトレードログ
データなしでは学習できません。全アラートをSQLiteデータベースに記録します：
```python
import sqlite3
from datetime import datetime
DB_PATH = "trades.db"
def init_db():
conn = sqlite3.connect(DB_PATH)
conn.execute("""
CREATE TABLE IF NOT EXISTS trades (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT NOT NULL,
market TEXT NOT NULL,
yes_token_id TEXT,
direction TEXT,
entry_price REAL,
size REAL,
my_estimate REAL,
edge REAL,
confidence TEXT,
status TEXT DEFAULT 'alerted'
)
""")
conn.commit()
conn.close()
def log_alert(market, yes_token_id, entry_price, size, estimate, edge, confidence):
conn = sqlite3.connect(DB_PATH)
conn.execute("""
INSERT INTO trades
(timestamp, market, yes_token_id, direction, entry_price, size, my_estimate, edge, confidence)
VALUES (?, ?, ?, 'YES', ?, ?, ?, ?, ?)
""", (datetime.now().isoformat(), market, yes_token_id,
entry_price, size, estimate, edge, confidence))
conn.commit()
conn.close()
def get_stats():
conn = sqlite3.connect(DB_PATH)
row = conn.execute("""
SELECT
COUNT(*) as total_alerts,
ROUND(AVG(edge) * 100, 1) as avg_edge_pct,
ROUND(SUM(size), 2) as total_size_suggested
FROM trades
""").fetchone()
conn.close()
return row
```
2週間のデータがあれば、エージェントが本物のエッジを見つけているのか、それともただのノイズなのかを明確に把握できます。
## 全てをまとめる
全てをスケジュールで実行する1つのスクリプトにまとめます——朝8:30のスキャンと夜20:00のスキャン：
```python
import schedule
import time
init_db() # 初回実行時にDBを作成
async def run_scan():
print(f"[{datetime.now().strftime('%H:%M')}] マーケットスキャン実行中...")
await scan_and_alert(bankroll=1000)
stats = get_stats()
print(f"総アラート数: {stats[0]} | 平均エッジ: {stats[1]}% | 提案された総サイズ: ${stats[2]}")
def run_schedule():
schedule.every().day.at("08:30").do(lambda: asyncio.run(run_scan()))
schedule.every().day.at("20:00").do(lambda: asyncio.run(run_scan()))
print("エージェント稼働中 — スケジュールされたスキャンを待機中")
while True:
schedule.run_pending()
time.sleep(30)
if __name__ == "__main__":
run_schedule()
```
これをmain.pyとして保存します。次にサーバーで動かしましょう。
## VPSへのデプロイ — 初心者向けステップバイステップ
**1. サーバーをレンタルする**
最も安価なLinuxサーバー（Ubuntu 22.04）を作成します。IPアドレスとルートパスワードが届きます。
**2. 接続する**
MacまたはLinuxでターミナルを開いて入力します：
```bash
ssh root@YOUR_SERVER_IP
```
WindowsではPuTTYまたはWindowsターミナルを使います。
**3. Pythonをインストールする**
```bash
apt update && apt upgrade -y
apt install python3 python3-pip -y
```
**4. プロジェクトをアップロードする**
ローカルマシンで実行します：
```bash
scp -r ./polymarket-agent root@YOUR_SERVER_IP:/root/
```
またはGitHubを使います——コードをプッシュして（.envファイルなしで）サーバーでプルします：
```bash
git clone https://github.com/yourusername/polymarket-agent
cd polymarket-agent
```
**5. サーバーに.envファイルを作成する**
```bash
nano .env
```
キーを貼り付けて、Ctrl+X > Y > Enterで保存します。
**6. 依存関係をインストールする**
```bash
pip install py-clob-client python-dotenv anthropic httpx schedule requests
```
**7. systemdで実行する**
ボットが再起動後に自動的に再起動するようにサービスファイルを作成します：
```bash
nano /etc/systemd/system/polybot.service
```
以下を貼り付けます：
```ini
[Unit]
Description=Polymarket AI Agent
After=network.target
[Service]
WorkingDirectory=/root/polymarket-agent
ExecStart=/usr/bin/python3 main.py
Restart=always
RestartSec=10
Environment=PYTHONUNBUFFERED=1
[Install]
WantedBy=multi-user.target
```
保存して起動します：
```bash
systemctl daemon-reload
systemctl enable polybot
systemctl start polybot
```
動作確認：
```bash
systemctl status polybot
```
「active (running)」と表示されれば——エージェントが24時間365日稼働しています。
ライブログの確認：
```bash
journalctl -u polybot -f
```
## エージェントが実際に何ができるか
数週間実行した後の正直な評価——何が得意で、どこで限界があるか：
**マーケットスキャン**
エージェントは手動では絶対に見つけられない面白いマーケットを確実に発掘します。常時300以上のアクティブなマーケットがある中で、出来高とエッジでフィルタリングすれば毎日2〜3時間のリサーチが節約されます。
**確率キャリブレーション**
Claudeの推定は、政治やマクロなどの文書化されたトピックでは約65〜70%の確率で方向的に正確です。ニッチなスポーツマーケットや非常に最近のニュースでは、精度が顕著に低下します。
**ポジション規律**
これが多くのトレーダーにとってエージェントが最も価値を発揮するところです。ケリーサイジングは賭け額からの感情的な要素を除きます。根拠なき感覚があるマーケットに賭けすぎるのをやめ、本物のエッジがあるマーケットに賭け足りないのをやめます。
**パターン追跡**
4〜6週間のログがあれば、Claudeがうまく推定できるマーケットカテゴリとそうでないカテゴリが分かります。カテゴリごとにエッジ閾値を調整すると精度が向上します。
**できないこと**
ライブニュース、オンチェーンデータ、インサイダー情報へのアクセスはありません。マーケットの質問とトレーニングデータしか見えません。エッジが過去24時間に起きたことによるものであれば——エージェントはキャッチできません。それはまだあなたの仕事です。
## 結論
これがAI取引エージェントストーリーの正直なバージョンです。
構築に2週間、月$8の運用費用、そして本当に役に立ちます——お金の印刷機としてではなく、リサーチと規律のツールとして。
エージェントが雑用を処理します：スキャン、サイジング、ロギング。
あなたが思考を処理します：ニュースを読む、コンテキストを理解する、アラートに基づいて行動するかどうか決める。
こうしたものを構築して60日間使い続けた人のほとんどが同じことを言います：衝動的な賭けが減り、ポジションをより適切にサイズし、直感ではなくデータをレビューできるようになった。
これはお金の印刷機ではありません。
これはただより良い取引です。
claude-workflowagent-opsai-industry
本物のAIエージェントで予測市場をスマートに
♥ 205↻ 10
原文を表示 / Show original
most influencers on X are lying to you. their "clawdbots" don't make millions. I'll show you how to build a real ai agent - and what it's actually capable of. just the truth.
introduction
every day I scroll my feed and see posts: "my bot made $50k on polymarket this week"
I immediately hit block
here's what's actually happening: they got lucky on one trade, the bot had nothing to do with it, or the screenshot is fake
a real AI agent for polymarket is not a money printer
it's a personal assistant that helps you trade smarter
that's the main point of this article
the decisions are still yours. always.
why you need an agent
trading on polymarket manually is exhausting
at any given moment hundreds of markets are active. you can't read all of them. you can't track when odds move.
here's what a real agent does for you:
scans 50+ markets every morning while you sleep
estimates whether current odds are fair or mispriced
calculates exactly how much to bet based on your bankroll
sends you a TG message when something interesting appears
logs every trade so you can review your decisions
it doesn't replace your judgment. it gives your judgment better inputs.
before you start
before writing a single line of code, get the following:
accounts and keys:
Polymarket account with API access > docs.polymarket.com
Anthropic API key > console.anthropic.com
Telegram bot token > message @BotFather on tg
your wallet's private key(the one connected to Polymarket)
tools on your machine:
Python 3.9+
pip(comes with Python)
a text editor(VS Code works fine)
a server to run it 24/7:
any cheap VPS
$5-6/month gets you 1 vCPU and 1GB RAM - more than enough
create a .env file in your project folder and put your keys there:
bash
PRIVATE_KEY=your_wallet_private_key
FUNDER_ADDRESS=your_polymarket_wallet_address
ANTHROPIC_API_KEY=your_key
TELEGRAM_TOKEN=your_bot_token
TELEGRAM_CHAT_ID=your_chat_id
never share this file. never push it to GitHub.
connect to polymarket
install the dependencies:
bash
pip install py-clob-client python-dotenv anthropic httpx schedule requests
now connect to Polymarket and pull live markets. we use the Gamma API for market discovery - it's the correct way to get a list of active markets with metadata:
python
# correct import — note the underscore: py_clob_client
from py_clob_client.client import ClobClient
from dotenv import load_dotenv
import requests
import os
load_dotenv()
# read-only client for price data (no auth needed)
clob = ClobClient("https://clob.polymarket.com")
def get_active_markets(limit=50):
"""fetch active markets via Gamma API"""
url = "https://gamma-api.polymarket.com/markets"
params = {
"active": "true",
"closed": "false",
"limit": limit,
"order": "volume24hr",
"ascending": "false"
}
resp = requests.get(url, params=params)
resp.raise_for_status()
return resp.json()
markets = get_active_markets()
for m in markets:
print(m["question"], "| volume 24h:", m.get("volume24hr", "n/a"))
run this and you'll see a list of active markets sorted by 24h volume. if it works - your data layer is live.
one important note: we skip markets where YES price is below 5% or above 95%. near-certain markets have almost no edge left - the crowd already priced them correctly.
ai probability estimation
this is where Claude comes in. for each market we send the question and current price to the API and ask it to estimate the true probability. the difference between Claude's estimate and the market price is your potential edge:
python
import anthropic
import json
claude = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
def get_market_price(token_id: str) -> float:
"""get current midpoint price for a token"""
try:
mid = clob.get_midpoint(token_id)
return float(mid["mid"])
except Exception:
return 0.5 # fallback if no price available
def estimate_probability(market_question: str, current_yes_price: float) -> dict:
prompt = f"""You are a prediction market analyst. Analyze this market question and estimate the true probability.
Market: {market_question}
Current YES price on Polymarket: {current_yes_price} (= market implied probability)
Consider:
1. Base rate for this type of event
2. Current news and context you know about
3. Whether the market price seems fair, too high, or too low
Respond ONLY in this exact JSON format, nothing else:
{{
"estimated_probability": 0.XX,
"confidence": "high/medium/low",
"edge": 0.XX,
"reasoning": "one sentence max"
}}
edge = your estimate minus current market price. positive = market underpriced."""
response = claude.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=300,
messages=[{"role": "user", "content": prompt}]
)
raw = response.content[0].text.strip()
# strip markdown fences if Claude adds them
raw = raw.replace("json", "").replace("", "").strip()
return json.loads(raw)
a few important things about this step:
the prompt forces Claude to respond in strict JSON - no parsing errors, no surprises. we also strip markdown fences just in case the model wraps the output in them.
the model has to explain its reasoning in one sentence - this helps you sanity-check whether the estimate makes sense.
don't trust the responses blindly. Claude has a knowledge cutoff and doesn't see live news. treat its estimates as a starting point, not gospel.
position sizing with Kelly Criterion
most traders lose money not because they pick the wrong markets but because they bet too much on each one. Kelly Criterion solves this mathematically
it tells you the exact percentage of your bankroll to risk given your estimated edge.
we use Quarter Kelly (0.25x) instead of full Kelly. full Kelly looks great on paper but the variance will make you panic-close winning positions. quarter Kelly lets you sleep:
python
def kelly_position_size(
bankroll: float,
probability: float,
market_price: float,
fraction: float = 0.25
) -> float:
if not (0 < market_price < 1):
return 0.0
b = (1 / market_price) - 1 # decimal odds
q = 1 - probability
kelly = (probability * b - q) / b
if kelly <= 0:
return 0.0 # no edge — skip
position = bankroll * kelly * fraction
return round(position, 2)
if Kelly returns 0 or negative
there's no edge and the agent skips the market entirely. this single filter eliminates most bad trades automatically.
telegram alerts
you don't want to stare at a dashboard all day. the agent should come to you when it finds something worth acting on. we connect it to a Telegram bot so you get a message directly on your phone:
python
import httpx
import asyncio
TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")
CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
async def send_alert(message: str):
url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
async with httpx.AsyncClient() as http:
await http.post(url, json={
"chat_id": CHAT_ID,
"text": message,
"parse_mode": "HTML"
})
async def scan_and_alert(bankroll: float = 1000):
markets = get_active_markets(limit=30)
for market in markets:
question = market.get("question", "")
token_id = market.get("clobTokenIds")
# skip markets without token IDs
if not token_id:
continue
# clobTokenIds is a JSON string like '["abc", "def"]'
try:
token_ids = json.loads(token_id)
yes_token = token_ids[0]
except Exception:
continue
yes_price = get_market_price(yes_token)
if yes_price < 0.05 or yes_price > 0.95:
continue
try:
analysis = estimate_probability(question, yes_price)
except Exception:
continue
edge = analysis.get("edge", 0)
if edge > 0.07 and analysis.get("confidence") != "low":
size = kelly_position_size(bankroll, analysis["estimated_probability"], yes_price)
msg = (
f"<b>EDGE FOUND</b>\n\n"
f"Market: {question}\n"
f"Market price: {yes_price:.0%}\n"
f"My estimate: {analysis['estimated_probability']:.0%}\n"
f"Edge: +{edge:.0%}\n"
f"Suggested size: ${size}\n"
f"Confidence: {analysis['confidence']}\n\n"
f"Reasoning: {analysis['reasoning']}"
)
await send_alert(msg)
the threshold is set at 7% edge minimum. anything below that isn't worth acting on - noise drowns out the signal. you can adjust this number depending on how aggressive you want the agent to be.
trade logging with SQLite
this is the most underrated part of the whole system
without logs you have no idea whether the agent's estimates are actually good over time. with logs you can review every alert, see which markets it found, and measure whether your win rate matches what Kelly predicted:
python
import sqlite3
from datetime import datetime
DB_PATH = "trades.db"
def init_db():
conn = sqlite3.connect(DB_PATH)
conn.execute("""
CREATE TABLE IF NOT EXISTS trades (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT NOT NULL,
market TEXT NOT NULL,
yes_token_id TEXT,
direction TEXT,
entry_price REAL,
size REAL,
my_estimate REAL,
edge REAL,
confidence TEXT,
status TEXT DEFAULT 'alerted'
)
""")
conn.commit()
conn.close()
def log_alert(market, yes_token_id, entry_price, size, estimate, edge, confidence):
conn = sqlite3.connect(DB_PATH)
conn.execute("""
INSERT INTO trades
(timestamp, market, yes_token_id, direction, entry_price, size, my_estimate, edge, confidence)
VALUES (?, ?, ?, 'YES', ?, ?, ?, ?, ?)
""", (datetime.now().isoformat(), market, yes_token_id,
entry_price, size, estimate, edge, confidence))
conn.commit()
conn.close()
def get_stats():
conn = sqlite3.connect(DB_PATH)
row = conn.execute("""
SELECT
COUNT(*) as total_alerts,
ROUND(AVG(edge) * 100, 1) as avg_edge_pct,
ROUND(SUM(size), 2) as total_size_suggested
FROM trades
""").fetchone()
conn.close()
return row
after two weeks of data you'll have a clear picture of whether the agent is finding real edges or just noise
putting it all together
now we tie everything into one script that runs on a schedule - morning scan at 8:30, evening scan at 20:00:
python
import schedule
import time
init_db() # create DB on first run
async def run_scan():
print(f"[{datetime.now().strftime('%H:%M')}] running market scan...")
await scan_and_alert(bankroll=1000)
stats = get_stats()
print(f"total alerts: {stats[0]} | avg edge: {stats[1]}% | total size suggested: ${stats[2]}")
def run_schedule():
schedule.every().day.at("08:30").do(lambda: asyncio.run(run_scan()))
schedule.every().day.at("20:00").do(lambda: asyncio.run(run_scan()))
print("agent is running — waiting for scheduled scans")
while True:
schedule.run_pending()
time.sleep(30)
if __name__ == "__main__":
run_schedule()
save this as main.py. now let's get it running on a server.
deploying to a VPS - step by step for beginners
1. rent a server
create the cheapest Linux server (Ubuntu 22.04). you'll get an IP address and a root password.
2. connect to it
on Mac or Linux open Terminal and type:
bash
ssh root@YOUR_SERVER_IP
on Windows use PuTTY or Windows Terminal.
3. install Python
bash
apt update && apt upgrade -y
apt install python3 python3-pip -y
4. upload your project
on your local machine run:
bash
scp -r ./polymarket-agent root@YOUR_SERVER_IP:/root/
or use GitHub - push your code there (without the .env file) and pull it on the server:
bash
git clone https://github.com/yourusername/polymarket-agent
cd polymarket-agent
5. create the .env file on the server
bash
nano .env
paste your keys, save with Ctrl+X > Y > Enter
6. install dependencies
bash
pip install py-clob-client python-dotenv anthropic httpx schedule requests
7. run it with systemd
create a service file so the bot restarts automatically after reboots:
bash
nano /etc/systemd/system/polybot.service
paste this:
ini
[Unit]
Description=Polymarket AI Agent
After=network.target
[Service]
WorkingDirectory=/root/polymarket-agent
ExecStart=/usr/bin/python3 main.py
Restart=always
RestartSec=10
Environment=PYTHONUNBUFFERED=1
[Install]
WantedBy=multi-user.target
save and start it:
bash
systemctl daemon-reload
systemctl enable polybot
systemctl start polybot
check that it's running:
bash
systemctl status polybot
if you see "active (running)" - your agent is live 24/7
watch live logs:
bash
journalctl -u polybot -f
what the agent is actually capable of
after a few weeks of running it - here's the honest picture of what it does well and where it stops:
> market scanning
the agent reliably surfaces interesting markets you'd never find manually. with 300+ active markets at any time, filtering by volume and edge saves 2-3 hours of daily research
> probability calibration
Claude's estimates are directionally correct roughly 65-70% of the time on well-documented topics like politics and macro. on niche sports markets or very recent news, accuracy drops noticeably
> position discipline
this is where the agent adds the most value for most traders. Kelly sizing removes the emotional component from bet sizing. you stop over-betting markets where you have a gut feeling and under-betting markets where you have a real edge
> pattern tracking
after 4-6 weeks of logs you can see which market categories Claude estimates well and which it doesn't. adjust the edge threshold by category and accuracy improves
what it can't do
it has no access to live news, onchain data, or insider information. it sees the market question and its training data. if the edge exists because of something that happened in the last 24 hours - the agent won't catch it. that's still your job.
conclusion
this is the honest version of the AI trading agent story
two weeks to build, $8/month to run, and it's genuinely useful - not as a money printer, but as a research and discipline tool
the agent handles the grunt work: scanning, sizing, logging
you handle the thinking: reading the news, understanding the context, deciding whether to act on the alert
most people who build something like this and stick with it for 60 days say the same thing: they make fewer impulsive bets, size positions better, and have data to review instead of vibes
this is not a money printer
this is just better trading