วิธีสร้างฝูง AI Agent เพื่อล่า Alpha ตลอด 24 ชั่วโมง

ฉันจะอธิบายวิธีการสร้างฝูง AI agent ที่มาแทนที่ทีมวิจัยเชิงปริมาณทั้งหมด

มาเริ่มกันเลย

บุ๊กมาร์กไว้นะ

- ผมชื่อ Roan เป็นนักพัฒนาแบ็กเอนด์ที่ทำงานด้าน system design, การเทรดแบบ HFT และระบบเทรดเชิงปริมาณ ผลงานของผมเน้นไปที่พฤติกรรมของ prediction markets ภายใต้ภาระงานจริง สำหรับข้อเสนอแนะ ความร่วมมือ หรือพาร์ทเนอร์ชิป สามารถส่ง DM มาหาผมได้

ในบทความล่าสุดของผม ผมบอกว่าจะพาคน 20 คนแรกที่กำลังสร้างระบบ AI เชิงปริมาณผ่านแต่ละขั้นตอนด้วยตัวเอง ผมหมายความตามนั้นจริงๆ

ตอนนี้มีผู้สร้างสี่คนที่กำลังดำเนินการร่วมกับผมอย่างจริงจัง หนึ่งในนั้นกำลังรันวงจร hedge fund ที่พัฒนาตัวเองได้เต็มรูปแบบอยู่ตอนนี้

ข้อเสนอยังคงเปิดอยู่

ถ้าคุณกำลังสร้างระบบวิจัยอัลฟา กำลังจะเริ่ม หรือแค่กำลังคิดอยู่ ตอบกลับใต้บทความนี้หรือส่ง DM บอกเซ็ตอัปปัจจุบันของคุณมา ผมจะพาคุณดูสถาปัตยกรรมของคุณทีละขั้น และชี้ให้เห็นช่องว่างระหว่างสิ่งที่คุณมีกับฝูงที่ล่าอัลฟาได้ด้วยตัวเอง

ถ้าผมไม่ตอบกลับ แสดงว่าคุณไม่อยู่ใน 20 คนแรก รีบหน่อย

นักเทรดเชิงปริมาณส่วนใหญ่ยังคงล่าอัลฟาแบบเดียวกับที่ทำเมื่อสิบปีก่อน

พวกเขาอ่านงานวิจัย เปิด Jupyter notebook สร้างฟีเจอร์สองสามตัว รัน backtest จ้อง Sharpe ratio แล้วก็ไปต่อที่ไอเดียถัดไป

พวกเขาคือไปป์ไลน์

ทุกขั้นตอนของการวิจัยคือตัวพวกเขา นั่งอยู่หน้าจอ รันสมมติฐานทีละอัน

ผู้สร้างระบบเชิงปริมาณที่ฉลาดที่สุดในโลกหยุดทำแบบนั้นแล้ว

พวกเขาสร้างฝูง แต่ละ agent ในฝูงเป็นเจ้าของหนึ่งขั้นตอนของการวิจัย agent ทำงานแบบขนาน ฝูงทำงานต่อเนื่อง อัลฟาใหม่ปรากฏขึ้นทุกเช้าขณะที่พวกเขาหลับ

Boris Cherny หัวหน้า Claude Code ที่ Anthropic พูดไว้เมื่อสองสัปดาห์ก่อน "ผมไม่ prompt Claude อีกแล้ว ผมมีลูปที่รันเพื่อ prompt Claude และหาว่าต้องทำอะไร งานของผมคือเขียนลูป"

ประโยคเดียวนั้นเปลี่ยนวิธีคิดของผู้สร้างจริงจังทุกคนบนโลกเกี่ยวกับ AI

สำหรับการวิจัยเชิงปริมาณ มันเปลี่ยนทุกอย่าง

