MoneySharks

Autonomous 24/7 Aster Futures perpetual trading agent. Purpose: generate the largest sustainable ROI from live leveraged futures trading on Aster DEX, operating continuously without per-trade human intervention, learning from every completed trade.

---

Core rules

• - Require onboarding before any private API action. Never use credentials that haven't been verified.
• Default mode is paper until the user completes onboarding and types ACCEPT at the consent gate.
• In autonomous_live mode: execute orders immediately — do NOT pause for per-trade human approval.
• All hard risk limits are permanent: daily loss cap, max exposure, max notional, leverage ceiling, stop-loss and take-profit requirements, circuit breakers. None can be overridden by configuration changes, learning, or performance.
• Never hardcode secrets. API key and secret live only in environment variables.
• Never silently expand risk. Never raise leverage above max_leverage, never change mode to a riskier mode without explicit user instruction.
• Never self-modify hard risk rules. The learning system adjusts confidence and leverage within bounds — it cannot rewrite the rules that define those bounds.
• Journal every decision, including wait decisions. No silent cycles.

---

Modes

Mode	Real Orders	Approval Per Trade	Description
INLINECODE5	No	N/A	Full pipeline simulation. Real market data, no API writes.
INLINECODE6

No | Yes | Generates proposals and waits for per-trade confirmation before submitting. | | live | Yes | Configurable | Live execution. Per-trade approval gate controlled by execution.require_human_approval_for_live_orders. | | autonomous_live | Yes | No | Full autonomy. Consent locked in once at onboarding. Executes every decision immediately 24/7. |

---

Files in this skill

Core skill file

• - SKILL.md — this file

Documentation

• - documentation-moneysharks.md — comprehensive human-readable documentation: architecture, all config options, pipeline deep-dives, API integration details, operational runbook, FAQ. Read this for context before explaining anything to the user.

References (read when needed)

• - references/onboarding.md — onboarding flow, consent gate text, defaults, post-ACCEPT steps
• INLINECODE13 — multi-TF strategy principles (4H trend, 1H signal, 5M timing)
• INLINECODE14 — 9-point confluence check definitions and confidence thresholds
• INLINECODE15 — leverage selection rules and volatility adjustments
• INLINECODE16 — hard risk rules, circuit breaker conditions
• INLINECODE17 — step-by-step execution cycle for each mode
• INLINECODE18 — exactly what is and isn't gated in autonomous_live
• INLINECODE19 — what the learning system may and may not adapt
• INLINECODE20 — halt sequence, resume, circuit breaker, trigger phrases
• INLINECODE21 — cron job intervals, 24/7 continuity rules
• INLINECODE22 — API integration scope and guidance
• INLINECODE23 — Aster skill family map
• INLINECODE24 — approval mode flow
• INLINECODE25 — proposal generation and approval handoff
• INLINECODE26 — real-time data feed (advanced / optional)
• INLINECODE27 — systemd / launchd deployment
• INLINECODE28 — skill packaging
• INLINECODE29 — ready-to-use OpenClaw cron job definitions (paths substituted by register_crons.py)

Scripts — live trading core (29 scripts total)

Entry point

• - scripts/autonomous_runner.py — main 24/7 entry point. Called by cron every 2 min. Validates config + credentials, checks halt/circuit-breaker, runs position_monitor.py for all known open positions, runs trade_loop.py per symbol, runs trailing stop management for open positions, triggers post-trade review every 5 new trades. Writes state.json after every cycle.

Per-symbol execution loop

• - scripts/trade_loop.py — single-symbol execution cycle. Enforces cooldown after close, duplicate position guard, learning-adjusted confidence threshold, and learning-capped leverage. Calls the full scan → risk → execute → journal pipeline. Handles paper, live, and autonomous_live execution branches. Updates known_open_positions in state on successful entry.

Market data and feature computation

• - scripts/market_scan_from_aster.py — fetches real multi-TF klines (5m/1h/4h), ticker, mark price + funding rate, order book depth, and account bundle from Aster API. Computes all features, signal, confluence, leverage, and position size. Applies exchange precision rounding via round_quantity() / round_price(). Enforces MIN_NOTIONAL from exchangeInfo. Performs order-book liquidity check. Returns a complete order proposal or null for non-entry signals.
• INLINECODE45 — from a kline array: computes EMA20, EMA50, EMA12, EMA26, RSI14, ATR14, MACD line, MACD signal, volume ratio, trend (up/down/neutral), momentum (up/down/neutral), highvolatility flag. Accepts optional funding_rate passthrough.
• INLINECODE53 — multi-TF weighted scoring for long and short. 7 factors each: 4H trend (weight 2), 1H trend (weight 2), RSI zone (1.5), MACD crossover (1), 5M timing (0.5), volume (1), EMA20 position (1). Incorporates funding rate bias (+0.5 weight). In high volatility raises the entry bar to 0.70. Generates close signal on trend reversal or extreme RSI with existing position.
• INLINECODE55 — 9-point binary check system: trend_alignment, momentum_confirmation, volume_confirmation, rsi_zone, macd_alignment, reward_risk_ok, exposure_capacity_ok, position_capacity_ok, timeframe_confluence. Confidence = checkspassed/9. Requires ≥ 0.55 for new entries (configurable via learning).

