lyj3431

[lyj3431 @lyj3431]

@AndrewBolis AI

[lyj3431 @lyj3431]

@Adamaestr0_ Opus

[区块链行情研究 @qkl2058]

有个中国交易员，用Claude Fable 5搭了个交易机器人，还把整个过程录成了完整教程，从头教你怎么复制一个出来。

31分钟，一步步带着走，完全免费。

视频带西班牙语和英语字幕。

可以先存着，以后你会回来谢我的。🔖

[Mr.RC｜𝟎𝐱𝐔 @MrRyanChi]

https://t.co/jxKubqJcGh

[鸟哥 | 蓝鸟会🕊️ @NFTCPS]

微软自己搞了个量化平台，华尔街的量化团队都在偷偷用，你还不知道？

说真的，Qlib这个东西出来好几年了，一直没大火，但一直在被严肃做量化的人用。微软研究院出品，不是那种GitHub上随便开源的玩具，是能上生产环境的框架，从因子挖掘到模型训练到回测到实盘部署，一条龙全给你搞定。

核心能力捋一遍：

1️⃣ 内置一堆SOTA模型，LightGBM、Transformer、TabNet、HIST、IGMTF、KRNN，开箱即用，不用自己从零搭

2️⃣ 全流程覆盖，数据处理、模型训练、回测、组合优化、在线部署，哪个环节都不缺

3️⃣ Concept Drift技术，金融市场一直在变，这框架会自适应，不是训完就摆烂那种

4️⃣ 支持高频，1分钟级K线数据，HFT策略能跑

5️⃣ 最新集成了RD-Agent，就是让LLM自己去挖因子、优化模型，AI做量化研究这条路微软已经在踩了

设计上有几个细节我觉得很重要：点时间数据库这个设计，专门防止未来数据泄露，很多人回测出来一堆假收益，就是栽在这里。模块松耦合，不用整套搬，哪块用哪块。模型还能滚动更新，上线之后继续迭代。

pip install pyqlib，Python 3.8到3.12都支持，Docker镜像也有。

40k星，6k fork，数据说话。

适合真正想做量化的人，来看热闹的可以划走了。

🔗 https://t.co/XRbEfZQRMY

[套利豪仔🗽 @pritipatelfgoo]

https://t.co/HEJhKHvOI2

[鸟哥 | 蓝鸟会🕊️ @NFTCPS]

2026年了，Polymarket日交易量破4亿刀，围绕它的工具生态已经卷成红海

整理了10个预测市场实战工具，从数据分析到自动交易到AI Agent，覆盖完整链路

1、Polymarket API
https://t.co/jcE5SijdKJ
官方三套API体系：Gamma API查市场和事件数据，Data API查持仓和交易记录，CLOB API直接对接订单簿做程序化交易。想做任何Polymarket相关开发，这是起点。

2、PolyCop Bot
https://t.co/SIEvDqhFVG
Polymarket排名第一的跟单机器人，监控目标钱包的交易行为并自动复制操作。之前单独介绍过，适合不想盯盘但想跟住alpha的用户。

3、Insiders
https://t.co/cmdQn1Sj35
一站式预测市场交易平台，主打0延迟交易、一键跟单和内幕信号聚合。把Polymarket的交易体验做了层封装，降低操作门槛。Insiders有个聪明钱回测工具非常好用！

4、Simmer Markets
https://t.co/uQGhAcJTCH
OpenClaw龙虾用户必用的工具，同时支持Polymarket和Kalshi。核心卖点是AI Agent自动交易，已接入OpenClaw生态，平台上跑着10000+个交易Agent。如果你想让AI帮你在预测市场下注，这是目前最成熟的入口。

5、骡子快跑
https://t.co/EqU63m4PpD
如果不想部署龙虾，觉得龙虾太笨的，可以用骡子快跑部署相关Skill，龙虾相当于是雏儿，骡子相当于是少妇，一拍屁股就知道要做是，对于小白用户来说更友好，也是我放弃龙虾之后用的Agent工具。

6、PredWin
https://t.co/0tHiQDrAH2
预测市场交易Bot，刷Polymarket撸空投的用户用的最多，可以自动刷交易量，胜率80%。

7、MiroFish
https://t.co/ZVPBaR345X
00 后北邮大四学生郭航江，用 Vibe Coding 十天做出 MiroFish，连续两次登顶 GitHub 全球趋势榜，2 万+ star，陈天桥 24 小时拍板投了 3000 万。可以用来做事件预测！