เพราะการวิจัยอัลฟาเป็นไปป์ไลน์อยู่แล้ว อ่านงานวิจัย ดึงสมมติฐาน สร้างฟีเจอร์ ทดสอบย้อนหลังกับข้อมูล 20 ปี ตรวจสอบนัยสำคัญ ตรวจสอบว่าสัญญาณอยู่รอดข้ามสภาวะตลาดหรือไม่ แยกองค์ประกอบเทียบกับทุกปัจจัยที่รู้จัก

ทุกกองทุนจริงจังบน Wall Street รันไปป์ไลน์นั้น Renaissance รันด้วย PhD 100 คน Two Sigma รันด้วย 200 คน Citadel รันด้วยมากกว่านั้น

ข้อแตกต่างเพียงอย่างเดียวคือพวกเขาต้องการมนุษย์หลายร้อยคนนั่งอยู่ในไปป์ไลน์ คุณไม่ต้องการ

ฝูงของ AI agent สามารถรันทุกขั้นตอนของไปป์ไลน์นั้นให้คุณได้ แต่ละ agent เชี่ยวชาญเฉพาะด้าน แต่ละ agent รันบนโมเดลที่เหมาะกับความซับซ้อนของมัน ทั้งหมดทำงาน 24/7 แบบขนาน

ผมสร้างฝูงนี้มาสองสามวันที่ผ่านมา

มันอ่านงานวิจัยใหม่ๆ ข้ามคืน มันศึกษาคณิตศาสตร์ภายในงานวิจัย มันดึงสมมติฐานที่ถูกอ้างออกมาอย่างแม่นยำ มันสร้างฟีเจอร์ที่จำเป็น มันทดสอบสัญญาณย้อนหลังกับประวัติศาสตร์ 20 ปี มันรันการตรวจสอบทางสถิติ มันตรวจสอบ overfitting มันแจ้งเตือนอะไรก็ตามที่ใช้ได้แค่ในสภาวะตลาดเดียว

เมื่ออ่านบทความนี้จบ คุณจะรู้สถาปัตยกรรมที่แน่นอนของฝูงวิจัยอัลฟาหก agent

คุณจะรู้เครื่องมือที่ให้คุณสร้างมันได้ในสุดสัปดาห์เดียว โดยไม่ต้องเขียน agent framework ของคุณเองตั้งแต่ต้น

และคุณจะรู้รูปแบบความล้มเหลวห้าแบบที่ฆ่าความพยายามของนักเทรดรายย่อย 90 เปอร์เซ็นต์

มาเริ่มกันเลย

ส่วนที่ 1: ฝูงคืออะไรจริงๆ

Prompt คือคำถาม คุณถาม โมเดลตอบครั้งเดียว แล้วก็หยุด

ลูปคืองาน agent ทำงานต่อไป ตรวจสอบความคืบหน้าของตัวเอง และทำต่อไปจนกว่างานจะเสร็จจริงๆ

ฝูงคือหลายลูปที่ทำงานแบบขนาน แต่ละลูปคือผู้เชี่ยวชาญ แต่ละผู้เชี่ยวชาญเป็นเจ้าของหนึ่งขั้นตอนของไปป์ไลน์ ผลลัพธ์ของอันหนึ่งป้อนเข้าสู่อันถัดไป

นั่นคือโมเดลทางความคิดทั้งหมด

ถ้าคุณเคยใช้ Claude Code, Cursor หรือ Codex คุณเคยใช้ลูปโดยไม่รู้ตัว agent เรียกโมเดล โมเดลเลือกการกระทำ การกระทำทำงาน ผลลัพธ์กลับไปยังโมเดล และมันทำซ้ำจนกว่าจะบรรลุเป้าหมาย

ลูปคือสิ่งที่ทำให้ agent เป็น agent แทนที่จะเป็นคำตอบเดียว

ฝูงคือสิ่งที่ทำให้ทีมวิจัยเป็นทีมวิจัย แทนที่จะเป็นนักวิจัยคนเดียวที่พิมพ์

ส่วนที่ 2: เครื่องมือที่รันฝูง

