בפוסט, המשטרה "תפסה" דסק של בוטים. כאן בונים אותו באמת: 7 סוכני AI עם תפקיד אחד לכל אחד, בוט סיכון שיכול להגיד "לא" לבוס, וקוד Python שרץ אצלכם. הכל על חשבון דמו, בלי שקל אמיתי אחד.
SPY739.95 ▼1.91%AAPL352.78 ▼0.98%AMZN257.75 ▼3.34%GOOGL283.72 ▼4.07%DESK: PAPER ONLYRISKARMEDDATA: yfinance · 2026-11-16 closeSPY739.95 ▼1.91%AAPL352.78 ▼0.98%AMZN257.75 ▼3.34%GOOGL283.72 ▼4.07%DESK: PAPER ONLYRISKARMEDDATA: yfinance · 2026-11-16 close
[ HALT ]זה מדריך לימודי. זה לא ייעוץ השקעות, לא המלצה לקנות או למכור, ולא מערכת שמרוויחה כסף. רוב הסוחרים הקמעונאיים מפסידים. הקוד כאן שולח פקודות רק לספר דמו מקומי. לפני כל דבר אחר, קראו את פרק הסיכונים.
בלי הייפ
מה יש כאן באמת
"המשטרה תפסה 7 בוטים" זה הוק. לא מצאנו שום דיווח על מקרה כזה, והוא לא העיקר. העיקר הוא הרעיון שמאחוריו: במקום לבקש ממודל אחד "תגיד לי מה לקנות", מחלקים את העבודה ל-7 תפקידים צרים. כל בוט מקבל משימה אחת, מחזיר JSON קצר, ובוט סיכון בודק את הכל בסוף ויכול לעצור.
7תפקידים, כל אחד פרומפט נפרד
1בוט עם זכות וטו (סיכון)
$0עם מודל מקומי ב-Ollama
~$0.01לריצה עם grok-4.3 (הערכה, ראו מחשבון)
למה לפצל לתפקידים?
פרומפט אחד שמנסה לקרוא גרף, חדשות ונפח מסחר ביחד, מערבב הכל. תפקיד צר נותן תשובה צרה שאפשר לבדוק. ככה בנויים גם פריימוורקים מחקריים כמו TradingAgents (אנליסטים, חוקרים "שוריים" ו"דוביים", סוחר, וצוות סיכון שמאשר או דוחה).
מה הפוסט לא אומר
"קרן משלמת לאנליסטים חצי מיליון בשנה על אותם כיסאות" ו"$500K" הם לפי הפוסט, לא נתון שבדקנו. 7 בוטים לא מחליפים אנליסטים. הם כן כלי מצוין ללמוד איך בונים מערכת סוכנים, עם בלמים.
#
הכיסא בפוסט
מה הוא עושה אצלנו
על איזה מידע הוא עובד
WATCHER
אחד צופה
מתאר מגמה ומומנטום, בלי תחזיות
מחירים מ-yfinance: שינוי 1/5/20 יום, RSI, ממוצע 50
HUNTER
אחד צד
בודק אם יש "סטאפ" לפי 2 חוקים כתובים מראש
שיא 20 יום, יחס נפח, RSI
NEWS
אחד קורא חדשות
נותן ציון טון מ-1- עד 1 לכותרות
עד 8 כותרות אחרונות מ-yfinance
FLOW
אחד עוקב אחרי הכסף הגדול
בודק אם הנפח "מאשר" את התנועה
רק נפח מול ממוצע. אין לו גישה לפקודות של מוסדיים, וזה כתוב לו בפרומפט
CROWD
300 סוכנים עושים את הקריאה
N מצביעים קטנים עם "אישיות" שונה, רוב קובע
הסיכומים של כל השאר. ברירת מחדל 5, אפשר יותר (כל אחד = קריאת API)
BOSS
בוט הבוס רוצה "כן"
כותב הצעה אחת: BUY / SELL / HOLD + ביטחון
כל הפתקים מהדסק
RISK
אחד רק אומר לא
חוקים קשיחים בקוד + פרומפט ספקן. יש לו וטו
ההצעה של הבוס, הספר, תנודתיות, הסכמת הקהל
על "300 סוכנים": Moonshot מציינת בדפי העזרה של Kimi שה-Agent Swarm שלה יכול להפעיל עד 300 תת-סוכנים. זה נתון של היצרן. אצלנו "הקהל" הוא פשוט לולאה של קריאות קטנות, ואתם קובעים כמה.
LIVE DEMO
הדסק בפעולה
לחצו על תרחיש וצפו איך האות עובר מכיסא לכיסא. התרחיש הראשון הוא ריצה אמיתית של הקוד מהמדריך על AMZN (16.11.2026, מודל Qwen3.5 4B מקומי). השניים האחרים הם סימולציות שמראות מה קורה כשהבוס רוצה "כן".
01WATCHERצופה בגרף
02HUNTERמחפש סטאפ
03NEWSקורא כותרות
04FLOWעוקב אחרי נפח
05CROWD ×Nהקהל מצביע
06BOSSכותב הצעה
07RISKוטו
→PAPER LEDGERספר דמו מקומי, כסף מזויף
desk_trace.jsonAMZN · 2026-11-16
ממתין…
לפני שמתחילים
מה צריך על השולחן
Python 3.11+
חינם
מ-python.org. בדקנו את הקוד על Python 3.14 עם openai 2.x ו-yfinance 1.8.
מוח: אחד מהשניים
בחירה
Grok API של xAI (בתשלום לפי טוקנים) או Ollama עם מודל מקומי (חינם, צריך מחשב סביר). אותו קוד עובד עם שניהם.
נתוני שוק
חינם
yfinance מושך מחירים וכותרות מ-Yahoo Finance בלי מפתח. זו ספרייה לא רשמית, למחקר ולימוד. לפעמים היא נשברת כש-Yahoo משנה משהו.
Alpaca Paper
אופציונלי
חשבון דמו חינמי עם $100K מזויפים. לפי Alpaca, כל אחד בעולם יכול לפתוח Paper Only Account עם אימייל. לא חובה: הקוד שלנו כולל ספר דמו מקומי.
מפת העבודה
צעד אחר צעד
8 שלבים. 1 עד 6 הם הבנייה, 7 ו-8 הם מה שמפריד בין צעצוע לכלי לימוד רציני.
01
שלב 1 מתוך 8 · 5 דק'
תיקייה, סביבה וספריות
פותחים טרמינל (ב-Windows: PowerShell) ויוצרים תיקייה נקייה לדסק. סביבה וירטואלית שומרת שהספריות לא יתערבבו עם שאר המחשב.
עכשיו הורידו את desk.py לתוך התיקייה (או העתיקו אותו מהקוד המלא בשלב 3).
מה יוצא מהשלב?תיקייה grok-desk עם סביבה פעילה, openai ו-yfinance מותקנים, ו-desk.py בפנים.
github.com/ranaroussi/yfinance
yfinance ב-GitHub (צילום אמיתי, 16.11.2026). רישיון Apache-2.0, גרסה 1.8.0.
02
שלב 2 מתוך 8 · 10 דק'
בוחרים מוח: Grok או מודל מקומי
מסלול א: Grok API. נכנסים ל-console.x.ai (ההתחברות שלכם, לא שלנו), יוצרים API key וטוענים קרדיט. לפי דף המודלים הרשמי, grok-4.3 עולה $1.25 למיליון טוקנים נכנסים ו-$2.50 ליוצאים, ו-grok-4.7 הדגל עולה $2 / $6. באתר כתוב ש-Playground כלול בכל חשבון, אבל לא מצאנו בדוקומנטציה הרשמית שכבת API חינמית. החיוב יורד מקרדיטים שנטענו מראש (Auto top-up מינימום $5).
מפתח API הוא כמו כרטיס אשראי. לא מדביקים אותו בקוד, לא מעלים ל-GitHub ולא שולחים בצ'אט. משתנה סביבה או קובץ .env שנמצא ב-.gitignore.
מה יוצא מהשלב?משתני סביבה שמצביעים על מודל: Grok בענן או Qwen על המחשב שלכם.
docs.x.ai/docs/models
דף המודלים הרשמי של xAI (צילום אמיתי). מחירי כל המודלים בטבלה שבהמשך הדף.
x.ai/api
דף ה-API: "Playground included with every account", תמחור לפי שימוש.
03
שלב 3 מתוך 8 · 3 דק'
ריצת ניסיון בלי AI בכלל
לפני שמשלמים על טוקן אחד, בודקים שהצנרת עובדת. הדגל --offline מחליף את המודל בחוקים פשוטים, אבל נתוני השוק אמיתיים.
טרמינל
python desk.py NVDA --offline
output · real run · 2026-11-16
=== NVDA 2026-11-16 close 156.14 (PAPER / EDUCATION ONLY) ===[WATCHER] {"trend": "down", "momentum": "strong", "note": "offline"}
[HUNTER ] {"setup": "none", "side": "flat", "why": "no rule matched"}
[NEWS ] {"sentiment": 0.0, "key_points": ["offline mode: headlines not scored"]}
[FLOW ] {"confirms": true, "note": "volume ratio rule"}
[CROWD ] {"votes": ["flat", "flat", "flat", "flat", "flat"]}
[BOSS ] {"action": "HOLD", "confidence": 0.3, "thesis": "offline rule"}
[RISK ] {"veto": null, "note": "no proposal to check, boss said HOLD"}
>>> NO TRADE. Boss said HOLD.
‹/› הקוד המלא של desk.py (כ-230 שורות, להעתקה)
desk.py · paper trading only
"""
desk.py - a 7-seat AI research desk. PAPER TRADING / EDUCATION ONLY.
This script NEVER sends real orders. It has no broker login, no withdrawal
access and no live-trading code path. "Trades" are written to a local JSON
ledger (paper_ledger.json) with fake money. Not investment advice.
Seats (each seat = one role prompt):
1 WATCHER reads the chart numbers 2 HUNTER looks for a setup
3 NEWS reads the headlines 4 FLOW follows volume ("big money" proxy)
5 CROWD N small voters, majority wins 6 BOSS writes the trade proposal
7 RISK hard rules in code + a skeptic prompt. RISK HAS THE FINAL VETO.
Run:
pip install openai yfinance
python desk.py NVDA --offline # no API key, rule-based stand-ins (test the plumbing)
python desk.py NVDA # with an LLM (see env vars below)
LLM settings (any OpenAI-compatible endpoint that supports the Responses API):
xAI Grok : LLM_BASE_URL=https://api.x.ai/v1 LLM_API_KEY=<your xai key> LLM_MODEL=grok-4.3
Ollama : LLM_BASE_URL=http://localhost:11434/v1 LLM_API_KEY=ollama LLM_MODEL=qwen3.5:4b LLM_REASONING=none
"""
import argparse, json, math, os, re, sys, time
from datetime import datetime, timezone
from pathlib import Path
LEDGER = Path("paper_ledger.json")
TRACE = Path("desk_trace.json")
STOP_FILE = Path("STOP") # create a file named STOP to freeze the desk
# ---------- hard risk limits (code, not vibes) ----------
LIMITS = {
"max_position_pct": 0.05, # never more than 5% of paper equity in one name
"max_open_positions": 3,
"max_annual_vol": 0.60, # skip names that move more than 60%/yr (20d realised)
"min_confidence": 0.60, # boss must be at least this sure
"min_crowd_agreement": 0.60, # at least 60% of the crowd must agree with the side
"max_daily_loss_pct": 0.02, # stop for the day after -2% on the paper account
}
ROLES = {
"watcher": "You are WATCHER on a research desk. You get price statistics for one stock. "
"Describe the trend and momentum in 2 sentences. No predictions, no advice. "
'Reply JSON only: {"trend":"up|down|sideways","momentum":"strong|weak|neutral","note":"..."}',
"hunter": "You are HUNTER. Using ONLY these rules: breakout = close within 2% of 20d high AND volume ratio > 1.3; "
"pullback = uptrend AND RSI between 35 and 50; otherwise none. "
'Reply JSON only: {"setup":"breakout|pullback|none","side":"long|short|flat","why":"..."}',
"news": "You are NEWS. Read the headlines and rate the tone for this stock from -1 (very negative) to 1 (very positive). "
"Ignore hype words. If headlines are unrelated, say 0. "
'Reply JSON only: {"sentiment":0.0,"key_points":["...","..."]}',
"flow": "You are FLOW. You do NOT see real institutional orders; you only see volume vs its 20-day average and the price move. "
"Say whether volume confirms the move. "
'Reply JSON only: {"confirms":true,"note":"..."}',
"crowd": "You are one of many small voters on a desk. Persona: {persona}. Given the desk notes, vote. "
'Reply JSON only: {"vote":"long|short|flat"}',
"boss": "You are BOSS (portfolio manager). Combine the desk notes into ONE proposal. You may say HOLD. "
"Confidence must be honest (0..1). "
'Reply JSON only: {"action":"BUY|SELL|HOLD","confidence":0.0,"thesis":"one sentence"}',
"risk": "You are RISK. Your job is to find reasons NOT to trade. Be skeptical of the boss. "
'Reply JSON only: {"veto":true,"reason":"one sentence"}',
}
PERSONAS = ["trend follower", "mean-reversion skeptic", "news-driven trader", "value-minded analyst", "volatility-averse saver"]
# ---------- data ----------
def get_market(ticker):
import yfinance as yf
t = yf.Ticker(ticker)
h = t.history(period="6mo")
if h.empty:
sys.exit(f"no data for {ticker}")
c, v = h["Close"], h["Volume"]
rets = c.pct_change().dropna()
delta = c.diff()
gain = delta.clip(lower=0).rolling(14).mean(); loss = (-delta.clip(upper=0)).rolling(14).mean()
rsi = 100 - 100 / (1 + gain.iloc[-1] / max(loss.iloc[-1], 1e-9))
f = {
"ticker": ticker, "date": str(h.index[-1].date()), "close": round(float(c.iloc[-1]), 2),
"chg_1d_pct": round(float(c.pct_change(1).iloc[-1] * 100), 2),
"chg_5d_pct": round(float(c.pct_change(5).iloc[-1] * 100), 2),
"chg_20d_pct": round(float(c.pct_change(20).iloc[-1] * 100), 2),
"rsi14": round(float(rsi), 1),
"high_20d": round(float(c.tail(20).max()), 2),
"sma50": round(float(c.tail(50).mean()), 2),
"vol_ratio": round(float(v.iloc[-1] / v.tail(20).mean()), 2),
"annual_vol": round(float(rets.tail(20).std() * math.sqrt(252)), 3),
}
news = []
for n in (t.news or [])[:8]:
c_ = n.get("content", n)
news.append(c_.get("title", ""))
return f, [x for x in news if x]
# ---------- LLM ----------
def make_llm(offline):
if offline:
return None
from openai import OpenAI
key = os.getenv("LLM_API_KEY") or os.getenv("XAI_API_KEY")
if not key:
sys.exit("Set LLM_API_KEY (or XAI_API_KEY), or run with --offline")
return OpenAI(api_key=key, base_url=os.getenv("LLM_BASE_URL", "https://api.x.ai/v1"))
def ask(llm, role, payload, persona=None):
system = ROLES[role].replace("{persona}", persona or "")
if llm is None:
return offline_answer(role, payload, persona)
kw = {}
if os.getenv("LLM_REASONING"):
kw["reasoning"] = {"effort": os.getenv("LLM_REASONING")}
text = json.dumps(payload, ensure_ascii=False)
for attempt in range(2): # models sometimes break JSON: ask once more
r = llm.responses.create(model=os.getenv("LLM_MODEL", "grok-4.3"), instructions=system, input=text, **kw)
m = re.search(r"\{.*\}", r.output_text, re.S)
try:
return json.loads(m.group(0))
except (AttributeError, json.JSONDecodeError):
text = text + "\n\nYour last reply was not valid JSON. Reply with valid JSON only."
return {"error": "invalid JSON from model", "raw": r.output_text[:300]}
def offline_answer(role, p, persona):
"""Rule-based stand-ins so the pipeline runs with no key. Not smart, on purpose."""
f = p.get("market", {})
up = f.get("close", 0) > f.get("sma50", 0)
if role == "watcher":
return {"trend": "up" if up else "down", "momentum": "strong" if abs(f.get("chg_20d_pct", 0)) > 8 else "neutral", "note": "offline"}
if role == "hunter":
if f.get("close", 0) >= f.get("high_20d", 1) * 0.98 and f.get("vol_ratio", 0) > 1.3:
return {"setup": "breakout", "side": "long", "why": "near 20d high on volume"}
if up and 35 <= f.get("rsi14", 50) <= 50:
return {"setup": "pullback", "side": "long", "why": "uptrend dip"}
return {"setup": "none", "side": "flat", "why": "no rule matched"}
if role == "news":
return {"sentiment": 0.0, "key_points": ["offline mode: headlines not scored"]}
if role == "flow":
return {"confirms": f.get("vol_ratio", 0) > 1.2, "note": "volume ratio rule"}
if role == "crowd":
side = p["notes"]["hunter"].get("side", "flat")
return {"vote": side if persona != "volatility-averse saver" else "flat"}
if role == "boss":
side = p["notes"]["hunter"].get("side", "flat")
act = {"long": "BUY", "short": "SELL"}.get(side, "HOLD")
return {"action": act, "confidence": 0.65 if act != "HOLD" else 0.3, "thesis": "offline rule"}
if role == "risk":
return {"veto": False, "reason": "offline: hard rules only"}
# ---------- paper ledger (fake money only) ----------
def load_ledger():
if LEDGER.exists():
return json.loads(LEDGER.read_text(encoding="utf-8"))
return {"cash": 100_000.0, "positions": {}, "trades": [], "start_equity_today": 100_000.0}
def equity(led, prices):
return led["cash"] + sum(q * prices.get(t, 0) for t, q in led["positions"].items())
def hard_risk_checks(led, f, proposal, crowd_share):
fails = []
eq = equity(led, {f["ticker"]: f["close"]})
if STOP_FILE.exists(): fails.append("STOP file present (kill switch)")
if proposal.get("action") == "SELL" and f["ticker"] not in led["positions"]: fails.append("no short selling on this desk")
if float(proposal.get("confidence", 0)) < LIMITS["min_confidence"]: fails.append("confidence below limit")
if crowd_share < LIMITS["min_crowd_agreement"]: fails.append(f"crowd agreement {crowd_share:.0%} below limit")
if f["annual_vol"] > LIMITS["max_annual_vol"]: fails.append(f"volatility {f['annual_vol']:.0%} above limit")
if len(led["positions"]) >= LIMITS["max_open_positions"] and f["ticker"] not in led["positions"]: fails.append("too many open positions")
if eq < led["start_equity_today"] * (1 - LIMITS["max_daily_loss_pct"]): fails.append("daily loss limit hit")
return fails
def paper_fill(led, f, action):
px = f["close"]; t = f["ticker"]
if action == "BUY":
qty = math.floor(equity(led, {t: px}) * LIMITS["max_position_pct"] / px)
led["cash"] -= qty * px; led["positions"][t] = led["positions"].get(t, 0) + qty
else:
qty = led["positions"].pop(t, 0); led["cash"] += qty * px
led["trades"].append({"time": datetime.now(timezone.utc).isoformat(timespec="seconds"), "ticker": t,
"action": action, "qty": qty, "price": px, "paper": True})
LEDGER.write_text(json.dumps(led, indent=2), encoding="utf-8")
return qty
# ---------- the desk ----------
def run(ticker, offline, crowd_n):
llm = make_llm(offline)
f, headlines = get_market(ticker)
trace = []
def log(seat, out):
trace.append({"seat": seat, "out": out}); print(f"[{seat.upper():7}] {json.dumps(out, ensure_ascii=False)}")
print(f"=== {ticker} {f['date']} close {f['close']} (PAPER / EDUCATION ONLY) ===")
notes = {}
notes["watcher"] = ask(llm, "watcher", {"market": f}); log("watcher", notes["watcher"])
notes["hunter"] = ask(llm, "hunter", {"market": f}); log("hunter", notes["hunter"])
notes["news"] = ask(llm, "news", {"ticker": ticker, "headlines": headlines}); log("news", notes["news"])
notes["flow"] = ask(llm, "flow", {"market": f}); log("flow", notes["flow"])
votes = [ask(llm, "crowd", {"market": f, "notes": notes}, PERSONAS[i % len(PERSONAS)]).get("vote", "flat")
for i in range(crowd_n)]
notes["crowd"] = {"votes": votes}; log("crowd", notes["crowd"])
proposal = ask(llm, "boss", {"market": f, "notes": notes}); log("boss", proposal)
side = {"BUY": "long", "SELL": "short"}.get(proposal.get("action"), "flat")
crowd_share = votes.count(side) / max(len(votes), 1)
led = load_ledger()
if proposal.get("action") not in ("BUY", "SELL"):
log("risk", {"veto": None, "note": "no proposal to check, boss said HOLD"})
print(">>> NO TRADE. Boss said HOLD.")
TRACE.write_text(json.dumps({"market": f, "headlines": headlines, "trace": trace, "veto": None}, indent=2, ensure_ascii=False), encoding="utf-8")
return
fails = hard_risk_checks(led, f, proposal, crowd_share)
skeptic = ask(llm, "risk", {"market": f, "notes": notes, "proposal": proposal, "hard_rule_fails": fails})
veto = bool(fails) or bool(skeptic.get("veto"))
log("risk", {"veto": veto, "hard_rule_fails": fails, "skeptic": skeptic})
if veto:
print(">>> RISK VETO. Nothing traded. (This is the desk working as designed.)")
else:
qty = paper_fill(led, f, proposal["action"])
print(f">>> PAPER {proposal['action']} {qty} {ticker} @ {f['close']} (fake money, ledger: {LEDGER})")
TRACE.write_text(json.dumps({"market": f, "headlines": headlines, "trace": trace, "veto": veto}, indent=2, ensure_ascii=False), encoding="utf-8")
if __name__ == "__main__":
ap = argparse.ArgumentParser(description="7-seat AI research desk (paper trading only)")
ap.add_argument("ticker"); ap.add_argument("--offline", action="store_true")
ap.add_argument("--crowd", type=int, default=5, help="number of crowd voters (each one is an API call)")
a = ap.parse_args()
run(a.ticker.upper(), a.offline, a.crowd)
מה יוצא מהשלב?7 שורות, אחת לכל כיסא, ושני קבצים חדשים: desk_trace.json (כל מה שכל בוט אמר) ו-paper_ledger.json כשיש עסקת דמו.
desk.py · the 7 seats
# flow: one signal, seven seats
market = get_market("NVDA") # yfinance, no keywatcher -> hunter -> news -> flow
-> crowd x N # majority vote
-> boss# BUY / SELL / HOLD
-> risk# hard rules + skeptic, VETO
-> paper_ledger.json# fake $100,000# there is no broker login, no live endpoint,
# no withdrawal code anywhere in this file.
המבנה של הקוד. המחשה של הזרימה, מבוסס על הקובץ עצמו.
04
שלב 4 מתוך 8 · 5 דק'
מריצים עם מודל אמיתי
עם משתני הסביבה משלב 2, מריצים בלי --offline. כל כיסא הוא קריאה נפרדת למודל עם פרומפט משלו. ברירת המחדל: 5 מצביעים בקהל, כלומר 11 קריאות לריצה.
טרמינל
python desk.py AMZN
python desk.py AMZN --crowd 15 # more voters = more API calls
ככה זה נראה אצלנו, ריצה אמיתית עם Qwen3.5 4B על לפטופ (קיצרנו שורות ארוכות לתצוגה):
python desk.py AMZN · qwen3.5:4b via Ollama
=== AMZN 2026-11-16 close 257.75 (PAPER / EDUCATION ONLY) ===[WATCHER] {"trend": "sideways", "momentum": "neutral", "note": "AMZN is trading near its 50-day moving average after a short-term decline..."}
[HUNTER ] {"setup": "pullback", "side": "long", "why": "Uptrend confirmed (close above SMA50) with RSI at 53.1 (...) though technically slightly above the defined upper bound..."}
[NEWS ] {"sentiment": -1.0, "key_points": ["Amazon falls on new AI chip export rules and satellite launch failure", ...]}
[FLOW ] {"confirms": false, "note": "The -3.34% daily drop with a volume ratio below the average (0.96) indicates declining participation..."}
[CROWD ] {"votes": ["long", "short", "short", "short", "flat"]}
[BOSS ] {"action": "HOLD", "confidence": 0.7, "thesis": "Negative news and weak volume dampen the bullish pullback thesis despite technical uptrend confirmation."}
[RISK ] {"veto": null, "note": "no proposal to check, boss said HOLD"}
>>> NO TRADE. Boss said HOLD.
השיעור הכי חשוב בריצה הזו: ל-HUNTER נאמר "pullback רק אם RSI בין 35 ל-50". ה-RSI היה 53.1, והוא כתב בעצמו שזה מעל הגבול, ובכל זאת קבע pullback. מודלי שפה מכופפים חוקים. לכן חוקים שחשובים לכם יושבים בקוד (שלב 6), לא רק בפרומפט.
מה יוצא מהשלב?דסק שחושב עם מודל אמיתי, ו-desk_trace.json עם כל ההחלטות. בשוק יורד כמו ב-16.11, "לא לעשות כלום" הוא תוצאה טובה.
מהפוסט: "אחד עוקב אחרי הכסף הגדול". אצלנו FLOW יודע שיש לו רק נפח מסחר, וזה כתוב לו בפרומפט, כדי שלא ימציא "כסף חכם".
05
שלב 5 מתוך 8 · 15 דק'
7 הפרומפטים: "הבילד" מהפוסט
אלה הפרומפטים שיושבים במילון ROLES בתוך desk.py. שלושה עקרונות: כל תפקיד צר, כל תשובה היא JSON קטן שאפשר לבדוק בקוד, וכל בוט יודע מה אין לו (FLOW לא רואה פקודות מוסדיים, NEWS מתבקש להתעלם ממילות הייפ).
ROLES · 7 role prompts
WATCHER: You are WATCHER on a research desk. You get price statistics for one stock. Describe the trend and momentum in 2 sentences. No predictions, no advice. Reply JSON only: {"trend":"up|down|sideways","momentum":"strong|weak|neutral","note":"..."}
HUNTER: You are HUNTER. Using ONLY these rules: breakout = close within 2% of 20d high AND volume ratio > 1.3; pullback = uptrend AND RSI between 35 and 50; otherwise none. Reply JSON only: {"setup":"breakout|pullback|none","side":"long|short|flat","why":"..."}
NEWS: You are NEWS. Read the headlines and rate the tone for this stock from -1 (very negative) to 1 (very positive). Ignore hype words. If headlines are unrelated, say 0. Reply JSON only: {"sentiment":0.0,"key_points":["...","..."]}
FLOW: You are FLOW. You do NOT see real institutional orders; you only see volume vs its 20-day average and the price move. Say whether volume confirms the move. Reply JSON only: {"confirms":true,"note":"..."}
CROWD: You are one of many small voters on a desk. Persona: {persona}. Given the desk notes, vote. Reply JSON only: {"vote":"long|short|flat"}
BOSS: You are BOSS (portfolio manager). Combine the desk notes into ONE proposal. You may say HOLD. Confidence must be honest (0..1). Reply JSON only: {"action":"BUY|SELL|HOLD","confidence":0.0,"thesis":"one sentence"}
RISK: You are RISK. Your job is to find reasons NOT to trade. Be skeptical of the boss. Reply JSON only: {"veto":true,"reason":"one sentence"}
רוצים לשנות אישיות של בוט? משנים רק את הטקסט שלו. רוצים להוסיף כיסא (נגיד MACRO שקורא ריבית)? מוסיפים מפתח ל-ROLES ושורה אחת בפונקציה run.
פרומפט לשדרוג הדסק עם עוזר קוד (Claude / ChatGPT / Grok)
Here is my desk.py, a paper-trading-only research desk with 7 role prompts.
Add an 8th seat called MACRO that reads the 10-year US Treasury yield
(ticker ^TNX via yfinance) and returns JSON {"regime":"risk_on|risk_off|neutral","note":"..."}.
Rules: do not add any real broker, live trading or withdrawal code.
Keep the RISK seat as the final veto. Show me only the changed parts.
מה הפרומפט עושה: מבקש מעוזר קוד להוסיף כיסא, ושומר במפורש על הבלמים.
מה יוצא מהשלב?7 תפקידים שאתם מבינים ושולטים בהם, ודרך להוסיף כיסאות בלי לשבור את הבטיחות.
github.com/TauricResearch/TradingAgents
רוצים גרסה גדולה יותר? TradingAgents (קוד פתוח, Apache-2.0) בנוי באותו היגיון, תומך ב-xAI, Ollama ועוד, ומצהיר שהוא "designed for research purposes" ו-"not intended as financial, investment, or trading advice".
06
שלב 6 מתוך 8 · 10 דק'
חוקי הסיכון בקוד, ומתג חירום
בוט הסיכון בנוי משתי שכבות. הראשונה היא חוקים קשיחים בפייתון שאי אפשר "לשכנע". השנייה היא פרומפט ספקן שמחפש סיבות לא לסחור. אם אחת מהן אומרת לא, אין עסקה. ככה זה נראה בקוד:
desk.py · LIMITS
LIMITS = {
"max_position_pct": 0.05, # max 5% of paper equity per name
"max_open_positions": 3,
"max_annual_vol": 0.60, # skip names moving >60%/yr
"min_confidence": 0.60, # boss must be at least this sure
"min_crowd_agreement": 0.60, # 60% of the crowd must agree
"max_daily_loss_pct": 0.02, # stop for the day after -2%
}
STOP_FILE = Path("STOP") # kill switch
מתג חירום: יוצרים בתיקייה קובץ ריק בשם STOP והדסק מסרב לכל עסקה. מוחקים אותו כדי לחזור.
אין שורט: SELL מותר רק על פוזיציה שכבר קיימת בספר הדמו.
הוטו תמיד אחרון: הבוס יכול לרצות "כן" כמה שהוא רוצה.
Windows · מתג חירום
New-Item STOP # freeze the desk
Remove-Item STOP # unfreeze
מה יוצא מהשלב?דסק שהבלמים שלו לא תלויים במצב הרוח של מודל שפה.
מהפוסט: "אחד רק אומר לא". הכיסא הכי חשוב בדסק.
07
שלב 7 מתוך 8 · אופציונלי
חשבון Alpaca Paper (דמו אמיתי של ברוקר)
הספר המקומי מספיק כדי ללמוד. אם רוצים סימולציה קרובה יותר לשוק, Alpaca נותנת חשבון Paper חינמי עם $100K מזויפים ו-API נפרד: https://paper-api.alpaca.markets. ההרשמה וההתחברות הן שלכם (אנחנו לא נרשמנו, ולא בדקנו את הקטע הבא עם מפתחות).
נרשמים ב-alpaca.markets עם אימייל ובוחרים Paper Only Account.
בדשבורד, בחשבון ה-Paper, יוצרים API keys. מפתחות Paper שונים ממפתחות Live.
pip install alpaca-py
Python · Alpaca paper only
import os
from alpaca.trading.client import TradingClient
from alpaca.trading.requests import MarketOrderRequest
from alpaca.trading.enums import OrderSide, TimeInForce
# paper=True sends everything to paper-api.alpaca.markets
client = TradingClient(os.environ["APCA_PAPER_KEY"], os.environ["APCA_PAPER_SECRET"], paper=True)
order = MarketOrderRequest(symbol="SPY", qty=1, side=OrderSide.BUY, time_in_force=TimeInForce.DAY)
print(client.submit_order(order_data=order))
לפי Alpaca עצמה, Paper לא מדמה השפעה על השוק, החלקה (slippage) מהשהיה, עמלות רגולטוריות ודיבידנדים. כלומר תוצאות דמו נראות טובות יותר מהמציאות. ואם יום אחד תעברו ל-Live: מפתח עם הרשאת מסחר בלבד, אף פעם לא הרשאת משיכה.
מה יוצא מהשלב?אותו דסק, עם ביצועים מדומים אצל ברוקר אמיתי במקום קובץ JSON.
docs.alpaca.markets/docs/paper-trading
הדוקומנטציה הרשמית: "Anyone globally can create an Alpaca Paper Only Account! All you need to do is sign up with your email address."
08
שלב 8 מתוך 8 · 30 יום
יומן 30 יום ומדידה מול "לא לעשות כלום"
דסק שלא מודדים הוא הימור עם גרפיקה יפה. מריצים פעם ביום אחרי הסגירה, על אותה רשימה קבועה של מניות, ושומרים כל desk_trace.json בשם עם תאריך.
מדד השוואה: כמה היה עושה SPY באותה תקופה? אם הדסק לא מנצח "לקנות ולשבת", הוא לא מוסיף ערך.
כמה פעמים הסיכון עצר, ומה קרה אחרי? זה מלמד אם החוקים טובים.
החליפו מודל (Grok מול Qwen מקומי) ובדקו אם ההחלטות משתנות. אם כן, זה סימן כמה הן רועשות.
מה יוצא מהשלב?יומן של חודש שאומר לכם בכנות אם יש פה משהו, או (הכי סביר) שזה כלי לימוד ולא מכונת כסף.
מהפוסט: "בוט הבוס רוצה 'כן'". היומן הוא מה שבודק אם ה"כן" שלו שווה משהו.
מחשבון
כמה עולה להריץ את הדסק?
כל כיסא הוא קריאת API. 300 סוכנים כמו בפוסט נשמע מרשים, אבל זה גם פי 50 קריאות. ההנחה כאן: כ-900 טוקנים נכנסים ו-200 יוצאים לקריאה, 21 ימי מסחר בחודש. מחירים מדף המודלים של xAI, 16.11.2026.
הערכה לחודש
$0.00
קריאות לריצה11
קריאות בחודש924
טוקנים בחודש0
זו הערכה גסה. כותרות ארוכות, נסיונות חוזרים כש-JSON נשבר, או מודל "חושב" יעלו יותר. בדקו את השימוש האמיתי בקונסול אחרי כמה ריצות.
RISK DISCLOSURE
הפרק שהפוסט לא שם
כתבנו את זה בלי ריכוך, כי זה החלק שבאמת שומר עליכם.
97%
מהסוחרים היומיים מפסידים
מחקר על כ-19,600 סוחרים יומיים בברזיל (2019) שהתמידו מעל 300 ימים מצא ש-97% הפסידו כסף. ב-CFD באירופה, לפי נתוני רגולטורים ש-ESMA ציטטה ב-2018, בין 74% ל-89% מהחשבונות הקמעונאיים מפסידים. בוטים לא מבטלים את הסטטיסטיקה הזו.
0
הרשאות משיכה לבוט
אף בוט, סקריפט או "שירות AI" לא מקבל מפתח עם הרשאת משיכה (Withdraw). אם תעברו מתישהו ל-Live: מפתח למסחר בלבד, הגבלת IP אם הברוקר מאפשר, ומפתח נפרד לכל מערכת.
LLM≠$
מודלים ממציאים
ראיתם בשלב 4: הבוט כופף חוק כתוב. מודל יכול גם "לסכם" כותרת לא נכון, או להיות בטוח מדי. לכן הנתונים מחושבים בקוד, החוקים בקוד, והמודל רק מפרש.
IL
רגולציה בישראל (ברמה כללית)
ייעוץ השקעות וניהול תיקים בישראל מוסדרים ברישיון מטעם רשות ניירות ערך. מסחר בכסף שלכם לצורך לימוד זה דבר אחד. לנהל כסף של אחרים עם בוט, למכור "סיגנלים" או להציע "רובוט מסחר" לקהל עלול לדרוש רישיון. הרשות כבר התריעה בעבר על רובוטי מסחר. זה לא ייעוץ משפטי: לפני כל דבר כזה, עורך דין ורואה חשבון (גם בגלל מס).
≠
דמו מחמיא למציאות
אין החלקה, אין השפעה על השוק, מילוי קל מדי. גם Alpaca כותבת את זה בדוקומנטציה. רווח על נייר הוא לא הבטחה לכלום.
$
עלויות שקטות
טוקנים, נתונים בתשלום, עמלות. דסק שמריץ 300 סוכנים כל שעה יכול לעלות יותר ממה שהוא "מרוויח" על נייר. השתמשו במחשבון.
ארגז הכלים
הכלים, חינם מול בתשלום
כלי
למה הוא בדסק
עלות
קישור
xAI Grok API
המוח בענן. תואם OpenAI SDK דרך base_url, ה-Responses API הוא הממשק הראשי.
משתני הסביבה לא הוגדרו בחלון הזה. ב-PowerShell הם חיים רק בחלון שבו הגדרתם אותם. הגדירו שוב ונסו.
no data for XYZ
טיקר לא נכון, או ש-Yahoo חוסם זמנית. בדקו את הטיקר ב-finance.yahoo.com ונסו שוב בעוד כמה דקות. מניות ת"א מקבלות סיומת .TA (למשל TEVA.TA).
"error": "invalid JSON from model"
המודל החזיר טקסט שבור גם בניסיון השני. מודלים קטנים עושים את זה יותר. נסו מודל גדול יותר, או קצרו את הקלט.
הכל יוצא HOLD
זה בסדר, ככה זה תוכנן. החוקים שמרניים. אל "תתקנו" את זה בהורדת הספים כדי לראות פעולה. זה בדיוק ה-overfitting שמפיל אנשים.
ריצה איטית עם Ollama
הריצה הראשונה כוללת טעינה של המודל לזיכרון (אצלנו כדקה). אחר כך זה מהיר. אין GPU? בחרו qwen3.5:2b.
החשבון ב-xAI נגמר מהר
הורידו את --crowd, צמצמו מניות, או עברו ל-Ollama לפיתוח ושמרו את Grok לבדיקות.
מהפוסט
השקופיות המקוריות
שאלות נפוצות
שאלות ותשובות
זה חייב להיות Grok?
לא. הקוד מדבר עם כל שרת שתומך ב-Responses API בפורמט של OpenAI. בדקנו אותו בפועל עם Ollama מקומי. עם Grok שמנו את ה-base URL והמודל לפי הדוקומנטציה הרשמית, אבל לא הרצנו אותו עם מפתח (אין לנו חשבון בתשלום במדריך הזה).
יש ל-Grok API שכבה חינמית?
בדוקומנטציה הרשמית לא מצאנו. באתר כתוב ש-Playground כלול בכל חשבון, ויש אפשרות לקוד פרומו. ראינו באתרים לא רשמיים דיווחים על קרדיטים חינמיים בתנאים מסוימים, אבל לא אימתנו אותם. הכי פשוט: היכנסו ל-Billing בקונסול ותראו מה מופיע אצלכם.
אפשר לחבר את זה לחשבון אמיתי?
הקוד במדריך בכוונה לא יודע לעשות את זה. אם אתם שוקלים כסף אמיתי: קודם 30 יום של יומן (שלב 8), מדידה מול SPY, סכום שאתם מוכנים לאבד במלואו, ושיחה עם איש מקצוע מורשה. ובלי הרשאות משיכה. אף פעם.
זה עובד על מניות בבורסת תל אביב?
yfinance תומך בטיקרים עם סיומת .TA. הכותרות שם כמעט כולן באנגלית ומעטות, אז NEWS יהיה חלש יותר. Alpaca Paper הוא לשוק האמריקאי.
למה בוט הסיכון לא בא לפני הבוס, כמו בפוסט?
כי הוא צריך הצעה לבדוק. אצלנו הבוס כותב הצעה, והסיכון הוא המילה האחרונה. ככה "הבוס רוצה כן" ו"אחד רק אומר לא" נפגשים בדיוק בנקודה הנכונה.
כמה זה עולה בפועל?
עם Ollama: אפס, חוץ מחשמל. עם grok-4.3 ו-5 מצביעים, לפי ההערכה שלנו בערך סנט לריצה. 300 מצביעים: בערך חצי דולר לריצה. השתמשו במחשבון למעלה.
צ'קליסט לפני שאתם קוראים לזה "דסק"
רוצים עוד מערכות כאלה?
עקבו אחרי @mr.benshabat
כל שבוע: מערכות AI, אוטומציות ושיווק דיגיטלי, מוסברים צעד אחר צעד. בלי הבטחות לכסף קל.