8、Awesome Finance Skills
https://t.co/J9U6BqaMBS
开源金融Agent技能集，⭐458 ��50。包含实时新闻聚合（覆盖Polymarket数据源）、情感分析、时序预测、逻辑链路可视化等8个模块。可以直接装到Claude Code / OpenCode等Agent框架里用。

9、PolyActivity
https://t.co/Q5eA9AQ49z
聚焦Smart Money信号追踪，实时监控大户动向和Featured Traders操作。界面简洁，适合快速捕捉聪明钱的方向性押注。

10、Predictfolio
https://t.co/38DbpYga4b
Polymarket数据分析平台，追踪250万+交易者的PnL、持仓和胜率。自带排行榜，能看到头部玩家的持仓变化和历史收益曲线，总追踪交易量超$141B。做研究和跟单参考都够用。

[Z大诗 @Zh_Crypto517]

🎉字节跳动终于开源了超级智能体🦌DeerFlow - 2.0！

我愿称之为：更适合中国宝宝体质的OpenClaw
目前已经在GitHub上斩获 44k stars 霸榜 Trending

DeerFlow 2.0 是一个开源的 SuperAgent 编排框架，可将Skills、Sub-Agents、长短期记忆、沙盒文件系统、外部工具/渠道全部整合在一起，完成从深度研究到代码生成与多步创作的复杂任务

- 技能与工具系统：通过skills扩展能力，按需调用检索、编码、执行、爬取等工具，可快速接入自定义技能

- 子代理编排：将复杂任务拆分为可协作的子代理，分别负责研究、规划、编码、审阅等角色并在统一上下文中协作

- 沙盒与文件系统：在隔离环境中运行与修改文件，支持安全实验、代码生成、批量重构与结果留存

- 上下文工程与长期记忆：在任务链路中持续注入关键上下文，记录与复用长期记忆，以减少重复决策与信息丢失

DeerFlow 2.0 支持 OpenAI/OpenRouter/Claude Code/Codex 等多模型，MCP 与 IM 渠道接入，企业与个人都能即开即用！

原项目仓库🔗：https://t.co/QPcOV8L5ic

[Biteye @BiteyeCN]

https://t.co/wd5aG4PSqq

[lyj3431 @lyj3431]

@Jlbcode 收到

[套利豪仔🗽 @pritipatelfgoo]

https://t.co/xYUxReBklt

[lyj3431 @lyj3431]

@Jlbcode 最近太忙了，一直没关注x刚看到信息！
住早日康复，身体健康！

[Mr.RC｜𝟎𝐱𝐔 @MrRyanChi]

https://t.co/TEUP3779I5

[白云☁️ @iBaiyun04]

再来分享一个polymarket加密货币5min/15min市场信息获取脚本，运行输出内容包括：定位当前市场，目标价获取，yes/no 的tokenid获取，订单薄信息，流动性，手续费计算等，想要初步搭建量化机器人的可以参考(缩进格式未能正确显示，复制给AI让它还原)：

"""
Polymarket 5min / 15min Up-or-Down 市场发现 & 实时价格获取

功能:
1. 自动计算下一个 5min / 15min 时间区间
2. 通过 Gamma API 查找对应的市场 (slug, tokenId, 当前价格等)
3. 通过 CLOB REST API 获取实时 orderbook (无需认证, 无需安装额外库)
4. 支持自定义币种列表 (BTC, ETH, SOL, XRP 等)

依赖:
pip install requests

无需安装 py_clob_client — 本脚本仅使用公开 REST API, 不需要私钥或认证。

原理:
Polymarket 会提前创建未来的 5min/15min 市场, slug 格式固定:
{coin}-updown-{interval}-{unix_timestamp}
例如: btc-updown-15m-1773127800
其中 unix_timestamp 是时间区间的结束时间 (整 5/15 分钟对齐)

"""

import time
import json
import requests
from datetime import datetime, timezone

# ==============================================================================
# 配置
# ==============================================================================

# Polymarket API 地址 (公开, 无需认证)
GAMMA_API = "https://t.co/3EIRaLEFB3"
CLOB_API = "https://t.co/zqEXz2DAIl"

# 支持的币种 — 可自行增减
# 目前 Polymarket 开放了 BTC, ETH, SOL, XRP 的短周期市场
COINS = ["btc", "eth", "sol", "xrp"]