คุณอาจลองสร้างสิ่งนี้ด้วยตัวเองโดยใช้ Python script ที่เรียกใช้ API ต่างๆ

ผมลองแล้ว มันพังทันทีที่ agent หนึ่งต้องรออีกตัว มันพังทันทีที่คุณต้องการให้สถานะคงอยู่ข้ามรอบ มันพังทันทีที่คุณต้องการรันหกลูปแบบขนานบนโมเดลต่างๆ

คุณลงเอยด้วยการสร้าง agent framework ของคุณเองตั้งแต่ต้นแทนที่จะทำวิจัย

แล้วผมก็เจอ Slate

Slate คือ AI coding harness ที่สร้างโดย @wearerandomlabs มันรันใน terminal ของคุณ มันกระจายงานใดๆ ออกเป็นฝูงของ subagents ทั่วทั้ง codebase ของคุณ มันเลือกโมเดลใดก็ได้ที่คุณต้องการในทุกขั้นตอน การสมัครสมาชิกที่มีอยู่ของคุณก็ใช้ได้

เหตุผลที่ผมใช้มันสำหรับฝูงนี้คือความสามารถที่พวกเขาเพิ่งเปิดตัวชื่อ Programs

Program คือลูปที่เขียนด้วย JavaScript ซึ่ง Slate รันให้คุณ

Prompt รันครั้งเดียวแล้วหยุด Program คือลูปที่ถูกออกแบบมา มันรันต่อเนื่อง มันเก็บสถานะระหว่างการรัน มันทำต่อไปจนกว่างานจะเสร็จ

คุณตัดสินใจว่าเกิดอะไรขึ้นในแต่ละขั้นตอน โมเดลไหนจัดการขั้นตอนไหน ลูปตรวจสอบอะไรก่อนที่จะดำเนินต่อ เมื่อไหร่ที่มันหยุด

คุณไม่ได้เขียน Program เพียงลำพัง คุณบอก Slate ว่าคุณต้องการอะไร และมันร่างลูปไปพร้อมกับคุณ ทีละขั้น มันบันทึกลูป มันรันมัน มันรันมันต่อไป

เพราะลูปคือโค้ด มันสามารถเก็บสถานะ โต้ตอบกับ codebase ของคุณ เรียกใช้ API ภายนอก โพสต์ไปยัง Slack และจัด orchestrate หลาย subagents แบบขนานบนโมเดลผสมใดก็ได้ที่คุณเลือก โมเดล open-weight ราคาถูกสำหรับงานง่าย โมเดล frontier สำหรับการใช้เหตุผลยาก อะไรก็ได้ที่เหมาะกับขั้นตอนนั้น

สำหรับฝูงวิจัยหก agent นี่คือเลเยอร์ที่เคยหายไป

คุณสามารถหา Slate ได้ที่ https://randomlabs.ai มันพร้อมใช้งานแล้ววันนี้

ตอนนี้ให้ผมแสดงฝูงให้คุณดู

ส่วนที่ 3: หก Agent

ทุกกองทุนเชิงปริมาณจริงจังรันหกขั้นตอนการวิจัยเดียวกัน

นี่คือฝูงที่มาแทนที่พวกมัน

Agent 1: ตัวสร้างไอเดีย

อ่านงานวิจัยใหม่จาก arXiv q-fin, SSRN และวารสารการเงินทุกคืน

ศึกษาแบบจำลองทางคณิตศาสตร์ที่งานวิจัยแต่ละชิ้นเสนอ ดึงสมมติฐานที่ถูกอ้างออกมาอย่างแม่นยำ ข้อมูลที่ต้องการ และทิศทางของสัญญาณที่คาดการณ์

เขียนแต่ละสมมติฐานเป็นตั๋ววิจัยที่มีโครงสร้างซึ่ง agent ถัดไปสามารถหยิบไปใช้

รันบนโมเดลที่เร็วและคุ้มค่า เพราะงานคือการดึงข้อมูลที่มีโครงสร้างปริมาณมาก

Agent 2: วิศวกรฟีเจอร์

