Funnel profiles — g7

Delivery profiles from TEARDOWN.md evidence only, except where marked (live). Open-source frameworks are profiled on their distribution funnel, not a SaaS funnel, where that is what they are.

nansen

• product: On-chain analytics terminal — Smart Money wallet tracking, token/wallet profilers, macro indicators, plus in-app spot/perps execution.
• surfaces: Web dashboard (app.nansen.ai SPA) + marketing site; API; AI agent in-app; Smart Alerts; trading via Jupiter/OKX/LI.FI/Hyperliquid routing.
• unit: A server-computed widget/page — PnL leaderboard ranked by trailing-30d realised PnL, Token God Mode page (holders, who-bought/sold, flow), Risk Barometer level 1–5, Nansen Score, or a Smart Alert. Customer receives precomputed answers, not methodology.
• cadence: Real-time/intraday data and alerts; leaderboards/scores refreshed server-side.
• mode: Pull (dashboard) + push (Smart Alerts).
• curation: Algorithmic, sealed — ~50-label taxonomy ships client-side; label assignment, PnL engine, Risk Barometer and Score formulas are server-side only.
• free_surface: Free plan: Smart Money restricted to Solana + Hyperliquid chains, exactly 1 active Smart Alert, 20 AI Agent credits/mo per client copy, API refill 10/day per vendor copy.
• paywall: Plan rank free < pioneer < professional < pro in code. Pro gates full chains, Risk Barometer tab, higher alert/API/agent limits.
• conversion: Single Pro plan $49/mo annual / $69/mo monthly replacing Pioneer $99 and Professional $999+; "unlimited" qualified in vendor's own copy as subject to fair-use limits; points/staking tiers 1,000 / 10,000 / 100,000 / 500,000.
• actionability: Discovery-grade: follow cohort net flow or copy a wallet manually, or trade in-app — no entry/stop/target is given with a unit; interpretation is the customer's.
• trust_record: No audited performance record published; "backtested strategies" is a named server widget with no rules, parameters or figures shipped. Claim audit: 500M+ labels UNVERIFIABLE, AI-credit cadence REFUTED as consistent (per week vs per month on vendor's own surfaces), risk disclosures CONFIRMED honest with no win-rate/return promise on pages fetched.

arkham

• product: Entity/wallet intelligence platform — Explorer, Visualizer, Tracer, Labels, Cases, 0–100 risk scoring, plus API, Predictions and an Exchange/Swap surface in the same client.
• surfaces: Web platform (arkm.com / intel.arkm.com, one Next.js SPA for marketing + app); API; alerts to Telegram / Slack / webhook; Intel Exchange bounty marketplace.
• unit: An entity or address profile, a Visualizer/Tracer graph, a transfers table, or a risk score 0–100 with named subscores (sanctions, hacker, scam, ponzi, darkweb per vendor guide).
• cadence: Real-time — realtime websocket ships in client; vendor notes much data previously updated once a day.
• mode: Pull (explorer/search) + push (alerts, delivery method locked per entitlement).
• curation: Algorithmic, sealed — ULTRA matching/clustering and risk arithmetic are 100% server-side; human layer via bounty submissions verified by the vendor.
• free_surface: Post-Oct 2026 free residue: Arkham labels incl. predicted labels, Visualizer 2.0, block explorer, tags, prediction markets, pre-existing custom labels/entities, limited alerts, 100 most recent transactions per address/entity.
• paywall: Server-granted entitlements/capabilities, no numeric limits hard-coded client-side — vendor can redraw the wall with no client change. Oct 2026 move put Tracer 2.0, filtering, full history, counterparties, custom label/entity/case creation behind Enterprise.
• conversion: Enterprise $1,500/mo per team, 14-day trial then card on file charged, monthly renewal, payments final/non-refundable; public sales page says only "pricing per team — request access"; Enterprise Grants programme for independent/public-interest investigators.
• actionability: Investigative, not trade-actionable: an attribution or risk score to act on elsewhere; no entry/stop/target, no trade instruction in a unit.
• trust_record: Marketed as "The Source of Truth On-Chain"; claim audit REFUTED that as a guarantee — documented predicted-label incidents (a denied wallet attribution; a predicted label republished as fact, later removed, with a reported intraday stock dip), a Zcash shielded-labelling dispute consistent with the client's own shielded-address exclusion, and Terms warranting the service "AS IS" with accuracy expressly disclaimed. Predicted vs verified labels are separate classes in data and UI; labels are retroactively revisable with no point-in-time snapshot, so historical joins leak.

ai-fund

• product: Open-source multi-agent orchestration framework for Claude Code — 45 LLM persona agents wired via MCP to exchange APIs, backed by a TypeScript quant library.
• surfaces: Local Claude Code / CLI; MCP connectors (Cube, Alpaca, CCXT); no hosted dashboard, Discord, or newsletter evidenced.
• unit: An agent persona output, a signal-generator scan (score −100…+100 with overallBias per symbol), or a backtest run from 9 textbook strategies (SMA crossover, RSI mean reversion, MACD, Bollinger, EMA trend, stochastic, ADX, confluence).
• cadence: On-demand, user-run; no scheduled push.
• mode: Pull — user invokes slash commands/prompts; paper trading by default.
• curation: Hybrid — deterministic detectors (EMA ribbon, RSI, MACD, Bollinger, ATR/ADX/stochastic) plus LLM persona judgment; "debate" and KPI firing are manual prompts, not code.
• free_surface: The whole repo is the free surface — framework, library, backtester, Monte Carlo, walk-forward tooling.
• paywall: None in the product; cost sits outside it (host LLM subscription, exchange accounts).
• conversion: No funnel evidenced — GitHub distribution, no tiers, trial, or upsell in the teardown.
• actionability: Moderate: scan gives bias/score at latest close and connectors can place paper/live orders under hard risk limits (20% max position, 15% max drawdown, 3x leverage, 40% concentration, 5% daily loss); no complete entry/stop/target package is guaranteed per unit.
• trust_record: No forward record or published results in repo. Claim audit: agent/risk/paper claims CONFIRMED, "market maker running Avellaneda-Stoikov" and automated agent debate REFUTED (prose only), KPI firing REFUTED as automation. Backtester executes at the same bar's close (1-bar effective lookahead) and its optimizer is in-sample with no correction — any Sharpe it prints is an upper bound.

ai-trader

• product: Social paper-trading arena for external AI agents — the platform supplies accounts, pricing, leaderboards and challenges; it supplies no strategy of its own.
• surfaces: Web platform (FastAPI + React); REST API + markdown skills for agents (ai4trade, copytrade, heartbeat, market-intel, polymarket, tradesync); pull-based heartbeat polling.
• unit: A published signal/trade post (strategy / operation / discussion), a paper position, or a challenge entry — re-priced server-side at submission.
• cadence: Real-time submission and marking; agents poll on a 30–60s heartbeat (websocket explicitly not trusted for delivery).
• mode: Push submission by agents, pull consumption by followers — "one-click copy trading" is not push: the broadcast function is a stub returning a count, so a follower's own agent must poll and re-submit.
• curation: External agents pick everything; platform "signal quality" is a keyword/length heuristic (direction words, target-price regex, "because/risk/evidence" counts) measuring post format, not predictive power.
• free_surface: $100K paper account, signal publishing, challenges, Polymarket paper trading with live mid-price fills and auto-settlement.
• paywall: None evidenced in the teardown.
• conversion: Points/rewards ledger (fixed + quality-weighted) for publishing and gaining followers, team missions, A/B experiments, challenge rankings.
• actionability: A follower can mirror a leader's positions only by building the poll-and-resubmit loop; a trade unit itself carries the executed price as re-priced by the server, not an entry/stop/target instruction.
• trust_record: Strongest honesty machinery in this group: server discards agent-claimed prices and re-prices from as-of-time candles (rejecting when no quote exists), challenge replay scorer with hard disqualifications (position %, drawdown, side violations) and risk-adjusted ranking, 0.1% per-trade fee. Gaps found: unbounded backdated executed_at allows hindsight trade insertion, and future-dated challenge trades are only clock-guarded on Polymarket. Marketing REFUTED on "100% fully-automated" (no platform automation), copy trading, and universal market access (only us-stock, crypto, polymarket in code).

alpaca-trading-agent

• product: Self-hosted LLM multi-agent trading framework (TradingAgents fork) — 5 analysts, bull/bear debate, risk debate, deterministic sizing/safety layer, Alpaca stock/crypto execution, paper + live.
• surfaces: Web UI (Dash panels incl. account, analysis, backtest, decision, safety, prompt/tool-output inspection); CLI; Telegram alerts.
• unit: A per-symbol analysis run ending in a trader plan and a deterministically parsed FINAL TRANSACTION PROPOSAL (BUY/SELL/HOLD), optionally executed as a market or bracket order with GTC stop + target.
• cadence: On-demand per symbol/run; checkpointed per symbol in SQLite for resume.
• mode: Pull — user launches the run; no push signal feed evidenced beyond Telegram alerts.
• curation: Hybrid — LLM decides direction via debate; deterministic Tier-1 technical brief (EMA/SMA, Wilder RSI-14, MACD, ADX, Bollinger, swing structure, majority-vote setup + confidence) and a deterministic regime/sizer/SafetyGuard decide size and admissibility.
• free_surface: Whole framework is open source; user brings LLM and Alpaca keys.
• paywall: None in the product; external LLM/broker costs only.
• conversion: None evidenced.
• actionability: Highest execution completeness among the agent frameworks here: direction + fractional-Kelly sizing (shrunk confidence→edge map, 1% risk/trade default, 2.0× ATR stop, 20% max position) + bracket protection, gated by a kill switch, notional/concentration caps, daily-loss and drawdown brakes — exits bypass exposure gates, the kill switch does not.
• trust_record: Backtest is unusually honest — next-open fills, slippage from the prior completed bar's range, news filtered to publish date ≤ decision date, with an explicit README warning on point-in-time limits. Live path FAILS the same standard: intraday indicators read the forming bar (iloc[-1]). README model catalog REFUTED — it lists non-existent models ("GPT-6 Astra", "Claude Fable 5.1", others) while claiming curation from official provider documentation. No published live track record.

azrael-1587

• product: A SPX morning planning method — "The 15.87 Rule" (VIX ÷ 15.87 = the day's priced range) sold as a free 16-page PDF brief, with a paid daily Desk subscription described inside it.
• surfaces: PDF ("The Vault"); X launch post with a full worked day; paid Desk per the brief's own timestamps (pre-open map, open, entry window, flat, close).
• unit: Free: a hand-completed morning worksheet — five lines (walls ±EM, shelves ±EM/2, magnet at prior close), circled VIX regime (CALM <15 / MIXED 15–18.5 / FAST >18.5), pre-written 1R in points, second-wall OI shortlist. Paid (as described): the daily map with dealer gamma, a graded plan, one scored idea with invalidation, and a graded result.
• cadence: Daily, pre-open (routine timed 07:55–08:08); trade window 09:50–11:05, hard flat 11:30.
• mode: Pull — the customer computes and draws the map before 09:30; the brief's gate is explicit: if you cannot write all five numbers, you do not trade.
• curation: Human-authored formula + options open interest (three biggest strikes above/below; agreement between chain and formula flags the level); no algorithmic feed in the free product.
• free_surface: Unusually complete: the formula, the five-line map, the regime rulebook, the clock, the flow check (size vs OI, bid/ask aggressiveness, premium not contracts), and one full setup — the Three-Ticker Break.
• paywall: The wall sits on daily labour and selection, not the method: the free brief states it does not say which setup is on today, does not fix the strike, does not answer "no trade", and does not enforce the 11:30 exit. Strike selection, sizing beyond 1R-in-points, and the CALM fade's stop/entry line are also absent from the free material.
• conversion: Classic lead-magnet funnel — free brief gives the method away, worked X post demonstrates it on that day's closes, paid Desk sells having it done, graded, and enforced daily.
• actionability: Very high for the one setup: all three of SPX/SPY/QQQ must close outside their own 20-min box on the same 5-min bar, box ≤ 0.2×EM, break ≥ 0.05×EM, >8 pts room to next level, target = next map line at least 1R away, stop = 5-min close back inside the box, flat 11:30 no exceptions.
• trust_record: No track record in the free brief and none claimed as audited: the ±EM band is presented as a 1σ model ("a model, not a promise", ~68% / two days in three), and the OI tap rule is self-labelled "a rule of thumb, not a measured result". The paid Desk's promised graded result is the trust mechanism; its archive was not in the teardown evidence.

circuit-framework

• product: Open-source crypto-native multi-agent framework (TradingAgents fork) — 12-stage LLM debate pipeline with a deterministic, fail-closed risk engine; live analysis + forward paper simulation on Hyperliquid data.
• surfaces: CLI (tradingagents crypto analyze BTC); no hosted dashboard, community, or feed evidenced.
• unit: A structured CryptoTradeProposal — LONG / SHORT / NO_TRADE with entry, stop and take-profit — as approved, rejected (named reason), or sized by the risk gate; paper fills are SQLite-simulated.
• cadence: On-demand live snapshot per run; no backtest harness exists.
• mode: Pull — user runs the analysis.
• curation: Hybrid — LLM Trader proposes after 5 analysts and two debates; deterministic risk engine is the final authority and NO_TRADE is preserved end-to-end, never converted.
• free_surface: The whole repo, incl. 7 YAML strategy profiles that differ only in analyst weights, prompt overlay and risk knobs.
• paywall: None; user brings LLM keys. It never calls the Hyperliquid exchange endpoint and never requests wallet credentials.
• conversion: None evidenced.
• actionability: Complete on paper: missing entry/stop/TP, stale snapshot (>180s), R:R < 1.5, spread > 30 bps, or confidence < 0.50 all reject; sizing is risk-budget ÷ stop distance, capped at 10% position / 3.0 leverage / 1% loss-at-stop, with volatility and confidence scalars. Caveat from the verification pass: strategy-profile minimum_confidence (0.58 / 0.60) is a dead knob — the gate enforces only its hardcoded 0.50.
• trust_record: No performance claim is made anywhere — no backtest, no returns, which the audit credits. Forward evaluation exists as machinery (MFE/MAE, stop/TP hits, BTC buy-and-hold benchmark, unresolved entries preserved), not as a published record. Indicators read the forming candle, so live numbers are as-of-now, not confirmed-bar values.

correctionscope-ai

• product: A single-file MT5 indicator (387 lines, MIT) — CorrectionScope AI v1: correction probability, fractal wave detection, HUD dashboard.
• surfaces: MT5 chart only; distributed as source via GitHub. No web, app, community, or alert surface evidenced.
• unit: A probability line (0–100% per bar: RSI-divergence slope + volume drop vs 20-bar SMA + engulfing/doji patterns), a correction rectangle when a wave confirms, and a HUD probability reading.
• cadence: Real-time, per bar on the attached chart.
• mode: Push-visual on the chart — it draws on the customer's chart; nothing is sent anywhere.
• curation: Algorithmic only; no human selection.
• free_surface: Everything — full source under MIT is the product.
• paywall: None.
• conversion: None evidenced.
• actionability: Low: a probability score and a rectangle, with no entry, stop, or target specified in the teardown — the customer must supply the entire trade decision. The HUD unit is also broken as shipped: the write loop never writes buffer[0], so the dashboard probability displays the init value 0.0, not the live reading.
• trust_record: Headline claim "No Repainting Guarantee… using confirmed data only" REFUTED — wave confirmation at index 1 uses the forming bar as its confirming bar, so the wave, rectangle and HUD signal can un-confirm (classic 1-bar fractal repaint). The probability math itself is backward-looking and honestly framed as statistical estimates; RSI/ATR/wave presence CONFIRMED.

crypto-claude-desk

• product: A Claude Code plugin that turns the host into a crypto trading desk — 7 specialist agents, 9 Python MCP servers (~96 tools), SQLite paper trading with a learning loop. Paper only, no real-money path, no API keys required.
• surfaces: Claude Code host (agents as markdown/YAML, file-based phased coordination); local dashboard with an embedded terminal (loopback only per its own warning); public data APIs (CoinGecko, CCXT exchanges, Binance futures, Polymarket, DefiLlama, Fear & Greed).
• unit: An agent verdict — EXECUTE / WAIT / REJECT from the portfolio manager — built on a technical signal in the form BUY/SELL/HOLD + strength/10 + entry/TP/SL + R/R; deterministic generators vote RSI/MACD/MA alignment with weighted scores.
• cadence: On-demand phased runs (daily timeframe by default for indicator/backtest paths).
• mode: Pull — user invokes the desk inside Claude Code; no external push feed.
• curation: Hybrid, LLM-dominant: a 5-agent pipeline (monitor → technical → news-sentiment → risk → portfolio manager) synthesises; EXECUTE requires multiple aligned signals and R/R ≥ 2:1 (futures) / 3:1 (spot), max 3 open trades, max 50% allocated. Two runs on identical inputs can differ.
• free_surface: Whole plugin is open; data calls are public/unauthenticated. The paid dependency is external: a Claude Code host + subscription, without which it is inert prompt files.
• paywall: None in the product itself.
• conversion: None evidenced; token-saving claims (40–60%) are UNVERIFIABLE with no benchmark in repo.
• actionability: High in form — entry/TP/SL and R/R gates are part of the unit, plus spot-vs-futures dual-book rules and a Polymarket-priced veto (thesis catalyst <30% downgrades, <15% with outflows rejects) — but discretionary in substance, since the final call is LLM synthesis.
• trust_record: The record is a self-kept learning database: per-setup-type track records (7d/30d/90d/global), pattern library with SEEK >60% / AVOID <40% win-rate gates, and written post-mortems per prediction — an internal scoreboard, not a published or audited one. Its only backtest harness is a 3-strategy toy with same-bar-close fills and no fees/slippage. Marketing counts are stale: 83/95 tools claimed vs 96 in code, "6 MCP servers" in docs vs 9 shipped.

guardian-ftmo-swing-free

• product: A cTrader cBot — Guardian FTMO Swing: an 8-strategy multi-market swing portfolio with prop-firm loss guards, sold as a $1 backtester-only Free edition and a paid live edition (from $120 one-time).
• surfaces: cTrader Store (product 4616, published 2026-10-09) + cTrader platform; vendor site labelling figures and separating backtest from demo forward tracking (Myfxbook-linked).
• unit: The bot itself — a sealed .algo binary with a 103-parameter panel; in the Free edition the received unit is a reproducible backtest (published recipe: m1 data, Jan 2021–Aug 2026, 80,000 start, additive sizing), in the paid edition it is autonomous execution.
• cadence: Continuous swing operation in the paid edition; the audited record is one long backtest window, not a per-day delivery.
• mode: Push in the paid form — the bot trades without per-trade customer action; pull in the Free form — the customer runs the backtest.
• curation: Algorithmic, sealed — 8 vendor-mined strategies (styles/timeframes labelled on the panel, e.g. "S01 — Volatility Trend — 8h"); no formula, indicator set, or entry/exit rule is public.
• free_surface: The $1 edition is stated to be the same engine, same 8 strategies, same parameter panel, differing only in refusing live/demo order placement — plus the full reproduction recipe on the listing.
• paywall: Exactly at execution: research/backtesting is nearly free; placing orders requires the paid edition.
• conversion: Falsify-before-you-pay funnel — reproduce the headline on the $1 edition, then upgrade to the same engine unlocked; sibling listings (Edge, Balanced, Pegasus Gold) cross-sell the same engine family; store rating 4.73/5 on 12 reviews.
• actionability: Total in the paid form — no interpretation step, the bot sizes and executes under daily/total loss caps; in the Free form the action is verification, not trading.
• trust_record: Vendor-run backtest only: +171.7% ROI, 19.3% CAGR, PF 1.58, max equity DD −4.13%, Calmar 4.69, 46.9% win rate on 2,276 trades, 56 positive vs 12 negative months. Claim audit: all figures internally consistent to the decimal on cross-checks, cost model disclosed (flat 2-pip spread, real commission + swap), figures labelled "Historical backtest" on the vendor site, and a platform Live Stats badge is claimed on the paid sibling listing — but there is no forward record for this book, the current 8 strategies are survivors replayed over the full window (replacement/survivorship inflation, undisclosed in those terms), "13 million backtests" selection is unverifiable by the vendor's own admission, and no FTMO challenge pass record was found. Verdict in teardown: UNVERIFIED-FILES-NEEDED.

helm-agents

• product: Self-hosted web app (NestJS API + React SPA) — a 12-LLM-agent deliberation pipeline producing a five-tier stock rating; an independent reimagining of TradingAgents. It produces opinions, not orders: no execution path.
• surfaces: Web UI with real-time streaming timeline (NDJSON), run persistence in SQLite, Markdown export of the full reasoning; DEMO mode with a stub LLM, no key needed.
• unit: A run report for one (ticker, trade date): Buy / Overweight / Hold / Underweight / Sell rating with executive summary, thesis, and optional LLM-written entry price, stop loss, position sizing (free text) and price target.
• cadence: On-demand per analysis; no schedule or feed.
• mode: Pull, with push-style streaming of agent progress during the run.
• curation: Pure LLM text — 4 analysts → bull/bear debate (default: one statement + one rebuttal) → research manager → trader → aggressive/conservative/neutral risk debate → portfolio manager. There is no indicator math anywhere: the default vendor's "indicators" payload is the last 10 raw daily closes, while the prompt asks the analyst to select up to 8 indicators from it; news/fundamentals inputs are stubs under default config.
• free_surface: Open source (Apache-2.0) + DEMO mode running the full pipeline keyless.
• paywall: None for the software; user supplies LLM provider keys (21 registered; azure/bedrock listed but throw not-implemented).
• conversion: The funnel is affiliate, not subscription: README top fold and every run-detail page carry "20%+ fee rebate trading tokenized stocks via our referral codes" with invite codes and a sponsor — the product monetises routing its users to trade elsewhere.
• actionability: Low: a rating plus free-text numbers from the LLM — no sizing formula, no risk %, no kill switch, nothing executable without the customer's own system.
• trust_record: No published record and no backtest harness at all. Its one honest time module (hold-period returns vs benchmark, nearest close at-or-before date) is undermined by the main path: tradeDate is accepted as an input and silently ignored by every vendor, so a run dated 2023 analyses with current data — future-leak FAIL — and the forming daily bar is consumed and labelled "Latest close" — repaint FAIL. Claim audit: "13 agents" REFUTED (12 registered; its own header miscounts), "technical indicators" REFUTED, five-tier rating and AES-256-GCM key storage CONFIRMED.

hypergrok-trading-desk

• product: A prompt-pack desk-operations manual for Hyperliquid perps — 7 agent system-prompt profiles + 17 discipline skill docs for running a 7-bot desk inside Grok Bot / Claude Code / Cursor, plus two read-only Python tools. It ships zero strategies by explicit design.
• surfaces: Host LLM platforms (Grok Bot / Claude Code / Cursor); GitHub / npm distribution and bot-directory listings; Hyperliquid public /info reads, /exchange writes only via the approved signed path.
• unit: A trade ticket the user must approve by exact ticket id, an opening-bell read (order-book depth bands), or a REVIEW block (plan-vs-fill, costs, protection verified from the exchange record, process judged separately from outcome). The one numerical rule in the repo (a funding-fade) is presented as a format example, not a claimed edge.
• cadence: On-demand / opening-bell; testnet rehearsal required before any new action type on mainnet.
• mode: Pull with a hard human push-gate — standing approval for a mainnet send that opens/increases exposure is "never"; the limits file may only tighten ceilings, never loosen them.
• curation: LLM agents under deterministic doctrine: unreducible ceilings (2% per-trade / 6% total open risk / 20x leverage / −10% daily loss stop), stressed-stop sizing (size from stop-fill distance + fees), reservation accounting so parallel tickets cannot spend the same capacity, correlated-cluster caps.
• free_surface: The whole pack (MIT) — starts read-only on public data, no keys loaded by its scripts.
• paywall: None; user brings host platform, own trade-only (non-withdrawing) API wallet.
• conversion: No pricing funnel evidenced; community/directory presence and a pump.fun community support claim (UNVERIFIABLE) are the distribution layer.
• actionability: High as process, empty as signal: execution, reconciliation-from-exchange-record (never from a plan file, chat message or screenshot), and an unknown-result no-retry protocol are fully specified — but the customer must still bring or build every strategy.
• trust_record: No return/profit claims anywhere, expressly ("documentation and instructions, not financial advice"; "No annualised return headline"). Its flagship honesty promise — backtests done honestly, with OOS holdback, holdout-read counter, multiplicity correction, block-bootstrap and sanity checks — is doctrine in prompts, not an executable harness, so it is UNVERIFIABLE; compliance is whatever the host LLM does. Changelog shows real maintenance, including fixes to its own doctor's honesty checks.

oft3r-agentic-trading-desk

• product: Open-source AI-agent-operated daily technical-analysis desk — an LLM fetches Robinhood daily bars via MCP, three stdlib-only Python scripts compute a deterministic indicator stack, and a three-pillar vote drives short-term equity/ETF rotation decisions under an autonomous execution mandate.
• surfaces: Local agent host + Robinhood MCP (historicals/quotes/positions/portfolio/orders); best-effort web fetches (Investing.com 10Y-2Y spread, Google Finance consensus pages); a shell order-guard hook. No hosted dashboard or community evidenced.
• unit: A daily session scorecard: Trend / Momentum / Macro-Sentiment pillars each −2…+2 (EMA structure votes; Wilder RSI-14 / MACD histogram / TRIX votes; six-ratio cross-asset macro composite), named exhaustion/rebound/bearish flags, and one of nine decisions — EXIT / TRIM, RE-ENTRY, TACTICAL REBOUND, HOLD / WAIT / STAY OUT / OBSERVE.
• cadence: Daily, documented as an after-close scheduled flow (today's close appended from the official closing print, asserted against the prior bar).
• mode: Push within the mandate — autonomous execution is authorised without in-the-moment confirmation (its README's "user decides and approves" claim is REFUTED by its own mandate docs, as is "discretion is deliberately absent": discretionary entries superseded that rule in Aug 2026 per the docs).
• curation: Hybrid — deterministic vote engine is the baseline, but the mandate authorises discretionary trades the cascade does not cover, so observed behaviour confounds engine and operator.
• free_surface: Whole repo (MIT), stdlib-only with zero network calls in its own code.
• paywall: None.
• conversion: None evidenced.
• actionability: High in form: the cascade is holding-aware (holders get exit branches first, flat accounts get entry branches), with mandate limits ($1,200 max/order, max 3 new positions/session, ≥15% cash reserve, −4% daily circuit breaker on new buys, GFD only, no stops) and a fail-closed order guard (denies stop orders, enforces RTH-market / off-hours-limit, denies >$1,200, denies when jq is missing). Enforcement is uneven: circuit breaker, pre-order simulation check and the protected-position list are prose-only with no code, and the guard itself is prose-only in installed-skill mode — a gap the docs confess, including three unguarded orders in Aug 2026.
• trust_record: No backtest, no trade history, no performance data — and the author says so in the README guardrails ("This framework has not been backtested"; a trigger firing does not make it correct). Repaint/future-leak PASS in the documented after-close flow; running it intraday would score a forming bar. Claimed math test cases are UNVERIFIABLE (no tests shipped) though the scripts' built-in self-tests run as designed.