# 支持的时间周期
INTERVALS = {
"5m":  {"seconds": 300,  "label": "5分钟"},
"15m": {"seconds": 900,  "label": "15分钟"},
}

# HTTP Session (带重试)
SESSION = requests.Session()
SESSION.headers.update({"Accept": "application/json"})

# ==============================================================================
# 工具函数
# ==============================================================================

def get_next_interval_ts(interval_sec: int) -> int:
"""计算下一个时间区间的结束时间戳 (Unix秒)。

Polymarket 的 slug 中使用的 timestamp 是区间结束时间,
且严格对齐到整 5/15 分钟。

例如: 当前 07:22 UTC
- 5min  -> 下一个区间 07:20-07:25, ts = 07:25 对应的 Unix 时间
- 15min -> 下一个区间 07:15-07:30, ts = 07:30 对应的 Unix 时间
"""
now = int(time.time())
return (now // interval_sec + 1) * interval_sec

def get_current_interval_ts(interval_sec: int) -> int:
"""计算当前正在进行的区间的结束时间戳。

如果你想查看 "正在交易中" 的市场, 用这个。
"""
now = int(time.time())
# 当前区间 = 上一个对齐点 + interval
return (now // interval_sec) * interval_sec + interval_sec

# ==============================================================================
# Gamma API — 市场发现
# ==============================================================================

def find_market(coin: str, interval: str, interval_ts: int) -> dict | None:
"""通过 Gamma API 查找指定的 updown 市场。
参数:
coin:        币种 (btc, eth, sol, xrp)

interval:    时间周期 ("5m" 或 "15m")
interval_ts: 区间结束时间戳
返回:
市场信息字典, 或 None (市场不存在/未创建)

"""
slug = f"{coin}-updown-{interval}-{interval_ts}"
try:
resp = SESSION.get(

f"{GAMMA_API}/events",
params={"slug": slug},
timeout=10,
)
resp.raise_for_status()
events = resp.json()
except Exception as e:
print(f"  [ERROR] Gamma API 请求失败: {e}")
return None
if not events:
return None

# events 是一个列表, 通常只有一个元素
event = events[0]

markets = event.get("markets", [])
if not markets:
return None
m = markets[0]
# clobTokenIds 可能是 JSON 字符串, 需要解析

tokens = m.get("clobTokenIds", [])

if isinstance(tokens, str):
tokens = json.loads(tokens)
if len(tokens) < 2:
return None
# outcomePrices 同样可能是 JSON 字符串
prices = m.get("outcomePrices", [])

if isinstance(prices, str):
prices = json.loads(prices)
# outcomes: ["Up", "Down"]
outcomes = m.get("outcomes", [])

if isinstance(outcomes, str):
outcomes = json.loads(outcomes)
return {
"slug":           slug,

"question":       m.get("question", ""),
"condition_id":   m.get("conditionId", ""),
"up_token":       tokens[0],        # YES / Up 的 tokenId
"down_token":     tokens[1],        # NO / Down 的 tokenId
"outcomes":       outcomes,          # ["Up", "Down"]
"outcome_prices": [float(p) for p in prices] if prices else [],
"neg_risk":       m.get("negRisk", False),
"best_bid":       m.get("bestBid"),
"best_ask":       m.get("bestAsk"),
"spread":         m.get("spread"),
"last_price":     m.get("lastTradePrice"),
"liquidity":      event.get("liquidity"),
"volume":         m.get("volume"),
"end_date":       m.get("endDate", ""),
"active":         m.get("active", False),
"closed":         m.get("closed", False),
}
# ==============================================================================
# CLOB API — 实时 Orderbook (公开, 无需认证)

# ==============================================================================
def get_orderbook(token_id: str) -> dict | None:
"""获取指定 token 的实时 orderbook。
注意: asks 按价格 *降序* 排列 (最贵在前, 最便宜在后)。

所以最优卖价 (best ask) = asks[-1], 不是 asks[0]!
返回:
{

"bids": [{"price": "0.45", "size": "100"}, ...],  # 升序
"asks": [{"price": "0.99", "size": "50"}, ...],    # 降序

"best_bid": float,
"best_ask": float,
"spread": float,
"mid_price": float,
"tick_size": str,
"min_order_size": str,
}
"""
try:
resp = SESSION.get(
f"{CLOB_API}/book",
params={"token_id": token_id},
timeout=10,
)
resp.raise_for_status()
data = resp.json()
except Exception as e:
print(f"  [ERROR] CLOB orderbook 请求失败: {e}")
return None
bids = data.get("bids", [])
asks = data.get("asks", [])
# best bid = bids 中最高价 (bids 升序, 最后一个)
best_bid = float(bids[-1]["price"]) if bids else 0

# best ask = asks 中最低价 (asks 降序, 最后一个)
best_ask = float(asks[-1]["price"]) if asks else 1

return {
"bids":           bids,
"asks":           asks,
"best_bid":       best_bid,

"best_ask":       best_ask,
"spread":         round(best_ask - best_bid, 4),
"mid_price":      round((best_ask + best_bid) / 2, 4),
"tick_size":      data.get("tick_size", "0.01"),
"min_order_size": data.get("min_order_size", ""),
"last_price":     data.get("last_trade_price", ""),
}
def get_top_asks(token_id: str, n: int = 5) -> list[tuple[float, float]]:
"""获取最优的 N 个卖单 (价格从低到高)。
返回: [(price, size), ...]
"""

book = get_orderbook(token_id)
if not book or not book["asks"]:

return []
asks = book["asks"]
# asks 降序 -> 取最后 n 个, 再反转为升序
bottom_n = asks[-n:] if len(asks) >= n else asks[:]
return [(float(a["price"]), float(a["size"])) for a in reversed(bottom_n)]

# ==============================================================================
# 综合查询: 一次获取所有币种 + 所有周期的市场信息
# ==============================================================================
def scan_all_markets(coins: list[str] = None, intervals: list[str] = None):

"""扫描所有币种 x 所有时间周期, 打印市场信息和实时价格。
参数:
coins:     币种列表, 默认 COINS

intervals: 周期列表, 默认 ["5m", "15m"]
"""

if coins is None:
coins = COINS
if intervals is None:
intervals = list(INTERVALS.keys())
print("=" * 80)
print("  Polymarket Up-or-Down 市场扫描器")
print(f"  时间: {https://t.co/iHTPC8QASx(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')} UTC")
print(f"  币种: {', '.join(c.upper() for c in coins)}")

print(f"  周期: {', '.join(intervals)}")
print("=" * 80)
for interval in intervals:
cfg = INTERVALS[interval]
interval_sec = cfg["seconds"]
# 当前正在进行的区间

current_ts = get_current_interval_ts(interval_sec)
# 下一个区间
next_ts = current_ts + interval_sec

current_end = datetime.fromtimestamp(current_ts, tz=timezone.utc)
next_end = datetime.fromtimestamp(next_ts, tz=timezone.utc)
print(f"\n{'─' * 80}")
print(f"  {cfg['label']} ({interval}) 市场")

print(f"  当前区间结束: {current_end.strftime('%H:%M:%S')} UTC (ts={current_ts})")
print(f"  下一区间结束: {next_end.strftime('%H:%M:%S')} UTC (ts={next_ts})")

print(f"{'─' * 80}")
for coin in coins:
print(f"\n  [{coin.upper()}]")
# ── 查找当前区间的市场 ──
market = find_market(coin, interval, current_ts)

if market is None:
print(f"    当前区间: 未找到市场 (可能已结算或尚未创建)")

else:
_print_market(market, "    当前区间")
# ── 查找下一个区间的市场 ──
market_next = find_market(coin, interval, next_ts)
if market_next is None:
print(f"    下一区间: 未找到市场 (尚未创建)")

else:
_print_market(market_next, "    下一区间")
def _print_market(market: dict, prefix: str):
"""打印单个市场的详细信息。"""
prices = market["outcome_prices"]
up_price = prices[0] if prices else "?"

dn_price = prices[1] if len(prices) > 1 else "?"
print(f"{prefix}: {market['slug']}")
print(f"      问题:    {market['question']}")
print(f"      状态:    {'交易中' if market['active'] and not market['closed'] else '已关闭'}")
print(f"      Up价格:  {up_price}  |  Down价格: {dn_price}")

print(f"      最优买:  {market['best_bid']}  |  最优卖: {market['best_ask']}  |  价差: {market['spread']}")
print(f"      流动性:  ${market['liquidity']:,.2f}" if market['liquidity'] else "")
print(f"      成交量:  ${float(market['volume']):,.2f}" if market['volume'] else "")
print(f"      negRisk: {market['neg_risk']}")
print(f"      Up Token:   {market['up_token'][:40]}...")
print(f"      Down Token: {market['down_token'][:40]}...")
# 获取实时 orderbook 深度
print(f"      ── Orderbook (Up/YES) ──")
top_asks = get_top_asks(market["up_token"], n=5)
if top_asks:
for i, (price, size) in enumerate(top_asks):
tag = " <-- best ask" if i == 0 else ""
print(f"        ASK {i+1}: {price:.2f} x {size:.1f}{tag}")
else:
print(f"        (无 asks)")
# ==============================================================================

# 单币种快速查询
# ==============================================================================
def quick_lookup(coin: str, interval: str = "15m") -> dict | None:
"""快速查询指定币种的当前市场, 返回完整信息。
使用示例:
info = quick_lookup("btc", "15m")
print(info["outcome_prices"])  # [0.52, 0.48]
print(info["orderbook"]["best_ask"])  # 0.49
"""
cfg = INTERVALS[interval]

current_ts = get_current_interval_ts(cfg["seconds"])
market = find_market(coin, interval, current_ts)
if market is None:

return None
# 附加 orderbook 信息
book_up = get_orderbook(market["up_token"])

book_dn = get_orderbook(market["down_token"])
market["orderbook_up"] = book_up
market["orderbook_down"] = book_dn
return market
# ==============================================================================
# 手续费计算
# ==============================================================================

def compute_fee(shares: float, price: float) -> float:
"""计算 Polymarket crypto 市场的手续费 (以 shares 计)。
公式: fee_shares = shares * 0.25 * (price * (1 - price))^2

最大费率: ~1.56% (当 price = 0.50)
越接近 0 或 1 的价格, 手续费越低。
"""

return shares * 0.25 * (price * (1 - price)) ** 2
def estimate_profit(shares: int, buy_price: float, win: bool) -> dict:

"""估算单笔交易的盈亏。
参数:

shares:    购买的 shares 数量
buy_price: 买入价格 (0~1)
win:       是否预测正确

返回:
{"cost": ..., "fee": ..., "payout": ..., "pnl": ..., "roi": ...}

"""
cost = shares * buy_price
fee = compute_fee(shares, buy_price)
if win:
# 赢: 每个 share 赎回 $1, 但实际持有 = shares - fee_shares
actual_shares = shares - fee

payout = actual_shares * 1.0
pnl = payout - cost

else:
# 输: 亏掉全部 cost
payout = 0
pnl = -cost

return {
"shares":        shares,
"buy_price":     buy_price,
"cost":          round(cost, 4),
"fee_shares":    round(fee, 4),

"actual_shares": round(shares - fee, 4),
"payout":        round(payout, 4),
"pnl":           round(pnl, 4),
"roi_pct":       round(pnl / cost * 100, 2) if cost > 0 else 0,
}
# ==============================================================================
# 持续监控模式
# ==============================================================================
def monitor(coins: list[str] = None, interval: str = "15m", refresh_sec: int = 30):

"""持续监控模式: 每隔 refresh_sec 秒刷新一次市场价格。
按 Ctrl+C 退出。
"""
if coins is None:
coins = COINS
cfg = INTERVALS[interval]
interval_sec = cfg["seconds"]
print(f"\n  持续监控模式 ({interval}, 每{refresh_sec}秒刷新)")
print(f"  币种: {', '.join(c.upper() for c in coins)}")
print(f"  按 Ctrl+C 退出\n")

try:
while True:
current_ts = get_current_interval_ts(interval_sec)

remaining = current_ts - int(time.time())
end_time = datetime.fromtimestamp(current_ts, tz=timezone.utc)

print(f"  [{https://t.co/iHTPC8QASx(timezone.utc).strftime('%H:%M:%S')} UTC] "
f"区间结束: {end_time.strftime('%H:%M:%S')} (剩余 {remaining}s)")
header = f"  {'Coin':>5s} | {'Up':>6s} | {'Down':>6s} | {'BestAsk':>8s} | {'Spread':>7s} | {'Volume':>10s}"
print(header)
print(f"  {'─' * len(header)}")
for coin in coins:

market = find_market(coin, interval, current_ts)
if market is None:
print(f"  {coin.upper():>5s} | {'N/A':^6s} | {'N/A':^6s} | {'N/A':^8s} | {'N/A':^7s} | {'N/A':^10s}")

continue
prices = market["outcome_prices"]
up_p = f"{prices[0]:.3f}" if prices else "?"
dn_p = f"{prices[1]:.3f}" if len(prices) > 1 else "?"
ask = f"{market['best_ask']:.2f}" if market['best_ask'] else "?"
spread = f"{market['spread']:.3f}" if market['spread'] else "?"
vol = f"${float(market['volume']):,.0f}" if market['volume'] else "?"
print(f"  {coin.upper():>5s} | {up_p:>6s} | {dn_p:>6s} | {ask:>8s} | {spread:>7s} | {vol:>10s}")
print()
time.sleep(refresh_sec)

except KeyboardInterrupt:
print("\n  监控已停止。")
# ==============================================================================
# 主入口
# ==============================================================================
if __name__ == "__main__":
import sys
# 支持命令行参数:
#   python find_markets_tutorial.py                    # 扫描所有
#   python find_markets_tutorial.py monitor             # 持续监控模式
#   python find_markets_tutorial.py btc eth             # 只看指定币种
#   python find_markets_tutorial.py btc 5m              # 指定币种 + 周期

args = sys.argv[1:]
if "monitor" in args:
args.remove("monitor")
coins = [a for a in args if a in COINS] or None
monitor(coins=coins)
else:
coins = [a for a in args if a in COINS] or None
intervals = [a for a in args if a in INTERVALS] or None
scan_all_markets(coins=coins, intervals=intervals)
# 演示: 快速查询 + 盈亏估算
print("\n" + "=" * 80)
print("  快速查询演示: BTC 15min")
print("=" * 80)

info = quick_lookup("btc", "15m")
if info:
prices = info["outcome_prices"]
print(f"  市场:   {info['slug']}")
print(f"  Up:     {prices[0]:.3f}  |  Down: {prices[1]:.3f}")
book = info.get("orderbook_up")
if book:
print(f"  BestAsk(Up): {book['best_ask']:.2f}  |  BestBid: {book['best_bid']:.2f}")
print(f"  Spread:      {book['spread']:.4f}  |  MidPrice: {book['mid_price']:.4f}")
# 盈亏估算示例
ask_price = book["best_ask"] if book else 0.50
print(f"\n  盈亏估算 (买入 10 shares Up @ {ask_price}):")
for outcome in [True, False]:
r = estimate_profit(10, ask_price, win=outcome)
label = "预测正确" if outcome else "预测错误"

print(f"    {label}: 成本=${r['cost']:.2f}, "
f"手续费={r['fee_shares']:.4f}shares, "
f"实际持有={r['actual_shares']:.4f}, "
f"收益=${r['pnl']:+.4f} (ROI {r['roi_pct']:+.2f}%)")
else:
print("  未找到 BTC 15min 市场 (可能当前区间已结算)")

[leifu _/ @leifuchen]

昨天转发了一篇用 Deribit 波动率曲面推导 Polymarket 二元期权定价的思路。一位做 PM 自动化交易的大哥@jtrevorchapman 告诉我，他几个月前试过类似的路径，结论是在 15 分钟尺度上，波动率曲面能给的信息，市场微结构信号可以更快更准地捕捉到。

我赶紧去看了大哥的实盘，发现他当前使用的交易系统表现非常优秀，盈利因子 4.29（每亏 $1，能赚回 $4.29），胜率 93%，而且他有问必答毫无保留。

热心哥的核心系统是一个三层架构：记忆 → 信号 → 防御

1. 记忆层
每个 session 开始，先扫描最近 30 +个已结束的 session，找出最像当前盘面的历史 session。比如当前 BTC 价格在某个位置、波动率是某个水平、市场情绪是某个状态，在过去类似的session中，最后结果是 UP 赢得多还是 DOWN 赢得多？如果是 UP 多，那么系统会带着这个“历史经验”（先验偏差）进入下一层。

2. 信号层
这层关注实时数据，每秒钟运行8-12条规则，然后独立投票UP / DOWN + 置信度（0-100%）。这些规则中热心哥认为 CVD（累计主动买卖量差）是预测力最强的单一指标。其他还有预言机报价距离、 Binance 动量、订单簿不平衡、UP / DOWN 代币价格走势（反映 PM 上所有参与者的集体判断）。

所有规则按置信度加权，得出方向和综合置信度，如“方向 YES，综合置信度约 65%”。

3. 防御层
方向确定后，用五个因子算出一个 0-1 系数，直接乘到仓位上，1 就是全仓执行，0 就不做。所以同样一个"65% 置信度 YES"的信号，根据防御层的评估，仓位大小也会有区别。这五个因子如下：
- CVD 同不同意？如果信号层说 UP，但 Binance 上的净卖压很大（CVD 不同意），仓位直接大幅压缩。CVD是热心哥极其看重的因子，在session混乱的情况下（预言机报价反复穿越基准价格 5 次），CVD 甚至有一票否决权（系数降为 0）。
- 距离基准价格多少？如果 BTC 现价和基准价咬得很紧，说明随时可能翻盘，需要压缩仓位。
- session 剩多少时间？如果只剩最后两三分钟，任何突发波动都来不及反应，风险陡增。
- 当前 session 预言机报价反复穿越了基准价格几次？超过 5 次就算混乱。混乱市场里信号可靠性大打折扣，仓位要激进压缩。
- 当前入场价的利润空间够不够？入场价越高，对胜率的要求也越高，所以系统在高价位时对信号可信度要求极高。比如 $0.95 入场时，只允许最无歧义最干净的信号通过。

除了核心系统之外，热心哥还提过几个额外细节：
- 只做 BTC，不做 ETH 市场，估计是 ETH 的信号不稳定
- 用 40 天、每 200 毫秒记录一次的数据做回测，发现在 session 剩余 6 分钟的时候指标才开始可靠。他用这个来衡量反转风险，过滤掉不该进的session。

限于时间没有全部整理完，他时间线上还有很多细节，推荐去翻翻。原文来自这篇回复：
https://t.co/jorScblOUy

[leifu _/ @leifuchen]

上篇介绍了热心哥 @jtrevorchapman 的 Polymarket 15m 三层滤网系统（盈利因子 4.29，胜率 93%）。这篇聊了聊他作为非程序员背景，如何通过 vibe coding 从零搭了一套稳定盈利的交易系统。信息依然是整理自他的回复。

他是从 12 月 12 日开始搭建，每天孩子睡后干到凌晨 5 点，经历了十几种策略才找到稳定盈利的三层滤网系统，如果没看过上篇，评论区有链接。

多智能体协同
使用的是 Claude Opus 和 Gemini Flash，其中 Claude Opus 负责写代码，Gemini Flash 负责数据研究。

这么分工的原因是 Gemini 写代码时太喜欢自作主张，会擅自改他没要求改的部分。

选择 Flash 而不是 Codex，看来大哥是买了 Google 全家桶了，当然他的这个经验和目前的研究是一致的，适量的多智能体协同确实是可以提高工作质量和效率。

调试方法论
这是我觉得最值得学习的部分：每次亏损后，回到日志里，问自己：“如果我能在这个瞬间暂停时间，我会怎么解决这笔亏损？”想清楚之后让 AI 把解法写成代码。

这个思路决定了他对日志的要求极高，需要记录数据点、决策分支、执行函数。因为没有详尽的日志，根本没法回到那个瞬间去复盘。

三条原则
1、编写代码时需要提供精确的指令（prompt），要像外科手术一样，否则 AI 会按它训练时默认的方式进行实现，这往往会搞砸苦心研究的策略。（其实很多人目前是主张应该顺着 AI 默认的方式进行，这可能是量化和其他领域编程的一个区别。）

2、研究策略时要求 AI 直说、不要迎合，鼓励 AI 反驳自己的看法而不是让 AI 顺着自己说。（这可能是大哥用 Gemini Flash 而不是 Opus 做研究的原因。）

3、不要轻信 AI 给出的的结论一定要多角度验证。他这里举了个有趣的例子，他早期有几周的成交率数据全是错的，自以为策略赚了钱，结果钱包余额却越来越少。（这是很多人都碰到过得问题吧，因为延迟造成的滑点，使得策略产生亏损，程序记录盈亏时按照触发价而不是实际成交价进行，导致表面盈利实际亏损。）

[lyj3431 @lyj3431]

@nzyyj 怎么玩？

[lyj3431 @lyj3431]

@sabir_huss50540 Claude

[lyj3431 @lyj3431]

@0xFrogify 11

[lyj3431 @lyj3431]

@ClawsAIsol 7BVg64G98YCv3Y7iYM2EqpRDNzFm1ruQHEf1g2TDwu1q