รับตั๋วสมมติฐาน ดึงข้อมูลที่ต้องการจากฐานข้อมูลราคาหรือฐานข้อมูลพื้นฐาน

สร้างเวกเตอร์ฟีเจอร์ ปรับมาตรฐานข้ามกลุ่มตัวอย่าง จัดการค่าที่หายไป ค่าผิดปกติที่เกินสามส่วนเบี่ยงเบนมาตรฐาน และอคติจากการมองไปข้างหน้า

ส่งออก dataframe ที่สะอาดพร้อมสำหรับการทดสอบย้อนหลัง

Agent 3: ผู้ทดสอบย้อนหลัง

รับเวกเตอร์ฟีเจอร์ สร้างกฎการสร้างพอร์ตโฟลิโอ รันการทดสอบย้อนหลังทางประวัติศาสตร์กับข้อมูล 20 ปี โดยมีต้นทุนธุรกรรมที่สมจริง ต้นทุนการยืมสำหรับฝั่งชอร์ต และ slippage

ส่งออก Sharpe ratio, maximum drawdown, turnover และประมาณการความสามารถในการรองรับ

Agent 4: ผู้ตรวจสอบ

นี่คือที่ที่ความเข้มงวดอาศัยอยู่

รับผลการทดสอบย้อนหลัง รัน Newey-West adjusted t-statistics เพื่อแก้ไขความสัมพันธ์อัตโนมัติในอนุกรมผลตอบแทน รัน bootstrap resampling ด้วย 10,000 รอบเพื่อตรวจสอบว่า Sharpe จริงหรือเป็น artifact ของตัวอย่าง

แจ้งเตือนสัญญาณใดๆ ที่ไม่ผ่านเกณฑ์นัยสำคัญ ฆ่าอะไรก็ตามที่มีการเสื่อมสภาพระหว่าง in-sample กับ out-of-sample มากกว่า 30 เปอร์เซ็นต์ เพราะนั่นคือ overfitting

รันบนโมเดลการใช้เหตุผลที่แข็งแกร่งกว่า ผู้สร้างไม่ควรตรวจสอบงานของตัวเอง เด็ดขาด

Agent 5: ผู้ตรวจสอบสภาวะตลาด

รับสัญญาณที่ผ่านการตรวจสอบ แบ่งประวัติศาสตร์ 20 ปีตามสภาวะตลาด (ระบุผ่าน Hidden Markov Model กับความผันผวนและผลตอบแทน)

คำนวณ Sharpe, drawdown และ hit rate ใหม่ภายในแต่ละสภาวะตลาด ฆ่าอะไรก็ตามที่ใช้ได้แค่ในสภาวะตลาดเดียว เพราะนั่นคือการจับจังหวะสภาวะตลาดที่ปลอมตัวเป็นอัลฟา

Agent 6: ตัวแยกองค์ประกอบปัจจัย

รับสัญญาณที่ทนทานต่อสภาวะตลาด ถดถอยเทียบกับ Fama-French five factor model บวก Carhart momentum บวก low-vol factor

รายงาน residual alpha (ค่าตัดแกนของการถดถอย) และ t-statistic

เฉพาะสัญญาณที่ residual alpha อยู่รอดจากการแยกองค์ประกอบปัจจัยเท่านั้นที่เป็นอัลฟาใหม่จริงๆ ที่เหลือคือโมเมนตัมที่ถูกบรรจุใหม่หรือ value ที่ถูกบรรจุใหม่พร้อมขั้นตอนเพิ่มเติม

หก agent แต่ละตัวเป็นเจ้าของหนึ่งขั้นตอน พวกมันส่งผลลัพธ์ลงไปตามสายโซ่

หนึ่ง Slate Program หก agent เฉพาะทาง รันทุก 24 ชั่วโมง

ฝูงทั้งหมดรันบน Slate Program ที่ทำงานทุก 24 ชั่วโมง

ส่วนที่ 4: วิธีสร้างทีละขั้นตอน

