██╗ ██╗██╗███╗ ██╗ ██████╗███████╗
██║ ██║██║████╗ ██║██╔════╝██╔════╝
██║ ██║██║██╔██╗ ██║██║ █████╗
╚██╗ ██╔╝██║██║╚██╗██║██║ ██╔══╝
╚████╔╝ ██║██║ ╚████║╚██████╗███████╗
╚═══╝ ╚═╝╚═╝ ╚═══╝ ╚═════╝╚══════╝
The durable edge is not a better opinion. It is a better process. — We Built the Machine (Substack)
Short-term monitoring terminal — OI, funding rates, L/S ratios, portfolio drift, Mando Minutes news, Hyperliquid tickers. Solus runs the weekly Hypersurface options ritual. Forge self-optimizes overnight on Apple Silicon. Part of a three-layer stack: VINCE (hours→weeks), Dexter (months→years, thesis engine), AIHF (cycle-scale, 18-analyst second opinion).
v2 refactor in progress. v2 core = four agents: VINCE data, Solus, Otaku, Forge. Six agents are moving to other machines. Run the v2 slim roster today with env flags — no code changes required. See Agent Roster.
Mac mini 247 is the operating rule: run the VINCE + Dexter + AIHF stack 24/7 on a single trusted machine, and treat “production deployment” as something we do only when it is required for distribution (GTM) or real funding-backed operations.
- The durable edge is process, not infrastructure.
- The system’s value is in the loop staying unbroken: VINCE monitors, Solus runs weekly, Forge improves overnight, Dexter refreshes sleeves, and AIHF challenges conviction.
- When we have no GTM and no funding, production-grade hardening mostly adds ceremony and failure modes, not alpha.
- The machine is always on, always reachable locally, and always running the core processes.
- You assume the machine will be the operator interface most days: terminal + dashboard + a small set of deterministic scripts.
- The goal is not “perfect uptime”; the goal is “fast recovery with clear operator signals.”
- Keep the app surface local while we are in 247 mode: bind access to your LAN (or localhost) and do not expose spend-triggering endpoints to the public internet.
Run the v2 slim roster on the Mac mini by default (4-agent core). Gate other agents out with env flags instead of moving code around.
ELIZA_ENABLED=false KELLY_ENABLED=false ECHO_ENABLED=false \
SENTINEL_ENABLED=false CLAWTERM_ENABLED=false \
ORACLE_ENABLED=false NAVAL_ENABLED=false bun start- VINCE (this repo): short-horizon monitoring, paper-bot gating, emits regime bundle artifacts for Dexter operators.
- Dexter: thesis and canonical sleeve artifacts; it is the source of truth for membership and portfolio composition.
- AIHF: adversarial second opinion; VINCE consumes Phase D to apply the conviction gate.
On Mac mini 247, everything important is a contract:
- Dexter artifacts are read from
DEXTER_ARTIFACT_ROOTand must exist as real files. portfolio_hyperliquid.jsonportfolio_tastytrade.jsonportfolio_watchlist.json- VINCE writes
regime_bundle_v1.jsoninto Dexter’s artifact root (orREGIME_BUNDLE_OUT_PATHif configured). - VINCE applies the AIHF Phase D conviction gate during the paper-trade loop.
If a contract breaks, you fix the contract wiring, not the narrative.
- We do not build a public-facing production surface.
- We do not rely on “someone might call the server correctly” as a safety mechanism.
- We do not pay the ongoing cost of edge allowlists, API gating review, and health-probe ops until distribution or funding requires it.
When we do go prod, we follow the Roy production checklist in docs/PROD_STACK_SINGLE_SOURCE_OF_TRUTH_ROY.md, including the API gating and verification scripts.
- Open the dashboard and scan the “Monitor the Situation” signals.
- Run a quick sanity check on portfolio state (the three ground-truth JSON files displayed via Dexter artifact sync).
- Ask for
drift/dexter driftto confirm the paper-vs-Dexter universe relationship. - Verify Forge completed its overnight run (or at least didn’t silently stall).
- Verify VINCE produced the expected downstream artifacts for the Dexter operator workflow.
- If something looks off, fix the contract or the inputs first (artifacts present, permissions correct, env vars correct).
After that, you stop. The point is to keep mechanical work out of your day.
- Weekly cadence (Solus ritual): ensure the weekly workflow ran without gaps; it is part of the core loop.
- ONNX / ML training: only when the feature-store gates are satisfied, and ideally after you check for obvious data issues.
- Portfolio cache prewarm: prewarm Financial Datasets cache when you are about to do discovery-heavy work.
Use the scripts already listed in this README; the rule is simple: don’t run the heavy stuff because you feel anxious, run it because the loop needs it.
- Treat failures as “operator signals,” not “mysteries.”
- When something fails, you answer one question: which contract failed (inputs missing, artifacts stale, model files missing, or a gate not applied)?
- Prefer restarting the loop with the same environment before making architectural changes.
If you’re debugging a prod-like failure later, the relevant production wiring guidance is in:
docs/API_SECURITY_AND_PRODUCTION.mdscripts/verify-api-gating.sh
But for Mac mini 247, the immediate checklist is simpler: do the contract checks and confirm the loop continues.
Each layer has a distinct time horizon, operational cadence, and job. Understanding which layer answers which question — and how often you run it — is the most important thing about working with this system.
| Layer | Repo | Time horizon | Cadence | Primary job |
|---|---|---|---|---|
| Layer 1 | VINCE (this repo) | Hours → weeks | Daily | Monitor the situation. Watch OI, funding, L/S ratios, portfolio drift, Mando Minutes, Hyperliquid tickers. Execute Solus options ritual. Surface signals that require immediate action. Run Forge overnight. |
| Layer 2 | Dexter | Months → 2–3 years | Weekly | Hold the thesis (SOUL.md). Build the two active sleeves (tastytrade + Hyperliquid). Re-underwrite when VINCE surfaces a regime shift. Publish scorecard.json and canonical portfolio files. |
| Layer 3 | AIHF | Cycle-scale | Monthly / Quarterly | 18-analyst second opinion. Challenge the thesis. Run conviction scoring. Find the blind spots before they find you. |
| From | To | Artifact | Purpose |
|---|---|---|---|
| Dexter | VINCE | scorecard.json, portfolio_*.json |
Canonical Top100 membership, scoring, sleeve weights. VINCE reads these as ground truth. |
| Dexter | VINCE | cache_dexter/ |
Historical API responses (prices, earnings, insiders, company facts). Reduces API cost; imported into .elizadb/financialdatasets-cache/ when VINCE_DEXTER_CACHE_IMPORT=true. |
| AIHF | VINCE | portfolio_draft_top100.json, portfolio_draft_tastytrade_full.json, portfolio_draft_hyperliquid_full.json |
Compare/staging artifacts for the Top100 tab. Show overlap and weight differences vs canonical. Never redefine membership, rank, or scores. |
| VINCE | Dexter | portfolio_watchlist_candidates.json, discovery runs |
Newly surfaced names (X, filings, broad FD screen). Staging inbox — Dexter promotes into sleeves. |
VINCE + Dexter + AIHF are connected by explicit artifact contracts and a pre-trade conviction gate:
- Dexter → VINCE (UI + monitoring): VINCE reads
portfolio_hyperliquid.json,portfolio_tastytrade.json, andportfolio_watchlist.jsonfromDEXTER_ARTIFACT_ROOTand shows them in the dashboard (Charts/Watchlist). - VINCE → Dexter (regime handoff): VINCE emits
regime_bundle_v1.jsonfor Dexter operators (and we havescripts/verify-regime-bundle-v1.tsto validate it locally). - AIHF Phase D (equity-only conviction gate): VINCE reads
values.aihfSecondOpinionand applies an equity-only dampener/booster inVincePaperTradingService.evaluateAndTrade():- contradiction: cap
tradeSignal.confidenceto50 - agreement: boost
tradeSignal.strengthslightly - always: append an
AIHFfactor into the trade reasons/signals
- contradiction: cap
For Roy’s end-to-end production checklist, sign-off steps, and remaining review items, see docs/PROD_STACK_SINGLE_SOURCE_OF_TRUTH_ROY.md.
Each layer has a different failure mode:
- VINCE failure = missed executions. The thesis is right, the machine is running, but no one is at the terminal when the window opens. Twelve weeks of uncollected Solus premiums. An airdrop T&C window that expired.
- Dexter failure = wrong thesis. Monitoring is active but the conviction map is stale.
- AIHF failure = blind spots. The thesis and monitoring are both internally consistent but unchallenged.
The three layers are designed to catch each other's failure modes.
This is VINCE's primary job. VINCE doesn't wait to be asked. It watches, and when something changes that requires attention, it tells you. Before any trade, before any options ritual, before any Forge run — the terminal reads the situation. One standout: stock discovery from 17,000+ US tickers (Financial Datasets) down to a ranked shortlist — screen broadly, enrich only survivors, explain why each name made the list. See Gem Ticker Discovery — 17k → shortlist below.
Portfolio state — three JSON files are the ground truth (see docs/DEXTER-PORTFOLIO-SYNC.md):
portfolio_hyperliquid.json— on-chain positions: weights, drift vs target, margin risk.portfolio_tastytrade.json— current tastytrade sleeve. VINCE surfaces which regime we're in.portfolio_watchlist.json— staging pipeline. VINCE flags when a watchlist name crosses a threshold.
Ask "drift" or "dexter drift" for a paper-vs-Dexter-universe report. Guardrails (leverage caps, PTQG): docs/GUARDRAILS.md.
Financial Datasets insights + cache (tastytrade/watchlist):
- Configure Cursor MCP connector for Financial Datasets (OAuth) so chat can pull live fundamentals/news for those sleeves.
- Prewarm historical prices once with
bun run fd:cache:portfolio(readsportfolio_tastytrade.json+portfolio_watchlist.json). - Optional autoprewarm task: set
VINCE_FD_CACHE_PREWARM_ENABLED=true(with interval/age envs) to keep cache fresh in runtime. - Cache files live in
.elizadb/financialdatasets-cache/; reruns are cache hits unless you use--force. - Ask
cached history <TICKER>orfd cache <TICKER>for cache-first historical stats from local files. - Setup + details: docs/FINANCIAL_DATASETS_MCP_CACHE.md.
Perps data feed (free-tier APIs) — VINCE data agent pulls continuously:
- Open interest by asset — rising OI in the direction of the trade is confirmation
- Funding rates — extreme positive = crowded longs, extreme negative = crowded shorts
- Long/short ratios — retail vs institutional divergence
- Liquidation heat maps — where forced exits are clustered
- 24h volume and volatility — unusual activity before Solus writes a strike
Mando Minutes — morning news feed. VINCE ingests and flags items that touch the SOUL.md thesis: BTC regime signals, equipment capex, power policy, semiconductor revisions.
Hyperliquid tickers — unusual moves in any portfolio ticker get surfaced immediately. Correlation breaks and sector rotations are the first signal a re-underwriting may be needed.
Leaderboard → Charts tab: TradingView blocks for BTC/core pairs, Hyperliquid sleeve (portfolio_hyperliquid.json), Watchlist (portfolio_watchlist.json), and Tastytrade (portfolio_tastytrade.json).
Gem Ticker Discovery — 17k → shortlist — This is where VINCE flexes. Financial Datasets covers 17,000+ US public companies (30+ years, 100% SEC filers). We don’t just rank a hand-picked list: we screen the broad universe, enrich only survivors, then rank. Result: a shortlist of names worth tracking, watching, and adding — with clear reasons and a falsifiable loop.
- Universe modes: Sleeve (tastytrade + watchlist only), Curated full (sleeve + peer + expansion JSONs), US broad (symbol master from FD or
fd_symbol_master.json— US exchange–listed for tastytrade tradeability). SetVINCE_FD_DISCOVERY_UNIVERSE_MODE=us_broadand (optionally) provide a symbol list; otherwiseVINCE_FD_DISCOVERY_FULL_UNIVERSE=trueuses curated full. - Two-stage funnel: Stage 1: price-only coarse screen (min price, min dollar volume, min history) over the full candidate set. Stage 2: enrich only top N (fundamentals, filings, earnings, insiders, snapshots). So: 17k → screened → ~1k enriched → ranked shortlist. Bounded concurrency in prewarm; coarse screen and metrics written so the UI can show “X screened → Y enriched → Z ranked.”
- Gem scoring: Cohort-relative momentum, sector-relative when available, plus subscores (sleeve-fit, momentum/trend, catalyst/event, valuation/quality, diversification, regime). Structured explanations per ticker: Momentum, Quality, Event, Liquidity, Portfolio fit — so the operator sees why a name made the list in a fixed, comparable format.
- Resolvable runs: Each run writes outcomes-ready history (pick-time fields,
discovery-candidates-history.jsonl,discovery-resolved-outcomes.jsonl) and discovery-metrics.json (screened/enriched/ranked counts). Resolution uses FD cached daily bars and nearest-trading-day logic. - Stocks tab (Leaderboard): Decision layer: Add now (PromoteNow), Research next (ResearchNext), Avoid, Net-new from the full run. Filters: View (All / Net-new only), Universe (Sleeve / Full). Pipeline line when metrics exist: “X screened → Y enriched → Z ranked.” Calibration, resolved outcomes, false positives, and promotion policy live in a collapsible Details section. Output goes to
portfolio_watchlist_candidates.json; live portfolio files are never auto-edited. - Tastytrade alignment: Candidates can show tastytrade-style tags (Earnings catalyst, High liquidity, Sector: Technology, etc.) so the flow blends with our premier execution partner’s preset watchlists (Earnings, Liquid Symbols, Sector Watchlists). Glossary and mapping: docs/TASTYTRADE_WATCHLIST_GLOSSARY.md.
Why it matters: Most systems rank a small, curated set. Here you start from the same 17k+ US universe FD uses, filter hard, enrich only what passes, then rank. The value is visible in the UI (screened → enriched → ranked) and in the reasons (Momentum / Event / Quality / Liquidity). Same harness idea as Forge: one search surface, fixed evaluation, keep/reject, so the system can improve over time without babysitting.
Two paths solve different problems: saving many tweets vs turning one source into tracked trade cards.
- You hit bookmark on posts that look like alpha (charts, setups, threads). Nothing runs until you choose to process them.
- You run the pipeline (CLI
bun run x-bookmarks:fetch, or chat with VINCE and ask to run the X bookmarks pipeline whenX_BOOKMARKS_PIPELINE_ENABLED=true). The Rust job inpackages/x-bookmarks-pipelinepulls bookmarks, labels finance vs not, and for trade-relevant ones produces Pine Script plus.meta.jsonunderdata/x-bookmarks-pipeline/output/(see docs/X-BOOKMARKS-PIPELINE.md). - You get artifacts you can open: TradingView-style scripts, a short digest at
data/x-bookmarks-pipeline/digest/latest.md, and—if the ticker maps to something the paper bot trades—a line inpaper-signals.jsonl. - On the next paper-bot cycle, VINCE treats those lines as a soft vote (
XBookmarksin the signal mix). It nudges direction/confidence for matching assets; it does not bypass the rest of the stack (funding, regime, gates). Think “remember what I saved”, not “YOLO because I bookmarked it.”
Operator takeaway: Bookmarks are your inbox of intent. The pipeline turns that inbox into reviewable code + structured fields and optionally feeds the paper sim. Live execution (Otaku / real money) stays a separate decision.
paste.trade is for: I have this URL or block of text—extract the trade ideas, compare instruments, lock prices, and show me cards I can follow.
- Input: Paste a link (tweet, article, video, PDF) or type a thesis in chat when paste.trade is enabled. The key is usually auto-provisioned by the skill (see
.env.exampleand docs/PASTE_TRADE.md); runbun run packages/paste-trade/scripts/onboard.tsonce if needed, then restart the server. Details: packages/paste-trade/README.md. - What you see: A source page that streams progress; thesis cards appear, then resolve with explanation, optional comparison table, and prices (author time vs when you posted to paste.trade).
- Why use it: You get auditable, tracked ideas with P&L context from defined entry prices—not just a chat reply that disappears.
How the two fit together
| You want to… | Primary path |
|---|---|
| Capture many X posts over time and batch them into Pine + paper-bot nudges | X bookmarks pipeline + paper-signals.jsonl (docs/X-BOOKMARKS-PIPELINE.md) |
| Turn one piece of content into explicit trade cards and a living profile | paste.trade flow (packages/paste-trade/ARCHITECTURE.md — create → enrich → save → route → post) |
Same research habit on X; different product surfaces depending on whether you are harvesting bookmarks or publishing a single source into trade objects.
Four core agents run always. Six v1 agents are moving to other machines — gate them out with env flags, no code changes required.
| Agent | Role | What it does |
|---|---|---|
| VINCE | CDO | Perps data feed: OI, funding, L/S ratios, liquidations. Portfolio drift across the three JSON files. Mando Minutes ingestion. The eyes of the system. |
| Solus | CFO | Weekly Hypersurface options — strike ritual, optimal strike, assignment probability (GBM + ML Brier calibration), tail risk, portfolio copula. Core use case. |
| Otaku | COO | On-chain identity (ERC-8004), reputation from Solus Brier scores, x402 skill endpoints. Only agent with a funded wallet. |
| Forge | — | MLX AutoResearch. Overnight experiments on Apple Silicon: mutate policies/trading-policy.yaml + prompts + ML hyperparameters → evaluate against paper-bot replay → commit winners (ΔComposite ≥ +0.5%), revert losers. Push Telegram summary at 2 AM UTC. Silent by default. |
v2 slim mode — run just these four agents:
ELIZA_ENABLED=false KELLY_ENABLED=false ECHO_ENABLED=false \
SENTINEL_ENABLED=false CLAWTERM_ENABLED=false \
ORACLE_ENABLED=false NAVAL_ENABLED=false bun startGate each out with <NAME>_ENABLED=false. All default to true for backward compatibility.
| Agent | v2 destination | To disable |
|---|---|---|
| Eliza | (1) Perplexity Computer research skill + (2) AIHF Substack writing assistant | ELIZA_ENABLED=false |
| Kelly | OpenClaw / Nemoclaw portable lifestyle skill (runs 24/7 on a daemon) | KELLY_ENABLED=false |
| Echo | Dexter thesis-layer skill — X alpha feeds conviction, not perps | ECHO_ENABLED=false |
| Sentinel | Claude Code agent skill | SENTINEL_ENABLED=false |
| Clawterm | Claude Code agent skill | CLAWTERM_ENABLED=false |
| Oracle | Stub only — Polymarket never produced real edge | ORACLE_ENABLED=false |
| Naval | Evaluate → Dexter SOUL.md review layer | NAVAL_ENABLED=false |
Forge is VINCE's MLX-powered AutoResearch layer. It runs on Apple Silicon while the rest of the system sleeps and gets smarter without manual steps.
Composite metric: causal_uplift × Sharpe × brier_calibration
All three must improve together. A threshold change that boosts Sharpe but hurts Solus calibration or causal uplift does not ship. Same proof bar as the rest of the system.
Mutable surfaces:
- Phase 1 (live):
policies/trading-policy.yaml,prompts/vince-entry-gate.md,prompts/solus-strike-ritual.md - Phase 2 (≥90 feature-store rows):
train_models.pyhyperparameters, Thompson Sampling priors - Phase 3 (with human approval): agent
style.all— Otaku mutations require explicit confirmation
The nightly loop:
- Trigger at
FORGE_NIGHTLY_HOUR_UTC(default 2 AM UTC) - Read
SOUL.mdfor investment thesis context — experiments that contradict the thesis get a 0.8× alignment penalty - Generate up to
FORGE_MAX_EXPERIMENTSmutations (default: 10) - Run each against paper-bot replay; score on composite metric
- Safety gate: ΔComposite ≥ +0.5%, drawdown ≤ 15%, win rate ≥ 45%, max leverage ≤ 40, max single trade ≤ $50K
- Winners →
git commitonforge/experiment-YYYYMMDD-NNN; losers →git checkout --revert - Push Telegram summary to
#forge/#opschannels
Forge Ops card (Leaderboard): In the dashboard Leaderboard → Markets tab, a Forge Ops card shows deterministic replay gate status (holdout, trigger count, win-rate) and metrics (Sharpe, Brier, cache size) from the signal cache. Branch and policy hash are shown for context. Use it to see at a glance whether promotion gates would pass.
Harness, not open-ended freedom: Forge and Gem Ticker Discovery both follow the same principle as autoresearch-mlx (our Apple Silicon port of Karpathy’s autoresearch): the agent is useful when the harness is tight. One mutable surface (policy + prompts vs train.py), one metric (composite vs val_bpb), fixed evaluation (replay vs 5‑min run), keep/revert on the score, and explicit failure handling. The impressive part is not that an agent can edit code or rank tickers; it is that the environment makes those edits measurable, discardable, and repeatable without babysitting.
Promotion gate enforcement: A shared hard promotion validator runs before every winner commit. No experiment is committed unless all gates pass (ΔComposite, win rate, drawdown, leverage, holdout/trigger data). Explicit reject reasons are recorded per loser and surfaced in the nightly summary, on-demand run output, and the Forge job ledger (bun run forge:jobs-tail shows a rejectReasons column when present).
Low-data remediation: When holdout or trigger gates fail (e.g. too few labeled outcomes), Forge runs auto-remediation: (1) FD cache health check and optional prewarm (financialdatasets-cache), (2) paper-bot activity diagnostics from ops summary or runtime, (3) a structured insufficient-data alert pushed to rooms named ops or forge, with fallback to sentinel. This runs from the daily report task and from the nightly/on-demand experiment path when the run is skipped for low data.
Runtime: MLX on Apple Silicon (300–600 experiments/hour). Falls back to train_models.py on CPU when MLX unavailable.
Three improvement loops now run without manual steps:
| Loop | Cadence | Optimizes |
|---|---|---|
| ML loop | Every 12h (90+ closed trades) | Model weights, signal thresholds, TP/SL |
| Strategy genome | Weekly | 15+ algo parameters (Sharpe + drawdown) |
| Forge | Nightly | Policy thresholds + prompts + hyperparams |
trades → feature store → [ML loop: train → ONNX → deploy]
↓
[Forge nightly: mutate policy + prompts → replay → commit winners]
↓
composite metric improves → both loops compound on each other
Research charter: docs/FORGE_PROGRAM.md · Agent brief: docs/FORGE.md
The architecture in Three Loops That Never Sleep is implemented end-to-end. These eight pieces close the gap between the essay and the codebase:
| # | What | Where |
|---|---|---|
| 1 | Prompt templates at runtime | Entry gate and Solus strike ritual load prompts/vince-entry-gate.md and prompts/solus-strike-ritual.md at invocation (inline fallback if missing). Forge’s prompt mutations affect live behavior. |
| 2 | Prompt mutations in Forge | generatePromptMutations() and applyPromptMutation() in the experiment service; bounded parameter changes in those files are in the nightly experiment pool with policy mutations. |
| 3 | SOUL.md thesis alignment | Experiments that contradict the thesis get a 0.8× multiplier on the composite; thesis_alignment is stored on results and in the Forge job ledger. |
| 4 | Causal uplift | Replay uses a rule-based baseline (equal weights, no ML). Composite uses causal_uplift = candidate_win_rate - baseline_win_rate so the metric reflects causation, not correlation. |
| 5 | Genome composite | Strategy genome fitness is the same multiplicative composite as Forge: causal_uplift × Sharpe × (1 − Brier). Drawdown and trade count stay as hard gates. |
| 6 | Guardrails enforced | ASSET_CLASS_MAX_LEVERAGE is enforced in validateTrade(); paper-trading and bot action pass asset-class caps; guardrail rejections are logged. |
| 7 | MLX in the nightly loop | When FORGE_USE_MLX=true and the MLX service is available, the nightly run uses forgeMlx.runAutoresearch() for the experiment sweep; otherwise TypeScript replay runs. |
| 8 | Composite time-series | After each Forge run, genome evolution, and ML training, a snapshot is appended to data/forge-composite-history.jsonl, data/genome-composite-history.jsonl, and data/ml-composite-history.jsonl for monitoring and charts. |
One composite metric, one precedence order (hard limits → guardrails → policy → ML), and three loops that compound without manual steps.
Solus handles the weekly onchain options strategy on Hypersurface (BTC, ETH, SOL, HYPE). One ask — "optimal strike for BTC" or "strike ritual" — and you get a strike call with assignment probability (GBM closed-form, or ML-calibrated when the ONNX model is trained on resolved predictions).
Self-calibrating: every strike call auto-records a prediction; at expiry you resolve it. Brier score over resolved rows measures calibration. That score and the last 10 outcomes are injected into every subsequent prompt — Solus sees its own track record and tempers confidence when it's been wrong. Friday reminder triggers for resolution. At 50+ resolved rows, a recurring task trains an ONNX assignment calibrator and the context switches to ML-calibrated P(assign).
Tail risk and portfolio assignment risk (Gaussian copula across 2+ positions) are in the same context. TypeScript-only, no extra APIs.
SOLUS.md · plugin-solus/FEATURE-STORE.md · IMPROVEMENT_PROOF.md
The durable edge today is code: repeatable process, broad coverage, zero emotional drift.
Renaissance's Medallion: ~39% annualized since the late 1980s. Berkshire's audited long-run record: ~19.9% annualized in the same period. Medallion won by repeating small statistical edges across many instruments with discipline. Code can monitor thousands of positions, react in milliseconds, and execute the same playbook without fatigue.
Three foundations made this inevitable:
- 1952 — Markowitz proved portfolio construction could be mathematical.
- 1964 — Sharpe introduced CAPM: a way to measure and compare risk-adjusted returns.
- 1973 — Black-Scholes published the options pricing equation — clear inputs, measurable outputs, formulas that adapt with data.
Edward Thorp proved these ideas in live markets. Jim Simons scaled them at Renaissance.
| Level | Name | Edge |
|---|---|---|
| 1 | Manual | Information scarcity. Who you knew, whether you had conviction. |
| 2 | Algorithmic | Pre-defined rules execute automatically. Speed, no learning. |
| 3 | Automated | Integrated workflows: data feeds, portfolio models, execution. Reduced friction. |
| 4 | Autonomous | ML models that update on new data without explicit reprogramming. |
| 5 | Agentic AI | Plans, chooses actions, uses tools, monitors outcomes, self-corrects. |
VINCE v2 targets Level 5 with a tighter surface: Solus as the weekly options workflow, Forge as the overnight self-improvement engine, Otaku as the on-chain identity layer, the paper bot as the causal proof harness. The loop is the same as v1. The agent count is not.
Goal: stay in the game without living on screens. Push, not pull.
bun install
cp .env.example .env # add at minimum OPENAI_API_KEY or ANTHROPIC_API_KEY
bun run build
elizaos dev # hot-reload
# or
bun start # production (Postgres when POSTGRES_URL set)Web UI: bun start serves the API on port 3000 and the frontend on 5173. Open http://localhost:5173 for chat and the dashboard.
v2 slim mode (4-agent core only):
ELIZA_ENABLED=false KELLY_ENABLED=false ECHO_ENABLED=false \
SENTINEL_ENABLED=false CLAWTERM_ENABLED=false \
ORACLE_ENABLED=false NAVAL_ENABLED=false bun startForge config (in .env):
FORGE_ENABLED=true
FORGE_RUNTIME=mlx # mlx (Apple Silicon) | python (CPU fallback)
FORGE_BUDGET_MINUTES=120 # default 5-hour safe nightly window
FORGE_NIGHTLY_HOUR_UTC=2 # default 2 AM UTC
FORGE_TELEGRAM_PUSH=true # push nightly summary to #forge/#opsThe paper bot runs 24/7: 15+ signal sources, 38 onchain assets (crypto, stocks, commodities, indices) as Hyperliquid perps. Every open position shows strength, confidence, sources, and R:R; every close feeds the feature store and ML loop.
Four ONNX models: signal quality, position sizing, TP optimizer, SL optimizer. Rule-based fallbacks keep it running when models are missing. The dashboard's "100 trades processed" is the Weight Bandit (Thompson Sampling) count of closed trades; ONNX loads when you run training and place .onnx files + training_metadata.json in .elizadb/vince-paper-bot/models/.
VinceBench scores every closed trade on process quality (signal, risk, timing, regime). The score trains the signal-quality model to learn more from high-quality decisions.
trades → feature store → [ML loop every 12h: train → ONNX → deploy]
↓
[Forge nightly: mutate policy + prompts → replay → commit winners]
↓
composite metric improves → both loops compound on each other
- Trade → outcomes written to feature store.
TRAIN_ONNX_WHEN_READYruns every 12h; when there are 90+ complete trades, runstrain_models.py(at most once per 24h).- New ONNX +
training_metadata.jsonwritten; on Cloud the task uploads to Supabase and callsreloadModels()without restart. - Forge runs overnight, mutates policy thresholds and prompts, commits winners.
- Next cycle uses updated thresholds, TP/SL from ONNX, and (if
VINCE_APPLY_IMPROVEMENT_WEIGHTS=true) updated aggregator weights.
| Env var | Purpose |
|---|---|
VINCE_ML_SIGNAL_QUALITY_THRESHOLD |
0–1. Override ML signal-quality threshold; lower = more trades. |
VINCE_SWARM_ENABLED |
true/false. Enable swarm consensus gating. |
VINCE_SWARM_MIN_CONFIDENCE |
0–1 (default 0.5). Min swarm consensus to allow a trade. |
VINCE_AGGRESSIVE_MARGIN_USD |
Fixed margin per trade in aggressive mode (default 1000). |
VINCE_AGGRESSIVE_BASE_SIZE_PCT |
Base size as % of portfolio when portfolio < margin (default 12). |
VINCE_PAPER_MAX_SINGLE_TRADE_USD |
Paper bucket cap per trade (default 10000). |
Single-trade cap: The paper bucket and policy rule cap each trade at $10K by default. If you see "blocked by policy engine: max-single-trade-usd" in logs, set VINCE_PAPER_MAX_SINGLE_TRADE_USD to raise it.
bun run train-models -- --bench-score-weight
# or with recency weighting:
bun run train-models:recencyOutput goes to .elizadb/vince-paper-bot/models/. Restart the agent to load the new threshold and training_metadata.json. Optionally: VINCE_APPLY_IMPROVEMENT_WEIGHTS=true bun run improvement-weights to apply source weight changes from the improvement report.
bun run validate-mlLoads feature-store data, computes suggested tuning (Q0.25 of profitable trades), and reports baseline win rate vs filtered win rate.
Full loop: PAPER-BOT-AND-ML.md · ONNX: ONNX.md · Feature store: FEATURE-STORE.md
- ML loop = performance engine. Learns from many trades. Predicts better signal quality, size, TP/SL.
- Post-mortem loop = safety engine. Learns from losses. Applies bounded guardrails, validates, rolls back if results don't improve.
- Forge = policy engine. Searches the threshold/prompt/hyperparameter space nightly. Commits winners as diff-ready branches.
Precedence: hard risk limits → post-mortem guardrails → policy engine → ML optimization inside those limits.
flowchart TD
pmLoss[LossPostMortem] --> guardrails[BoundedGuardrails]
mlTrain[MLTrainingLoop] --> optimize[MLOptimization]
forgeNightly[ForgeNightly] --> policyUpdate[PolicyUpdate]
guardrails --> tradeDecision[FinalTradeDecision]
optimize --> tradeDecision
policyUpdate --> tradeDecision
The north star is not a specific return target. It is a specific operating state: the portfolio reflects the thesis at all times, the options premium machine runs weekly without gaps, and the three improvement loops compound overnight without supervision. The human is freed from the mechanical work of executing a plan that is already built.
On Hyperliquid — HIP-3 compliant sleeve: concentrated AI winners and financial rails (NVDA, TSM, MSFT, META, AMZN, GOOGL, PLTR, ORCL, COIN, HOOD). Position weights in portfolio_hyperliquid.json; drift monitored by VINCE; Solus writes weekly options on Hypersurface for premium income.
On Tastytrade — AI infrastructure bottleneck sleeve (ASML, AMAT, KLAC, LRCX, SNPS, CDNS, ANET, AVGO, VRT and extensions). Positions in portfolio_tastytrade.json; rebalanced by SOUL.md conviction tiers and regime.
Division of labor: The machine monitors. The machine executes. The machine improves overnight. The human holds the thesis, challenges the machine, and writes the record. Weekly and quarterly Substack reports are the accountability layer — thesis stated clearly, decisions explained, outcomes accounted for.
| Script | Purpose |
|---|---|
elizaos dev |
Hot-reload development |
bun start |
Production start (all agents) |
bun run deploy:cloud |
Deploy to Eliza Cloud |
bun run sync:supabase |
Backfill features to Supabase |
bun run db:check |
Verify DB migrations |
bun run train-models |
Train ML models (min 90 closed trades) |
bun run train-models:recency |
Train with recency decay (upweight recent trades) |
bun run improvement-weights |
Apply improvement report source weights |
bun run validate-ml |
Validate ML thresholds on feature-store data |
bun run fd:cache:portfolio |
Prewarm Financial Datasets historical cache for tastytrade + watchlist sleeves |
bun run forge:daily-report |
Write daily Forge markdown report + print Discord-ready summary |
bun run forge:push-now |
Ask Forge agent to push daily summary to forge/ops channels immediately |
bun run forge:job-status -- <jobId> |
Query async messaging job status/result for Forge command jobs |
bun run forge:jobs-tail -- --limit 20 |
Tail Forge job ledger from .elizadb/forge/jobs.jsonl in table format |
bun run type-check |
TypeScript check (no emit) |
bun run check-all |
type-check + format + tests |
v2 slim roster (4-agent core):
ELIZA_ENABLED=false KELLY_ENABLED=false ECHO_ENABLED=false \
SENTINEL_ENABLED=false CLAWTERM_ENABLED=false \
ORACLE_ENABLED=false NAVAL_ENABLED=false bun startForge daily push can run automatically in runtime with:
FORGE_DAILY_REPORT_ENABLED=true
FORGE_DAILY_REPORT_HOUR_UTC=7Forge async terminal flow (when using jobs fallback):
# 1) ask Forge to push now
bun run forge:push-now
# 2) copy jobId from output, then inspect status/result
bun run forge:job-status -- <jobId>Async command jobs are also appended to .elizadb/forge/jobs.jsonl with:
command, jobId, acceptedAt, finalStatus, resultHash (when available), and rejectReasons (promotion gate failures when the run completed and wrote last-run.json).
| Doc | What |
|---|---|
| FORGE_PROGRAM.md | Forge research charter — composite metric, mutable surfaces, safety gates, budget |
| FORGE.md | Forge agent brief — can/cannot, key files, next PRDs |
| SOLUS.md | Solus options agent — Brier calibration, tail risk, copula |
| FEATURE-STORE.md | ML feature store schema and usage |
| PAPER-BOT-AND-ML.md | Signal loop, training, ONNX deployment |
| ONNX.md | Train, export, deploy ONNX models |
| MULTI_AGENT.md | ASK_AGENT, standups, Discord |
| OTAKU.md | Executor agent, DeFi, ERC-8004 identity |
| DEPLOY.md | Eliza Cloud, env, troubleshooting |
| CONFIGURATION.md | Push schedule, Discord, env vars |
| GUARDRAILS.md | Leverage caps, PTQG/max-loss process, weekly guardrail runbook |
| FINANCIAL_DATASETS_MCP_CACHE.md | Cursor MCP setup + historical cache prewarm workflow |
| FD-WAREHOUSE.md | Financial Datasets warehouse + Gem Ticker Discovery (V2) |
| CLAUDE.md | Dev guide (character, plugins, tests) |
| DEXTER.md | Dexter integration — SOUL.md, fundamentals, execution gate |
| AIHF.md | AIHF adversarial challenge layer |
| RECURSIVE.md | Autoresearch architecture, signal cache, 5,000+ experiments/night |
| plugin-vince | WHAT, WHY, HOW, README |
| We Built the Machine | Full architecture essay — three layers, failure modes, harness, north star |
| Three Loops That Never Sleep | Composite metric, ML / genome / Forge loops, precedence order — and what’s implemented in this repo |
Built with ElizaOS. No hype. No permission. No exit.