Sizing and risk

• - scripts/recommend_leverage.py — maps confidence to leverage (min at < 0.60, midpoint at 0.60–0.79, max at ≥ 0.80). Steps down by 1 in high volatility. Result is further capped by effective_leverage_cap from learning metrics.
• INLINECODE67 — risk-based position sizing: notional = (equity × risk_pct) / stop_distance_pct. Returns risk_usd, stop_distance_pct, notional, margin, quantity.
• INLINECODE74 — four hard enforcement checks: daily loss limit hit, total exposure after trade vs max_total_exposure, per-trade notional vs max_notional_per_trade, available margin vs required margin. Also guards against zero notional. Only enforces limits that are set > 0.
• INLINECODE77 — constructs the final order dict from sizing outputs (symbol, side, type, quantity, leverage, stoploss, takeprofit).

Execution

• - scripts/live_execution_adapter.py — gated live execution. Checks credentials, enforces mode guard (only live or autonomous_live), enforces approval gate in live mode, skips gate in autonomous_live. Calls aster.place_bracket() → entry MARKET + STOPMARKET + TAKEPROFITMARKET. Returns full order result JSON.
• INLINECODE84 — complete Aster DEX API client. HMAC-SHA256 signing, retry logic (3 retries, exponential backoff, 429 Retry-After respect, 5xx retry). Exchange info cache (1h TTL). round_quantity(), round_price(), get_symbol_filters(). Public endpoints: ticker, mark price, depth, klines, funding rate, exchangeInfo. Private reads: account, positions, open orders, income history, user trades. Private writes: setleverage, setmargintype, placeorder (MARKET / STOPMARKET / TAKEPROFITMARKET), cancelorder, cancelallorders, closeposition_market, place_bracket(). CLI modes: market, market_bundle, klines, account, mark_price, funding, set_leverage, cancel_all, income, trades, positions.

Position lifecycle management

• - scripts/position_monitor.py — runs at the start of every cycle. Compares state.json → known_open_positions to live Aster positions. When a position disappears: queries /fapi/v1/income for REALIZEDPNL, classifies outcome (win/loss/breakeven), detects close reason (stop_loss_hit/take_profit_hit/unknown), updates the matching journal entry in trades.json with outcome, realised_pnl, close_reason, closed_at, lesson_tags, regime. Adds to daily_loss on losses. Cleans up known_open_positions.
• INLINECODE119 — calculates updated stop-loss for an open position. Two modes: atr (trail = currentprice ± ATR × 1.5) and breakeven (move SL to entry + buffer when PnL ≥ 0.5%). Never moves against the position. Called by autonomous_runner.py after trade loops. When moved=true, autonomous_runner.py cancels the old STOP_MARKET order and places a new one via aster_readonly_client.

Learning pipeline

• - scripts/fetch_trade_outcomes.py — backbone of the self-learning loop. Queries /fapi/v1/income (REALIZEDPNL) for each symbol with unresolved journal entries. Matches income records by symbol and time. Writes outcome, realised_pnl, and lesson_tags into trades.json. For paper mode (with --paper flag): estimates outcome from current mark price vs recorded SL/TP levels. Returns counts of updated entries.
• INLINECODE133 — analyses trades.json: win rate, avg PnL, total PnL, max loss streak, lesson tag frequency, performance by symbol, performance by market regime (trendingup, trendingdown, highvolatility, ranging), high-confidence trade win rate. Generates lessons list.
• INLINECODE136 — applies learning adaptations from review to state.json → metrics. Adaptations: confidence_multiplier (lowered after ≥4 loss streak, recovered after winning), effective_leverage_cap (lowered after ≥3 streak or win_rate < 35%, recovered slowly), recommended_min_confidence (raised when high-confidence trades outperform), underperforming_symbols flag. All bounded by config limits — never raises leverage above max_leverage.
• INLINECODE143 — appends one entry to trades.json. Sets ts if missing.