นี่คือการสร้างที่แน่นอน ทำตามแล้วคุณจะมีฝูงทำงานภายในสิ้นวัน

ขั้นตอนที่ 1: ติดตั้ง Slate

เปิด terminal ของคุณแล้วรัน:

1npm install -g @randomlabs/slate

Slate ติดตั้งเป็น CLI ทั่วโลกในเวลาไม่ถึง 30 วินาที

จากนั้นสร้างไดเรกทอรีโปรเจกต์:

1mkdir alpha-swarm
2cd alpha-swarm
3slate init

slate init สร้างโครงสร้างโปรเจกต์ด้วยโฟลเดอร์ที่คุณต้องการสำหรับสถานะ Programs และ providers

ขั้นตอนที่ 2: เชื่อมต่อโมเดลของคุณ

รัน:

1slate /providers

นี่จะเปิดหน้าจอการกำหนดค่า provider ภายใน Slate CLI เชื่อมต่อโมเดลที่คุณต้องการใช้

สำหรับฝูงนี้ ผมใช้ Sonnet สำหรับ agent ที่เร็ว (การสร้างไอเดีย, วิศวกรรมฟีเจอร์, การทดสอบย้อนหลัง, การตรวจสอบสภาวะตลาด) และ Opus สำหรับ agent ที่เน้นการใช้เหตุผลหนัก (การตรวจสอบและการแยกองค์ประกอบปัจจัย)

ขั้นตอนที่ 3: ร่าง Program

เริ่ม Slate:

1slate

จากนั้นใน Slate CLI พิมพ์:

ร่าง program ที่รัน agent วิจัยหกตัวตามลำดับ: ตัวสร้างไอเดีย, วิศวกรฟีเจอร์, ผู้ทดสอบย้อนหลัง, ผู้ตรวจสอบ, ผู้ตรวจสอบสภาวะตลาด, ตัวแยกองค์ประกอบปัจจัย รันทุก 24 ชั่วโมง ใช้ sonnet สำหรับ agent ที่เร็ว และ opus สำหรับการตรวจสอบและการแยกองค์ประกอบปัจจัย

Slate ร่าง Program ไปพร้อมกับคุณ มันถามคำถามเพื่อความกระจ่าง แหล่งข้อมูลอะไร หน้าต่างการทดสอบย้อนหลังเท่าไหร่ เกณฑ์ Sharpe เท่าไหร่ ตัวจำแนกสภาวะตลาดแบบไหน คุณตอบด้วยภาษาธรรมชาติ Slate เขียน JavaScript

นี่คือลักษณะของลูปเมื่อเขียนเสร็จ:

1export default async function alphaSwarm(slate) {
2  while (true) {
3    // Stage 1: read papers, extract hypotheses
4    const hypotheses = await slate.agent('idea-generator', {
5      model: 'sonnet',
6      task: 'Read arXiv q-fin and SSRN from the last 24 hours. Extract 10 alpha hypotheses with claimed direction, required data, and paper reference.',
7      state: slate.state.get('tested-hypotheses')
8    });
9
10    // Stage 2: feature engineering, in parallel per hypothesis
11    const features = await Promise.all(
12      hypotheses.map(h => slate.agent('feature-engineer', {
13        model: 'sonnet',
14        task: `Build the feature vector for: ${h.claim}. Standardize cross-section. Handle look-ahead.`,
15        data: slate.tools.priceData()
16      }))
17    );
18
19    // Stage 3: 20-year backtest with realistic costs
20    const backtests = await Promise.all(
21      features.map(f => slate.agent('backtester', {
22        model: 'sonnet',
23        task: 'Run 20-year backtest. Include transaction costs of 5bps per trade and shorting costs.',
24        features: f
25      }))
26    );
27
28    // Stage 4: statistical validation on the reasoning model
29    const validated = await Promise.all(
30      backtests.map(b => slate.agent('validator', {
31        model: 'opus',
32        task: 'Newey-West t-stat above 2.5. Bootstrap 10k. Reject if IS/OOS Sharpe degrades more than 30 percent.',
33        backtest: b
34      }))
35    );
36
37    // Stage 5: regime segmentation via HMM
38    const regimeChecked = await Promise.all(
39      validated
40        .filter(v => v.passed)
41        .map(v => slate.agent('regime-auditor', {
42          model: 'sonnet',
43          task: 'Fit 3-state HMM on volatility and returns. Recompute Sharpe per regime. Reject if only one regime works.',
44          result: v
45        }))
46    );
47
48    // Stage 6: factor decomposition to isolate residual alpha
49    const finalSignals = await Promise.all(
50      regimeChecked
51        .filter(r => r.passed)
52        .map(r => slate.agent('factor-decomposer', {
53          model: 'opus',
54          task: 'Regress against Fama-French 5 + Carhart momentum + low-vol. Report residual alpha and t-stat.',
55          result: r
56        }))
57    );
58
59    // Persist, notify, sleep
60    await slate.state.set('final-signals', finalSignals);
61    await slate.state.append('tested-hypotheses', hypotheses);
62    await slate.notify.slack('research', `${finalSignals.length} new signals survived all six stages today.`);
63    await slate.sleep('24h');
64  }
65}

นั่นคือฝูงทั้งหมด ไฟล์เดียว หก agent รันตลอดไป

ขั้นตอนที่ 4: รันฝูง

บันทึกไฟล์แล้วรัน:

1slate run alpha-swarm.js

ทันทีที่คุณกด Enter Slate จะเริ่มลูป หก agent ทำงานตามลำดับ

วิศวกรรมฟีเจอร์ทำงานแบบขนานในทุกสมมติฐาน การทดสอบย้อนหลังทำงานแบบขนาน การตรวจสอบทำงานบนโมเดลที่แข็งแกร่งกว่า

คุณสามารถดู agent แต่ละตัวทำงานจาก Slate CLI แบบเรียลไทม์ แต่ละ agent แสดงสถานะ งานปัจจุบัน และความคืบหน้า

[ภาพหน้าจอ 4: Terminal แสดงฝูงที่กำลังทำงาน โดยมีหลาย agent ทำงานพร้อมกัน ตัวบ่งชี้ความคืบหน้า visible สำหรับแต่ละขั้นตอน]

รอบแรกใช้เวลา 20 ถึง 40 นาที ขึ้นอยู่กับว่าขั้นตอนที่หนึ่งสร้างสมมติฐานได้กี่ข้อ

ในตอนท้าย Slate โพสต์ผู้รอดชีวิตไปยังช่อง Slack ของคุณ พร้อม Sharpe ratios, drawdowns และ residual alpha จากนั้นก็หลับจนถึงพรุ่งนี้

ขั้นตอนที่ 5: ปรับปรุง

ลูปเวอร์ชันแรกไม่ใช่เวอร์ชันสุดท้าย

ตัวสร้างไอเดียจะสร้างซ้ำ พิมพ์ลงใน Slate:

เพิ่มการตรวจสอบเทียบกับประวัติสถานะ เพื่อให้มันเสนอเฉพาะสมมติฐานที่เรายังไม่ได้ทดสอบใน 30 วันที่ผ่านมา

ผู้ตรวจสอบจะปฏิเสธสัญญาณที่คุณคิดว่าควรผ่าน พิมพ์:

ลดเกณฑ์ Sharpe เหลือ 1.2 แต่เพิ่มเกณฑ์ max drawdown เป็น 8 เปอร์เซ็นต์

Slate อัปเดต Program ให้คุณ รอบถัดไปใช้ตรรกะใหม่ ทุกการปรับปรุงสะสมในไฟล์สถานะ และเมื่อเวลาผ่านไป ฝูงจะเฉียบคมขึ้นเพราะมันจำทุกอย่างที่เคยทดสอบแล้วและทุกอย่างที่เคยปฏิเสธแล้ว