Setup and operations

• - scripts/onboarding.py — interactive CLI onboarding. Step 1: reads/prompts credentials, verifies against Aster /fapi/v2/account live call (fails hard on bad creds). Step 2: collects symbols, base investment, leverage range, exposure limits, daily loss limit, allow_short. Step 3: presents consent gate — must type ACCEPT to enable autonomous_live. Step 4: writes config.json, calls register_crons.py, prints next steps.
• INLINECODE152 — substitutes /ABSOLUTE/PATH/TO/moneysharks placeholder in openclaw-cron-templates.json with the real skill root path. Selects which jobs to enable based on mode. Writes register_crons.json. Called automatically by onboarding.py.
• INLINECODE157 — validates config.json: all required fields present, valid mode, consent set for autonomous_live, leverage bounds sensible, notional vs exposure consistency, cron scan interval, symbols non-empty. Returns {"ok": bool, "errors": [...], "warnings": [...]}.
• INLINECODE161 — two modes. Stdin mode (-): accepts {"account": {...}, "positions": [...], "orders": [...]} JSON and returns a reconciled summary. CLI mode: fetches live account bundle from Aster API and updates state.json → account + positions_snapshot fields. Use at startup and after resume.
• INLINECODE166 — emergency halt CLI. Sets halt=true + circuit_breaker=true in state.json. Cancels all orders for each allowed symbol if --cancel-orders or execution.cancel_on_halt=true. Optionally flattens all open positions with --flatten. Accepts --reason "text". Journals a halt_event entry. Prints confirmation.
• INLINECODE175 — resume from halt. Clears halt=false, circuit_breaker=false, consecutive_errors=0. Optionally switches mode (--mode paper|autonomous_live). Guards: cannot resume into autonomous_live without autonomous_live_consent=true in config. Fetches live account reconciliation. Journals a resume_event. Optionally runs first cycle (--run-now).
• INLINECODE184 — live status report. Fetches account + positions from Aster API. Reads state.json and trades.json. Outputs: mode, halt, circuit breaker, consecutive errors, daily loss vs limit, last cycle age, credentials status, equity, available margin, today PnL, open positions with uPnL, trade stats (total/executed/closed, win rate, total PnL), adaptive metrics (win rate, avg PnL, eff leverage cap, confidence multiplier), active lessons, config summary. Human-readable by default; --json for machine output.

Approval / proposal mode helpers

• - scripts/aster_proposal_runner.py — generates an approval-gated order proposal using real Aster market data. Calls market_scan_from_aster.py for the symbol, extracts price and order params, emits a PENDING_APPROVAL proposal with confidence, leverage, entry, SL, TP, and signal context.
• INLINECODE191 — constructs a PENDING_APPROVAL proposal dict from order inputs. Used in approval mode trade loop.
• INLINECODE194 — returns a monitoring status dict indicating scan-journal-propose mode. Stub for approval watcher loop.
• INLINECODE195 — legacy paper simulation runner (static file inputs). Main paper flow uses autonomous_runner.py with mode=paper.

Config and data files

• - config.json — your active configuration. Written by onboarding.py. Never commit with real credentials.
• INLINECODE200 — annotated reference config with all fields and sensible defaults.
• INLINECODE201 — live agent state: halt, circuit_breaker, consecutive_errors, daily_loss, last_run, account, known_open_positions, last_close_ts, metrics.
• INLINECODE211 — state schema reference.
• INLINECODE212 — complete trade journal. Append-only during operation. Every decision logged.
• INLINECODE213 — trades schema reference.
• INLINECODE214 — generated by register_crons.py at onboarding. Contains ready-to-register OpenClaw cron job defs with real paths substituted.

Setup

• - install.sh — setup verification: Python 3.10+ check, all 21 required scripts present, all scripts syntax-valid, config validation, credentials check.
• INLINECODE217 — no pip dependencies (stdlib only). Documents optional advanced integrations.

Deployment

• - deploy.systemd.service / deploy.systemd.timer — Linux systemd unit files for 24/7 background deployment.
• INLINECODE220 — macOS launchd plist for 24/7 background deployment.
• INLINECODE221 — Linux log rotation config.
• INLINECODE222 — macOS log rotation config.

---

Workflow

Per-cycle execution (called by cron every 2 min)

CODEBLOCK0

Onboarding flow

CODEBLOCK1

Post-ACCEPT: register cron jobs (agent executes these steps)

After writing config.json and generating register_crons.json, the agent reads the file and calls cron(action="add", job=...) for each of the four active jobs:

Job key	Schedule	sessionTarget	delivery
INLINECODE226	INLINECODE227 UTC	isolated	none
INLINECODE228

*/30 * * * * UTC | isolated | none |
| autonomous_daily_summary | 0 0 * * * UTC | isolated | announce |
| halt_check | */15 * * * * UTC | isolated | announce |

The exact job JSON (with real paths) is already written to register_crons.json by register_crons.py. The agent reads each entry and passes it directly to cron(action="add").

---

Onboarding requirements

Collect only the essentials — everything else uses sensible defaults:

Input	Required	Default	Notes
INLINECODE237	Yes	—	Verified live against Aster API before proceeding
INLINECODE238

Yes | — | Never written to config.json |
| allowed_symbols | Yes | BTCUSDT, ETHUSDT, SOLUSDT | Must be valid Aster Futures symbols |
| base_value_per_trade | Yes | 100 | USD reference investment per trade |
| max_leverage | Yes | 10 | Hard ceiling — never exceeded |
| min_leverage | No | 2 | Floor for low-confidence setups |
| max_total_exposure | No | base_value × 10 | Total open notional cap |
| max_daily_loss | No | total_exposure × 10% | Daily loss hard stop |
| allow_short | No | true | Set false for long-only mode |
| Consent: ACCEPT | Yes | — | Cannot be set programmatically — user must type it |

Full config field reference: documentation-moneysharks.md § 5.

---

Signal generation summary

Signals from compute_signal.py (weighted scoring, each factor contributes independently):

Factor	Weight	Long condition	Short condition
4H trend	2.0	trend == "up"	trend == "down"
1H trend

2.0 | trend == "up" | trend == "down" |
| RSI zone | 1.5 | RSI 45–68 | RSI 32–55 |
| MACD crossover | 1.0 | MACD > signal | MACD < signal |
| 5M timing | 0.5 | 5m trend/momentum up | 5m trend/momentum down |
| Volume | 1.0 | volumeratio ≥ 0.8 | volumeratio ≥ 0.8 |
| EMA20 position | 1.0 | price > EMA20 | price < EMA20 |
| Funding rate bias | 0.5 | funding < −0.0001 | funding > +0.0001 |

Entry threshold: score ≥ 0.55. High-volatility override: threshold raised to 0.70.
wait if neither long nor short meets threshold.
hold / close logic runs when a position is already open (trend reversal, extreme RSI).

---

Confluence scoring (9-point system)

Implemented in compute_confluence.py. Confidence = checks_passed / 9.

Check	Passes when
INLINECODE252	1H trend matches direction; 4H at least neutral
INLINECODE253

RSI-based 1H momentum matches direction |
| volume_confirmation | volume_ratio ≥ 0.75 |
| rsi_zone | RSI in valid entry zone (long 40–70, short 30–60) |
| macd_alignment | MACD line above signal (long) / below signal (short) |
| reward_risk_ok | (take_profit − entry) / (entry − stop_loss) ≥ min_reward_risk |
| exposure_capacity_ok | currentexposure < maxtotal_exposure × 0.90 |
| position_capacity_ok | openpositions < maxconcurrent_positions |
| timeframe_confluence | Both 1H AND 4H trend align with direction |

Minimum confidence to enter: 0.55 (5/9). Raises to 0.70 in high volatility.

Stop/target defaults (when ATR available): SL = entry ± 1.5×ATR, TP = entry ± 2.5×ATR → natural R:R 1.67×.

---

Learning system summary

Three-step cycle after every set of closed trades:

1. 1. fetch_trade_outcomes.py — pulls REALIZED_PNL from /fapi/v1/income, resolves outcome + realised_pnl + lesson_tags in INLINECODE267
2. INLINECODE268 — computes win rate, avg PnL, loss streak, regime performance
3. INLINECODE269 — applies bounded adaptations to state.json → metrics:

Metric	What it does	Bounds
INLINECODE271	Multiplied into raw confidence score before threshold check. < 1.0 makes entry harder.	0.70 floor; recovers toward 1.0
INLINECODE272

Caps the leverage recommended by recommend_leverage.py. | min_leverage floor; max_leverage ceiling — hard | | recommended_min_confidence | Entry threshold. Raised when high-confidence trades outperform. | 0.55 default; 0.75 max | | leverage_reduction_active | Flag indicating leverage has been reduced by learning. | Bool only | | underperforming_symbols | Symbols with total PnL < −$100. Informational. | — |

Learning cannot: raise leverage above max_leverage, change mode to riskier, suppress journaling, remove stop-loss requirements.

---

Hard safety rules (always enforced, cannot be bypassed)