ส่วนที่ 5: สิ่งนี้มาแทนที่ทีมวิจัยได้อย่างไร

สามรูปแบบครอบคลุมทุกการใช้งานจริง

รูปแบบที่ 1: การค้นพบข้ามคืน

ฝูงทำงานตั้งแต่ 20.00 น. ถึง 08.00 น. ทุกเช้าคุณตื่นมาพบสัญญาณสองถึงสามตัวที่รอดชีวิตจากทั้งหกขั้นตอน

งานของคุณกลายเป็นการตรวจสอบผู้รอดชีวิต แทนที่จะรันไปป์ไลน์ด้วยตัวเอง

รูปแบบที่ 2: โหมดระเบิดสมมติฐาน

งานวิจัยใหม่ตีพิมพ์ แหล่งข้อมูลใหม่พร้อมใช้งาน คุณเรียกใช้ฝูงตามความต้องการและได้ 100 สมมติฐานที่ทดสอบแล้วในบ่ายวันนั้น

นักวิจัยมนุษย์ทดสอบได้สองสมมติฐานในเวลาเดียวกัน

รูปแบบที่ 3: การตรวจสอบการเสื่อมของอัลฟา

ฝูงรันสัญญาณที่ผ่านการตรวจสอบซ้ำทุกสัปดาห์กับข้อมูลใหม่ ทันทีที่ Sharpe ratio ของสัญญาณลดลงต่ำกว่าเกณฑ์ มันจะแจ้งเตือนการเสื่อม

คุณลดความเสี่ยงก่อนที่ drawdown จะสะสม

แต่ละรูปแบบแทนที่ฟังก์ชันเฉพาะที่เคยต้องใช้ PhD เมื่อรวมกันแล้ว พวกมันแทนที่สิ่งที่ทีมวิจัยทำในแต่ละวันเป็นส่วนใหญ่

ส่วนที่ 6: รูปแบบความล้มเหลวห้าแบบที่ฆ่าความพยายามของนักเทรดรายย่อย 90 เปอร์เซ็นต์

ความล้มเหลวที่ 1: ข้ามผู้ตรวจสอบ

คุณจะได้ 100 สัญญาณที่มี Sharpe ratio สวยงามและไม่มีความเข้มงวด ทุกอันคือ data snooping ใน disguise

ผู้ตรวจสอบไม่สามารถต่อรองได้ ใช้โมเดลที่แข็งแกร่งที่สุดของคุณ ตั้งเกณฑ์การปฏิเสธที่เข้มงวด อย่าปล่อยให้ผู้สร้างตรวจสอบงานของตัวเองเด็ดขาด

ความล้มเหลวที่ 2: ไม่มีการคงอยู่ของสถานะ

ฝูงที่ไม่มีความทรงจำจะทดสอบสมมติฐานที่ล้มเหลวซ้ำแล้วซ้ำเล่าทุกวัน

ทุกสัญญาณที่ถูกปฏิเสธต้องถูกบันทึกพร้อมเหตุผลการปฏิเสธที่แน่นอน เพื่อไม่ให้ agent ใดเสีย token ไปกับความล้มเหลวเดียวกันสองครั้ง

ความล้มเหลวที่ 3: ไม่มีการแยกผู้สร้างและผู้ตรวจสอบ

agent ที่สร้างสมมติฐานคือผู้ตัดสินที่แย่ที่สุดว่ามันเป็นอัลฟาจริงหรือไม่

แยกผู้สร้างและผู้ตรวจสอบข้าม agent ที่แตกต่างกันบนโมเดลที่แตกต่างกัน Renaissance ทำแบบนี้ Two Sigma ทำแบบนี้ Citadel ทำแบบนี้ ฝูงของคุณก็ควรทำเช่นกัน

ความล้มเหลวที่ 4: agent ตัวเดียวทำทุกอย่าง

ทันทีที่คุณพยายามให้ agent ตัวเดียวสร้าง ออกแบบ ทดสอบ และตรวจสอบ คุณภาพจะพังทลาย

ความเชี่ยวชาญเฉพาะด้านคือสิ่งที่ทำให้ฝูงทำงาน แต่ละ agent ทำสิ่งหนึ่งได้อย่างสมบูรณ์แบบ

ความล้มเหลวที่ 5: ไม่มีเงื่อนไขการหยุดบนลูป

ลูปที่ไม่มีการหยุดจริงจะล้มเหลวอย่างเงียบๆ agent ส่งสัญญาณเสร็จสิ้นโดยเชื่อว่างานเสร็จแล้ว ผลลัพธ์ที่ไม่ดีจะไม่ได้รับการแก้ไข

ทุกเงื่อนไขการหยุดต้องตรวจสอบได้โดยสิ่งอื่นที่ไม่ใช่การอ้างของ agent เอง "Sharpe สูงกว่า 1.5 จากการเทรด out-of-sample 30 ครั้งล่าสุด" "Drawdown ต่ำกว่า 5 เปอร์เซ็นต์" ห้าม "agent บอกว่ามันเสร็จแล้ว"

เคารพห้าข้อนี้ แล้วฝูงจะสร้างผลงานวิจัยระดับสถาบัน

สรุป

การวิจัยอัลฟาเป็นไปป์ไลน์อยู่แล้ว หกขั้นตอน อ่านงานวิจัย สร้างฟีเจอร์ ทดสอบย้อนหลัง ตรวจสอบ ตรวจสอบสภาวะตลาด แยกองค์ประกอบเทียบกับปัจจัย

ทุกกองทุนจริงจังรันมันด้วย PhD 100 คน

ฝูงของ AI agent เฉพาะทางหกตัวรันทุกขั้นตอนให้คุณ แต่ละ agent เลือกโมเดลที่เหมาะกับความซับซ้อนของมัน ฝูงทั้งหมดรันบน Slate Program ที่ทำงานทุก 24 ชั่วโมง

Programs โดย Slate คือเลเยอร์ที่ทำให้สิ่งนี้สามารถจัดส่งได้จริงในสุดสัปดาห์เดียวแทนที่จะเป็นหกเดือน

มันร่างลูปไปพร้อมกับคุณ มันบันทึกลูป มันรันลูป มันรันมันตลอดไป

คุณหยุดเป็นไปป์ไลน์ คุณกลายเป็นสถาปนิก

คูเมืองด้านโครงสร้างพื้นฐานมีจริง คูเมืองด้านการวิจัยตายแล้ว

นั่นคือประเด็น

ถ้าคุณอยากลอง ลงทะเบียนได้ที่

https://randomlabs.ai และติดตาม

@wearerandomlabs สำหรับการเปิดตัว

ในบทความก่อนหน้าของผมเกี่ยวกับวิศวกรรมลูป ผมได้อธิบายว่าสถาปัตยกรรมเดียวกันเชื่อมต่อกับระบบเทรดที่พัฒนาตัวเองได้เต็มรูปแบบซึ่งเทรดได้ด้วยตัวเองอย่างไร ถ้าคุณยังไม่ได้อ่าน ให้อ่านต่อจากนี้

ฝูงนี้คือครึ่งหนึ่งของการวิจัยของระบบนั้น

https://x.com/RohOnChain/status/2069056530960490835

กองทุนที่สร้างสิ่งนี้ก่อนจะทบต้นไปอีกทศวรรษ

กองทุนที่ยังคงทดสอบทีละสมมติฐานจะถูกทิ้งไว้ข้างหลัง

ดังนั้นนี่คือคำถามให้คุณคิด

คุณคือนักวิจัยที่ยังคงทดสอบสมมติฐานสัปดาห์ละอัน หรือคุณคือสถาปนิกที่สร้างฝูงที่ทดสอบร้อยอันทุกคืนขณะที่คุณหลับ?

ไม่มีคำตอบที่ผิด แต่มีคำตอบที่เปิดเผยตัวตนมาก