Rule	Enforcement point
INLINECODE280 — blocks ALL entries when daily loss hits limit	INLINECODE281, INLINECODE282
INLINECODE283 — caps total open notional

risk_checks.py |
| max_notional_per_trade — scales down + hard blocks oversized trades | market_scan_from_aster.py, risk_checks.py |
| max_leverage — hard ceiling on all leverage | recommend_leverage.py, update_metrics.py |
| require_stop_loss — every live trade has STOP_MARKET | live_execution_adapter.py |
| require_take_profit — every live trade has TAKEPROFITMARKET | live_execution_adapter.py |
| ISOLATED margin — per-position loss cannot drain full account | aster_readonly_client.py → place_bracket() |
| reduceOnly=true on SL/TP — closing orders never open new positions | aster_readonly_client.py → place_order() |
| halt=true blocks all execution | autonomous_runner.py, trade_loop.py |
| circuit_breaker=true blocks all execution | autonomous_runner.py |
| Consecutive errors ≥ 5 auto-trips circuit breaker | autonomous_runner.py |
| Learning cannot raise leverage above max_leverage | update_metrics.py |
| autonomous_live_consent cannot be set by agent self-action | onboarding.py consent gate only |

---

Emergency controls

Trigger phrases (say to OpenClaw agent)

CODEBLOCK2

Halt sequence (automatic on any trigger phrase)

1. 1. Set state.json → halt=true, INLINECODE309
2. Cancel all open orders for each allowed symbol (if execution.cancel_on_halt=true — default)
3. Close all positions (only if --flatten flag or execution.flatten_on_emergency_stop=true)
4. Journal a halt_event entry in INLINECODE314
5. Announce: "MoneySharks halted. Cycles stopped. Orders cancelled. Positions: [status]. Say 'resume moneysharks' to restart in paper mode."

CLI:
CODEBLOCK3

Resume sequence

CODEBLOCK4

1. 1. Clear halt=false, circuit_breaker=false, INLINECODE317
2. Update config.json mode if changed
3. Fetch live account reconciliation from Aster
4. Journal INLINECODE319
5. Run first cycle if INLINECODE320

Resuming into autonomous_live requires autonomous_live_consent=true already in config.json. It cannot be set by the resume script — only by onboarding ACCEPT.

Circuit breaker

• - Auto-trips when INLINECODE324
• Any successful cycle resets the counter to 0
• Clear via resume.py or by editing INLINECODE326

---

Cron jobs (24/7 autonomous operation)

All defined in openclaw-cron-templates.json. Paths auto-substituted by register_crons.py.
Registered automatically by the agent at the end of onboarding (on ACCEPT).

Job	Schedule	What it runs	Delivery
INLINECODE329	every 2 min	INLINECODE330	none (silent)
INLINECODE331

every 30 min | fetch_trade_outcomes.py + review_trades.py | none (silent) |
| moneysharks-daily-summary | 00:00 UTC daily | status.py + review_trades.py → full day summary | announce |
| moneysharks-halt-check | every 15 min | status.py --json → alert if halt/CB/errors/daily loss approaching | announce (only on problem) |

In paper mode: autonomous_live_scan and autonomous_review are replaced by:

• - moneysharks-paper-market-scan (every 5 min)
• INLINECODE342 (every 30 min)

---

Status and monitoring

CODEBLOCK5

Shows: mode, halt, circuit breaker, consecutive errors, daily loss %, last cycle age, credentials, equity, available margin, today PnL, open positions with uPnL, win rate, avg PnL, total PnL, adaptive metrics, active lessons, config summary.

---

Key data files

state.json structure

CODEBLOCK6

trades.json entry structure (executed trade)

CODEBLOCK7

---

Quick reference: when something goes wrong

Symptom	Likely cause	Fix
No trades being placed	Confidence below threshold, or wait signal	Check status.py, review recent journal entries
Circuit breaker active

≥5 consecutive API errors | resume.py --mode paper, investigate logs |
| Daily loss limit hit | Too many losses today | Waits for UTC midnight to reset, or lower max_daily_loss |
| Halt active | Manual or automatic halt | resume.py config.json --mode paper |
| Credential error | ASTER_API_KEY/ASTER_API_SECRET not set | Set env vars, re-run install.sh to verify |
| Trades have no outcome | fetch_trade_outcomes.py hasn't run yet | Run manually or wait for next 30-min review cron |
| Leverage too high in learning | Loss streak triggered effective_leverage_cap reduction | Wait for recovery, or reset metrics in state.json |

For full operational runbook, see documentation-moneysharks.md § 16.