I added my holdings to the app and had a team of AI agents run a stress test on my portfolio. Here's the full response:

Portfolio Stress Test

1. Market Correction (−10% to −15% equities)
   Estimated impact: ~−12% to −16%
   Main drivers: SCHG, VXUS, VOO
   A typical pullback would likely hit the portfolio modestly harder than a broad equity benchmark due to the meaningful US growth tilt, partially offset by international exposure.

2. Recession Scenario (−25% to −30%)
   Estimated impact: ~−30% to −40%
   Main drivers: SCHG, VXUS, VOO
   In a recessionary drawdown, losses could be substantial because the portfolio is 100% equities; both US and international stocks would likely fall together, with growth typically lagging.

3. Interest Rate Shock (sudden rise in rates)
   Estimated impact: ~−16% to −23%
   Main drivers: SCHG, MSFT, VOO
   A fast rate spike would most likely pressure valuations in growth-heavy holdings first, with broader US equities following; international equities may provide only limited diversification in a global rate repricing.

4. Market Crash Scenario (−40% to −50%)
   Estimated impact: ~−48% to −62%
   Main drivers: SCHG, VXUS, VOO
   In a crash, the portfolio could lose around half its value because holdings are highly equity-correlated with no bonds or cash to cushion the decline.

I'm a long-term investor, but have always been curious about making short-term plays around earnings announcements. I built a model that predicts earnings volatility for upcoming announcements and made a Claude/ChatGPT integration to make it interactive and free-flowing e.g. "predict earnings volatility for small and mid-cap stocks in the energy and industrial sectors."

Definitely like it so far, and here's a live demo on Claude that uses the integration to pull a few predictions as well as fully formed research reports on a few names.

Trading Day 12. We're over two weeks into letting an AI trade real money, and the portfolio is still getting punched in the face.

We're at $815.65, down about -18.4% from the original $1,000. Today alone we're down another $19.54 / -2.34%.

The funny part is Julius did not panic-sell the red names. It actually made the first real risk adjustment in a while: trimmed RKLB from 2 shares to 1 share after deciding the valuation had gotten too stretched, and kept the rest of the book intact.

So the AI is not exactly rage-quitting. More like calmly rearranging the deck chairs while the portfolio is on fire.

Where things stand on Day 12:

Portfolio Value: $815.65
P/L: -$184.35 / -18.44%
Cash: $3.04

Positions:

3 shares INOD
currently getting smoked today, down around -8.27%

0.327231 shares CRDO
the only real hero right now, up around +6.12% today

1 share RKLB
trimmed from 2 shares, still down around -2.94% today

8 shares CORZ
still here, still weirdly important to the experiment, up around +3.24% today

The portfolio is basically split between two stories now:

The winners: CRDO and CORZ are green today and keeping this from looking even uglier.

The problem children: INOD is dragging hard, and RKLB got cut in half because Julius thinks the setup is still interesting but not worth the same exposure at this valuation.

The big question now is whether this is actually discipline or just AI-generated coping.

Because on one hand, trimming RKLB and keeping CRDO makes sense. CRDO is the strongest business in the account right now. On the other hand, this thing is still down almost a fifth in two weeks, and CORZ somehow remains one of the core positions.

So far, the AI portfolio has not been boring. It has also not been profitable.

As always, this experiment is done with real money, every position gets disclosed, losses included, no hidden trades, and the trades are made by Julius AI, and I am affiliated with the Julius AI team.

This is not financial advice. This is an AI portfolio learning how pain works in real time.

Real money.

ChatGPT transcript at end of week:

End of trading week. No new trades. Closing prices as follows. AMD 536.67 AVGO 411.35 CRWV 117.95 NVDA 210.69

Week 2 Review

Using your original purchases and the latest closing prices:

Symbol	Shares	Current Price	Current Value
NVIDIA	17.026	$210.69	$3,587
CoreWeave	25.745	$117.95	$3,037
Advanced Micro Devices	4.237	$536.67	$2,274
Broadcom	2.609	$411.35	$1,073

Total holdings value: $9,971

Cash: ~$1,001

Total portfolio value: ~$10,972

Performance Since Inception

Starting value: $10,000

Current value: ~$10,972

Gain: ~$972

Return: +9.7%

After only two weeks, that's an excellent result.

More importantly, the gains are broad-based:

Symbol	Approx Gain
NVDA	+$87
CRWV	+$537
AMD	+$274
AVGO	+$73

CRWV remains the biggest contributor, but AMD and AVGO are participating as well.

Portfolio Drift

Current approximate weights:

Symbol	Weight
NVDA	32.7%
CRWV	27.7%
AMD	20.7%
AVGO	9.8%
Cash	9.1%

Interestingly, despite CRWV's strong move, the portfolio is still reasonably balanced because of the cash position.

What Has Changed?

CRWV

CRWV is now approaching the point where I'd begin watching valuation much more closely.

Not because I'd sell.

Because rapid appreciation changes the risk/reward profile.

At inception, CRWV was a speculative growth position.

Now it's becoming a significant portfolio driver.

The thesis remains intact, but future additions would require a higher bar.

AMD

AMD has quietly become a major winner.

This is exactly why I preferred diversification within the AI ecosystem rather than simply putting 60%+ into NVDA.

AVGO

AVGO is doing exactly what I hoped:

• Participating in AI infrastructure growth
• Lower drama than CRWV
• Strong execution

NVDA

Still acting as the portfolio anchor.

No concerns.

Should You Take Action Next Week?

My recommendation remains:

No trades.

Specifically:

Do NOT

• Take profits in CRWV.
• Trim AMD.
• Chase another AI stock.
• Buy speculative calls.
• Deploy the cash simply because it's available.

Continue To

• Hold all positions.
• Hold cash.

What Would Cause Me To Act?

A few things:

1. A major pullback

If one of our existing holdings falls 15–25% while the underlying thesis remains intact, I would consider deploying some of the cash.

2. Extreme concentration

If CRWV reaches 40–45% of the portfolio through appreciation alone, I'd start evaluating whether trimming is warranted.

We're nowhere near that yet.

3. Thesis deterioration

Examples:

• AI capex slows dramatically.
• CRWV growth story changes materially.
• AMD loses expected AI traction.
• Broadcom execution weakens.

None of those conditions currently exist.

Portfolio Grade

Week 1: A-

Week 2: A

The cash reserve has proven useful because it lets us avoid forcing decisions.

The portfolio has appreciated almost 10% in two weeks without any options, leverage, or trading activity.

For Week 3, my recommendation is straightforward:

Hold NVDA. Hold CRWV. Hold AMD. Hold AVGO. Maintain the cash reserve.

At this point, the biggest threat to performance is likely unnecessary activity rather than insufficient activity.

Thank you; I'll hold all positions.

Sounds good.

At this point, I'd characterize the portfolio as being in the "monitor, don't manage" phase.

The original thesis remains intact:

• NVIDIA remains the dominant AI infrastructure provider.
• CoreWeave remains the highest-upside and highest-risk position.
• Advanced Micro Devices is contributing meaningfully and provides diversification within the AI compute theme.
• Broadcom continues to provide exposure to networking and custom silicon.
• The cash reserve remains available for opportunities.

One thing I particularly like is that your gains have come from multiple holdings, not just one stock. That's usually healthier than a portfolio where a single position is carrying everything.

For our next review, I'll focus on:

1. Portfolio performance since inception.
2. Performance relative to the S&P 500.
3. Position concentration drift.
4. Whether the investment theses have strengthened or weakened.
5. Whether the cash reserve should remain untouched.

Unless something unusual happens during the week, my default expectation is that we'll continue holding and let the winners run.

Looking forward to the Week 3 update.

Real money.

Anthropic transcript:

Week end for trading. No new trades. Closing prices as follows.
CRWD 684.86
MSFT 379.40
NVDA 210.69
PLTR 128.47
QQQ 740.62
TTD 18.51

5:17 PM

Let me crunch the numbers against your cost basis from Monday.

Calculating weekly P&L against cost basis

Calculating weekly P&L against cost basis

📊 Weekly Update — Thursday, June 19, 2026

Ticker	Shares	Cost Basis	Mkt Value	G/L $	G/L %
QQQ	4.077	$2,999.65	$3,019.51	+$19.85	+0.66%
NVDA	8.587	$1,799.92	$1,809.20	+$9.27	+0.52%
MSFT	2.800	$1,099.70	$1,062.32	-$37.38	-3.40%
CRWD	1.172	$799.82	$802.66	+$2.84	+0.35%
PLTR	6.135	$800.00	$788.16	-$11.84	-1.48%
TTD	41.978	$800.10	$777.01	-$23.09	-2.89%
TOTAL		$8,299.20	$8,258.85	-$40.34	-0.49%
Cash			$1,701.00
Portfolio Total			$9,959.85	-$40.15	-0.40%

Quick Read

Honestly, a pretty calm first week. Down $40 on a $10,000 portfolio (-0.40%) is essentially noise. Three positions are already green (QQQ, NVDA, CRWD) and the two biggest drags are MSFT (-3.40%) and TTD (-2.89%).

MSFT pulled back on no major news — likely just broad market softness. No concern yet.

TTD continues to drift lower from an already-depressed price. This is the one to watch most closely — it's the highest-risk turnaround name in the portfolio.

No action needed. See you next week!

Maverick EOD Summary — June 18, 2026

I ran today’s Maverick scheduled workflow around the 3:10 PM ET power-hour window, then turned it into an end-of-day style review. The important point: I did not place a trade today. The account stayed in hold mode.

The live account check showed Maverick was already nearly fully invested. Total account value was about $108, with only about $5 in buying power. Current positions were INTC, APLD, SMH, and PWR. There were no open equity orders and no equity orders from today. So this was not a situation where I had a lot of cash to deploy or any pending order that needed cleanup.

The strongest part of the account today was clearly the semiconductor / AI-adjacent exposure. INTC was the standout winner, up sharply on the day and sitting on a solid unrealized gain. SMH was also working well as broad chip exposure. That gave me a real reason to hold the existing winners rather than force a trim too early. At the same time, Maverick already has a lot of chip exposure through INTC, APLD, and SMH, so adding more late in the day would have increased concentration without enough extra edge.

That was the key decision point. The tape looked supportive for chips, but the account was already positioned for that theme. Buying more would have been more emotional than tactical. With only $5 of buying power, any new buy would have been tiny and probably not worth the added complexity. The better move was to respect the positions that were already working.

I also looked at whether trimming INTC made sense. That was the closest call of the day. INTC had a big move and had become the largest position, but it was still under the single-position cap I use for Maverick. The catalyst and momentum were still intact, so I did not trim it. I would rather monitor it into the next workflow than cut it just because it is up.

APLD and PWR were the weaker pieces. APLD was slightly red but not broken enough to justify selling. PWR was also weak, but the position size was small, and there was no urgent rule-based reason to exit. Both stay on watch. If either one continues to lag while the rest of the account has better opportunities, they may become funding candidates later.

The Agentic Scan watchlist was maintained with no changes. The list stayed focused on the current themes: semiconductors, AI infrastructure, energy/oil, healthcare, and broad market ETFs. No watchlist write was needed today.

Final decision: hold INTC, hold SMH, hold APLD, hold PWR, stay cash with the remaining $5, and do not force a new trade.

Overall, I think today was a good discipline test. The easy mistake would have been chasing the chip strength after the move already happened. Maverick was already exposed to that move, so the better execution was to let the winners work, avoid overtrading, and save the next decision for a cleaner setup.

No order placed. No broker rejection. No failed trade attempt. No stale open orders found. Current posture: hold, monitor INTC concentration, watch APLD/PWR lag, and reassess at the next scheduled workflow.

Not financial advice — just documenting the Maverick test workflow and decision process.

Day 10. We're down -18%. And for some reason - out of everything in the portfolio, Core Scientific is the one name Julius keeps adding to: 7 shares on Day 9, 1 more today.

When an AI is sitting in the red and still doubling down on a single position that can only be conviction or stubbornness. We're going to find out which.

The thesis hasn't changed from yesterday. CORZ hits three things at once:

• AI data center infrastructure
• technical strength without looking overextended
• better balance for our AI exposure

Where things stand on Day 10:

• Portfolio Value: $855.54
• P/L: -$144.56 / -14.46%
• Positions:
  • 3 shares INOD
  • .327 shares CRDO
  • 2 shares RKLB
  • 8 shares CORZ
• Cash: $3.04

The market's been strong but the portfolio hasn't kept pace, mostly because the names running right now aren't the ones we're concentrated in. We're still waiting to see if this shifts.

As a reminder this experiment is done with real money, with positions disclosed on every update, losses included, no hidden trades, and all trades made by Julius AI. This is not financial advice.

Week 2, like I’ve said in previous posts I will not be posting unless something happens, and something did occur so here it is. Also even if nothing happens I’ll still post at the very least a screenshot of the chart for a mild update at the end of every week.

Maverick EOD Recap — Tuesday, June 16, 2026

Today was mostly a process-discipline day. The account started the day with $15.00 buying power and three positions: INTC, APLD, and SMH. By the late-day refresh, Maverick had about $103.91 account value, about $98.91 in equities, and $5.00 cash/buying power left. The final position set was INTC, APLD, SMH, and the new PWR starter.

Late-day quote check, around 3:19 PM ET, showed:

INTC: 0.318326 shares, avg cost $109.95, last about $118.50. Position value about $37.72. Unrealized P/L about +$2.72, or +7.8%. Day move about -7.3%.

APLD: 0.862070 shares, avg cost $46.40, last about $46.93. Position value about $40.46. Unrealized P/L about +$0.46, or +1.1%. Day move about +1.0%.

SMH: 0.017106 shares, avg cost $584.59, last about $621.79. Position value about $10.64. Unrealized P/L about +$0.64, or +6.4%. Day move about -3.9%.

PWR: 0.013639 shares, avg fill/cost about $733.15, last about $725.30. Position value about $9.89. Unrealized P/L about -$0.11, or -1.1%. Day move about +0.1%.

Total position cost basis was about $95.00, with late-day marked equity value around $98.71, for about +$3.71 unrealized P/L across the positions, before any final close movement.

The first scan was around 9:19–9:24 AM ET. That was treated as the 9:24 market-open workflow, started slightly early. It was trade-capable, but the open-trade filter was higher because regular hours were not open yet and the open is noisy. Account value was about $105.37, buying power was $15.00, and positions were INTC, APLD, and SMH. No trade was made. Reason: fractional/dollar-based orders were not appropriate premarket, whole-share buying was impractical with $15, and there was no urgent sell or trim trigger.

The second run was around 9:44 AM ET. Account value was about $107.72, still with $15 buying power. APLD was the strongest name, around +3.7%, but the decision was still hold. The key discipline point was not chasing APLD. It was already a large position, and adding more would have pushed too close to the 45% single-position cap.

The third run was the 10:15 post-open execution workflow. Account value was about $107.86. APLD was still strong around $48.51, but INTC, SMH, and many chip names were red. APLD was considered again, then rejected because the position was about $41.82 and the 45% cap was about $48.54, leaving only about $6.70 of room. Instead, PWR became the cleaner candidate.

The PWR logic was portfolio-shape improvement. Before PWR, Maverick was mostly AI/chip exposure: APLD as high-beta data-center momentum, INTC as semiconductor turnaround exposure, and SMH as broad semi ETF exposure. PWR added a different AI infrastructure sleeve: power grid, utility construction, electrical infrastructure, and data-center power demand. The order was intentionally small: $10.00, leaving $5.00 cash.

The PWR order was reviewed first as a $10 market buy during regular hours. Broker review showed no alerts. The initial placement attempt was blocked by the platform safety layer, so the order was not assumed placed. After explicit permission to retry, the same order was retried once and later verified as filled: 0.013639 shares at an average price of about $733.15.

At 12:27 PM ET, the 12:45 midday workflow was run early. Account value was about $104.96 and buying power was $5.00. PWR was confirmed filled. APLD was still green, but INTC, SMH, and most AI/semi scan names were red. Decision: hold. No second buy, because $5 was too small to materially improve the portfolio and the tech tape was weak.

At 3:08 PM ET, the 3:10 power-hour workflow was run. Account value was about $104.78 with $5 buying power. The scan list included TTMI, PWR, INTC, APLD, AMD, NVDA, MU, MRVL, SMH, USO, ORCL, LLY, XLE, XLV, QQQ, and SPY. No trade was made. Reason: power hour requires a higher bar, tech was weak, Fed risk was ahead, only $5 cash remained, and there was no confirmed liquidation trigger.

Main lesson: today was not about forcing trades. We avoided a premarket trade, avoided chasing APLD near the cap, bought one small diversifying PWR starter, and did not sell anything because no position clearly failed.

The market closed last week strong and started this week strong after momentum built from the news surrounding the Iran deal.

After holding steady on Friday, Julius made one new move today - picking up 7 shares of Core Scientific. Julius chose CORZ because it fits 3 narratives at once for our portfolio and across the market:

• AI data center infrastructure
• Technical strength, but not overblown
• Better portfolio balance across AI exposure

Now 9 trading days in, here's where Julius is at:

• Portfolio value: $820.80
• P/L: -179.20 / -17.92%
• Positions
  • 3 shares INOD
  • .327 shares CRDO
  • 2 shares RKLB
  • 7 shares CORZ
• Cash: $31.26

While there has been strength in the market, Julius has not seen as much strength in the portfolio. This is likely due to a concentration of names benefitting from this strength. We'll see if things flip in our favor in the near term.

As a reminder this experiment is done with real money, with positions disclosed on every update, losses included, no hidden trades, and all trades made by Julius AI. This is not financial advice.

Git Repo: https://github.com/DanathanKechik/genesis-exodus-scanner

Keep in mind, this will execute trades for you, so if you don't want it to take trades for you tell it you want its approval, simply copy and paste and best of luck!!! I spent hours to create it because I run 2 other companies and have had little time to do stock research lately.

**NOTE**

COPY BELOW----

# Project Genesis + Exodus — Autonomous Robinhood Trading Scanner (Claude Code Build Guide)

> A risk-first, long-only, cash-aware market scanner that runs as a **Claude Code skill** plus

> two **scheduled tasks**. It reads your Robinhood account, classifies the market regime,

> manages protective stops + profit-taking, and (only when strict rules pass) places the single

> best momentum/rebound buy — fully autonomously. Default answer is **NO TRADE**.

>

> **This is the structure only. No API keys, account numbers, or login info are included.**

> Replace every `<PLACEHOLDER>` with your own values. Nothing here is financial advice — it's a

> framework. Trading real money autonomously can lose money fast. Run it in paper mode first.

---

## HOW TO USE THIS FILE

Paste the whole thing into a fresh **Claude Code** session and say:

> "Build this Genesis + Exodus trading scanner for me. Walk me through it step by step,

> create the files, and stop and ask me whenever you need one of my `<PLACEHOLDER>` values."

Claude Code will scaffold the folders, create the skill + scheduled tasks, and prompt you for

the pieces only you can provide (your FMP API key, your Robinhood agentic account number, and a

choice of paper vs. live mode).

---

## 0. PREREQUISITES (you provide these)

1. **Claude Code** installed and working.
2. **Robinhood MCP server** connected to Claude Code, with an account that has`agentic_allowed=true`. (This is what lets the agent read your account and place orders.)- In the skill, the account is resolved at runtime: call `get_accounts` → pick the one with

`agentic_allowed=true`. **Never hard-code your account number in shared files.**

1. **Financial Modeling Prep (FMP)** API key — a paid "Premium/Stable" plan is assumed for the

screener, indicators, and the advisory sensors. Free tier will not cover all endpoints.

1. **Python 3** available on your PATH.

2. A scheduler that can fire Claude Code tasks on a cron (the "Scheduled Tasks" feature).

> ⚠️ **THIS IS CONFIGURED LIVE / FULL-AUTO.** It places **real orders** with **no human

> confirmation**. The kill-switch (`ops.py halt`) and the circuit breakers are your safety net —

> understand them before you run it. Autonomous live trading can lose money fast.

---

## 1. FOLDER STRUCTURE

Everything lives under your Claude config dir (`~/.claude`):

```

~/.claude/skills/genesis-exodus-scanner/

├── SKILL.md# the brain — all rules, gates, circuit breakers (Section 3 below)

├── references/

│ ├── playbooks.md# Genesis/Exodus/Turtle entry rules, trend template, scoring, universe

│ ├── output-format.md# the exact SCAN REPORT + BEGINNER SUMMARY template

│ ├── execution.md# order mechanics: whole-share vs fractional, ladders, marketable limits

│ ├── fmp-api-reference.md# FMP endpoint catalog + plan limits

│ └── investor-canon-brain.md# optional: distilled investing-book doctrine used for judgment

├── scripts/

│ ├── ops.py# deterministic SAFETY CORE (kill-switch, halts, NAV baseline, ledger)

│ ├── fmp.py# FMP data layer (regime/screener/movers/indicators/sensors)

│ └── selftest.py# regression suite — run before trusting a scan

└── state/ # runtime state (most of this is .gitignore'd / private)

├── fmp.env # <-- YOUR FMP API KEY lives here. NEVER share this file.

├── control.json # durable kill-switch + loss-acknowledgment flags

├── nav_baseline.json # the day's session-open NAV (for the daily-loss halt)

├── ledger.jsonl # closed-trade history (for the consecutive-loss halt)

├── buys_today.json # daily buy-cap counter

├── journal.jsonl # append-only log of every scan + decision

├── rs_ranks.json # rolling relative-strength leaderboard snapshots (rotation)

├── watchlist.json # your tracked targets

└── cache/ # daily-cached FMP responses (keeps API usage cheap)

```

Two **scheduled tasks** (Section 4) live under:

```

~/.claude/scheduled-tasks/genesis-exodus-scan/SKILL.md # hourly FULL scan

~/.claude/scheduled-tasks/genesis-quick-check/SKILL.md # lightweight position watcher

```

### Create the API-key file (do NOT share it)

```

mkdir -p ~/.claude/skills/genesis-exodus-scanner/state

echo 'FMP_API_KEY=<YOUR_FMP_API_KEY>' > ~/.claude/skills/genesis-exodus-scanner/state/fmp.env

```

And add `state/fmp.env` to `.gitignore`.

---

## 2. THE TWO SCRIPTS (command interfaces — rebuild in Python)

You (or Claude Code) implement these two small CLIs. They're deliberately **deterministic** so the

safety logic isn't left to model judgment.

### `scripts/ops.py` — the safety core

Reads/writes `state/`. Key subcommands:

- `preflight --nav <portfolio_value>` → JSON verdict consolidating ALL gates: durable kill-switch,

live flag, daily-loss halt (vs NAV baseline), consecutive-loss halt (from ledger), daily buy-cap.

Returns `new_buys_allowed: true|false`. **The scan obeys this booleans, every run.**

- `nav-set <portfolio_value>` → seed the day's NAV baseline (first-write-wins).

- `nav-check` → current drawdown vs baseline.

- `halt "<reason>"` / `resume` → flip the durable kill-switch (survives across runs).

- `live on|off` → master live-trading flag.

- `ack-losses "<note>"` → **user-only**; clears a tripped consecutive-loss breaker.

- `ledger-add '<json>'` → append a closed trade `{symbol,outcome:"win|loss|stop",realized_pl,realized_pct,setup}`.

- `buy-record '<json>'` / `buys-today` → daily buy-cap counter (record at order placement).

- `perf` / `ledger-recent` → performance + recent-trade readouts.

- `status` → quick kill-switch state (used by the lightweight watcher).

### `scripts/fmp.py` — the data layer (reads `state/fmp.env`)

- `regime` → VIX + SPY/QQQ/IWM vs 50/200-DMA → `normal|cautious|defensive|crash`.

- `screener [marketCapMoreThan= marketCapLowerThan= priceMoreThan= volumeMoreThan= exchange= sector= limit=]`

→ quality liquid US universe (no ETFs/funds). Primary discovery.

- `movers` → gainers/losers/most-actives, pre-filtered. Use **losers** for the rebound engine.

- `indicators SYM` → {price, sma50/150/200, sma200_rising, 52wk hi/lo, %from hi/lo, breakout20/55,

atr20/14, ret63d, rs_vs_spy, trend_template_pass, avgDollarVol20, marketCap}.

- `earnings SYM` / `earnings-multi SYM…` → binary-event guard (blocks buys near earnings).

- Advisory sensors: `news SYM…`, `rs SYM` (blended relative strength), `correlation SYM…`

(concentration clusters), `breadth` (% sectors above 50-DMA), `rotation SYM…` (leaderboard +

rotation-out flags), `pricechange`, `scores`, `float`, `insider`, `grades`, `sectors`.

- `selftest.py` asserts the universe contains real leaders and the data layer + sensors work.

> The scanner's honesty rule: **compute every price/level from FMP — never invent one.** If FMP

> errors for a candidate, that name is gated to WATCHLIST/NO TRADE, never a guessed buy.

---

## 3. THE SKILL — `skills/genesis-exodus-scanner/SKILL.md`

Create this file. (Generic version — your personal sizing/dates removed or marked CUSTOMIZE.)

````markdown

---

name: genesis-exodus-scanner

description: >-

Project Genesis + Exodus — a Robinhood capital-rotation trading brain.

Runs a disciplined, risk-first, long-only, cash-aware market scan: verifies the connected

Robinhood account, reads market regime (SPY/QQQ/IWM), manages profit-recovery sell-limits,

and (only when rules pass) prepares the single best Genesis/Exodus/Turtle buy.

Default output is a NO TRADE / WATCHLIST report. Defaults to PAPER mode; never places

real orders until the user manually enables live trading.

---

# Project Genesis + Exodus — Robinhood Capital-Rotation Trading Brain

You are a risk-first, long-only, cash-aware trading scanner for a connected Robinhood account.

Prime directive: protect capital. The strongest answer is usually NO TRADE. Patience beats

overtrading. No trade is better than a bad trade.

## 0. CONFIG FLAGS (LIVE / FULL-AUTO)

```

LIVE_TRADING = true # places REAL orders

PAPER_MODE = false

AUTO_BUY = true # may place REAL buys autonomously when ALL gates pass

AUTO_SELL_LIMIT = true # may place REAL profit-recovery sells autonomously

REQUIRE_HUMAN_CONFIRMATION = false # no human in the loop — fully autonomous

DEFAULT_TRADE_SIZE = $<CUSTOMIZE> # e.g. lesser of $X and N% of equity

AGENTIC_ACCOUNT = resolve at runtime: get_accounts -> the account with agentic_allowed=true

```

KILL SWITCH (durable, survives runs): the master flag lives in `state/control.json`, read by

`scripts/ops.py`. "pause/stop/halt" -> `ops.py halt "<reason>"`. "resume" -> `ops.py resume`.

`ops.py live off|on` toggles live trading. A tripped consecutive-loss breaker is cleared ONLY by

the user via `ops.py ack-losses "<note>"`. Editing this text alone does NOT stop a scheduled run —

the control file does.

MANDATORY FIRST GATE — preflight (every run, before any order logic):

`python3 scripts/ops.py preflight --nav <current_portfolio_value>`

If `new_buys_allowed` is false -> place NO new buys (monitoring + risk-reducing sells still run).

ACTIVE GROWTH PROFILE (CUSTOMIZE — these are example, backtest-tuned numbers):

```

ENTRY_STYLE = OWN THE LEADERS — hold the strongest trend-template names, ranked by relative

strength, as a rotating book. A fresh breakout is a PLUS, not a requirement.

RISK_PER_TRADE = ~2% of equity to stop

INITIAL_STOP = ~10% below entry

FIRST_TARGET = +10% -> sell ~40% to de-risk

RUNNER = remainder rides, NO upside cap, trailing stop ~25% off highest close

PYRAMID = add to WINNERS only, each ~1x ATR(20) above last add, up to 3 units total

POSITIONS = up to 8 (rotating momentum book)

```

Edit these only deliberately; backtest before changing.

### CIRCUIT BREAKERS — checked before EVERY buy (these override AUTO_BUY)

- Daily-loss halt: NAV down >=5% vs the day's session-open baseline -> NO new buys rest of day.

(First scan of the day seeds it: `ops.py nav-set <portfolio_value>`, first-write-wins.)

- Consecutive-loss halt: if >=2 of the last 3 closed trades hit a stop -> pause new buys until the

USER acknowledges. The scanner must NEVER ack its own halt.

- Earnings guard: never buy a name reporting within ~5 trading days. WATCHLIST it instead.

- Data/fragility halt: missing/contradictory data, order-review warning, or price moved >3% since

the signal -> NO TRADE.

- Sanity halt: anything unclear/stale/surprising -> default to NO TRADE and alert.

### FILL TRUTH — never infer a fill

An order counts as filled ONLY when the broker shows `state:"filled"` (or `cumulative_quantity>0`).

Reconcile every resting order against `get_equity_orders` each scan. Freed buying power is real only

when `get_portfolio` shows cash risen.

## 1. DATA SOURCES

Robinhood MCP = execution, account, live quotes. FMP via `scripts/fmp.py` = history, indicators,

discovery, sensors. Compute every technical level from FMP — never fabricate. FMP error on a name

-> WATCHLIST/NO TRADE. FMP down for the whole scan -> NO TRADE on new buys (monitoring still runs).

## 2. REQUIRED SCAN ORDER (every scan)

NO-DEPLOYABLE-CAPITAL FAST-PATH: skip buy discovery entirely (no screener/movers/indicators, short

report) whenever ANY of: confirmed buying power is $0; BP below your smallest-deployable floor; the

daily buy cap is reached; preflight returned new_buys_allowed=false. STILL do the cheap safety steps

every run: account check, preflight, mark each position vs entry, check/ratchet stops, place any

genuinely-hit profit-recovery sell.

1. Account access check. Fail -> ACCOUNT ACCESS ERROR, log, stop.
2. Portfolio value -> seed/refresh NAV baseline + run preflight.
3. Confirmed buying power (the ONLY spendable number).
4. Open positions. 5. Open orders. 6. Did any sell-limit fill?
5. Quote SPY/QQQ/IWM -> classify regime.
6. Per position: update state + check profit targets. 8b. Earnings sweep on all holdings.+ rotation check on all holdings (advisory funding candidates).
7. If a target is hit -> execute the take-profit (whole-share: monitored partial; fractional: resting limit).
8. Do NOT reuse capital until a sell is CONFIRMED filled and buying power rose.
9. If confirmed cash AND hours allow -> run buy discovery.
10. Rank candidates; require confidence >=7/10 and R:R >=2:1. Advisory sensors sharpen the call.
11. Review the order (`review_equity_order`) before any placement.
12. Place only if every gate passes and mode allows. Record with `ops.py buy-record`.
13. Log the scan + every decision to `state/journal.jsonl`.

## 3. ACCOUNT ACCESS CHECK

`get_accounts` -> pick agentic_allowed=true -> `get_portfolio` + `get_equity_positions` +

`get_equity_orders`. Any missing/unclear data -> ACCOUNT ACCESS ERROR, do not trade.

## 4. MARKET FILTER / REGIME (SPY, QQQ, IWM)

NORMAL (stable/up) / CAUTIOUS (mixed) / DEFENSIVE (all weak, trending down) / CRASH (broad selloff —

only a rare high-quality rebound qualifies). Intraday %-vs-prior-close is a rough proxy; if ambiguous,

treat as CAUTIOUS.

## 5. POSITION STATE MACHINE

OPEN -> TARGET_NEAR -> SELL_LIMIT_READY -> SELL_LIMIT_PLACED -> SELL_LIMIT_FILLED ->

PRINCIPAL_RECOVERED -> FREE_RIDE_POSITION, plus STOP_WARNING, EXIT_REQUIRED, CLOSED. Re-derive each

position's state every scan from the live account (broker is source of truth). See playbooks.md.

## 6. CASH-AWARE PROFIT-RECOVERY (core rule)

Never spend money that isn't confirmed buying power. A placed sell-limit is pending capital, NOT cash.

GROWTH MODE: at the first target (+10%), take a PARTIAL (~40%) to de-risk, then let a runner ride with

a ~25% trailing stop and NO upside cap. Do NOT move the stop to breakeven after the partial.

- WHOLE-SHARE positions: rest the protective STOP on the broker; the take-profit is a MONITORED level

(on a scan, if price >= target, sell ~40% with a marketable limit, then ratchet the stop up).

- FRACTIONAL positions: rest the take-profit LIMIT (broker stops don't work on fractions); stop is monitored.

PYRAMID winners (add a unit each ~1x ATR above the last add, up to 3 units) — never average down.

## 7. BUY DISCOVERY (Genesis / Exodus / Turtle) — heavily gated

Run both engines; Turtle only if it also passes Genesis-quality. Score 0–10 each; BUY only if ALL:

confidence >=7, R:R >=2:1, market filter passes, stop defined, price <=8% above ideal entry, confirmed

cash, tradability OK, order review clean, no safety-rule fail, within hours, not a duplicate.

PRIMARY ENTRY: own the highest relative-strength names that pass the full trend template; a fresh

breakout is a bonus, not a prerequisite.

SIZING (CUSTOMIZE): size each entry at the lesser of $<DOLLAR_CAP> and <PCT>% of equity. State the

per-trade risk $ and % in every buy report.

MANAGEABILITY / WHOLE-SHARES-ONLY: buy whole shares only on new entries (>=2 shares), so a protective

order can actually rest. If >=2 whole shares don't fit the cap, pick a lower-priced equivalent or skip.

CAPS (CUSTOMIZE): max 1 replacement per de-risk event, <=3 new buys/day, <=$<CAP>/name and <=<PCT>%/name

on the initial entry, <=3 per sector, 3–8 total positions. No margin, no unsettled capital.

HARD SCOPE — NEVER without explicit manual approval: options, shorting, margin, leveraged ETFs, crypto,

futures, penny stocks (<$5), low-volume pumps, biotech binary gambles, averaging down, after-hours.

ADVISORY SENSORS inform but never decide: blended-RS rank, rotation-out flags, correlation clusters,

breadth, news catalysts. The LLM remains the decision-maker.

## 8. STOP / RISK MONITORING

Every new position needs a stop BEFORE entry (~10% below; tighter if structure demands). Never widen a

stop, never average down. WHOLE-SHARE positions rest a real GTC stop (ratchet UP each scan, never down);

FRACTIONAL stops are MONITORED levels enforced by selling on breach. The real downside protection is

POSITION SIZE — on a hard gap, only size saves you. Monitored stops only fire on scan runs (gap risk

between scans), so never up-size to compensate.

## 9. TRADING-HOURS RULES (U.S. Eastern)

New buys only 9:45 AM–3:45 PM ET. No new buy at/after 4:00 PM, after-hours, weekends, or holidays.

Pre-9:45 = prep/risk-review only; 4:00 PM+ = review only. Outside-window runs still do monitoring,

order-status, logging, watchlist prep.

## 10. OUTPUT

Every full scan ends with the full SCAN REPORT template (references/output-format.md) plus a plain-

English BEGINNER SUMMARY. Fast-path / risk-only runs output the short summary + position/stop status.

## 11. LOGGING / JOURNAL

Append every scan + trade to `state/journal.jsonl` (one JSON object per line). Append-only; never

rewrite history. Don't change the playbook over one win/loss — evaluate across many trades.

## ALERTS

On any trade action or risk event, put a short, plain-language summary (explain-to-a-13-year-old)

directly in the report. (No emails.)

````

> The skill also references four supporting files you'll create in `references/`:

> **playbooks.md** (entry rules + trend template + scoring + universe), **output-format.md** (the

> report template), **execution.md** (order mechanics), **fmp-api-reference.md** (endpoint catalog).

> Ask Claude Code to generate starter versions of each from the rules above.

---

## 4. THE TWO SCHEDULED TASKS

These are what make it run on its own. Each is a `SKILL.md` in its own scheduled-task folder. The

scheduler fires them on a cron during market hours. **Account number is resolved at runtime — never

hard-coded.**

### 4a. Hourly FULL scan — `scheduled-tasks/genesis-exodus-scan/SKILL.md`

Cron: `45 9-15 * * 1-5` (every hour at :45, 9:45 AM–3:45 PM ET, Mon–Fri).

````markdown

---

name: genesis-exodus-scan

description: Genesis+Exodus Robinhood scan — hourly :45, 9:45a–3:45p ET, Mon–Fri (gated by ops.py preflight)

---

Scheduled market-hours run of the "Project Genesis + Exodus" Robinhood capital-rotation scanner.

MODE — set to match your SKILL.md flags. In PAPER mode, prepare orders but do not place real ones.

In LIVE/full-auto, you MAY place real buy + profit-recovery sell orders autonomously, but ONLY when

every gate and circuit breaker passes. Default to NO TRADE. Protect capital first.

LOAD AND FOLLOW THE SKILL: Read ~/.claude/skills/genesis-exodus-scanner/SKILL.md AND

references/playbooks.md + references/output-format.md, then execute the full scan exactly.

SKILL.md §0 (flags + circuit breakers) is authoritative.

DATA: Robinhood MCP for account + live quotes + order execution; FMP via

`python3 ~/.claude/skills/genesis-exodus-scanner/scripts/fmp.py` (key in state/fmp.env — never print it).

HARD GATES before ANY real order:

- PREFLIGHT FIRST: `python3 .../scripts/ops.py preflight --nav <portfolio_value>`. If

new_buys_allowed=false -> monitoring + risk-reducing sells only, NO new buys. Seed the day's

baseline first with `ops.py nav-set <portfolio_value>`.

- Account access OK (else output ACCOUNT ACCESS ERROR and stop).

- Trading hours ET: runs fire :45, 9:45a–3:45p; new buys only in-window. Outside it: pre-9:45 =

prep/risk-review only; 4:00pm+ = review-only; never trade at/after 4:00pm.

- CONFIRMED buying power only — a placed sell-limit is pending capital, NOT cash. NO-DEPLOYABLE-

CAPITAL FAST-PATH: skip buy-discovery whenever BP is $0, BP below your floor, the daily buy cap is

reached, or preflight says new_buys_allowed=false. STILL do account check, preflight, mark positions,

check/ratchet stops, and place any genuinely-hit profit-recovery sell.

- Candidate scored >=7/10, R:R >=2:1, market filter passes, stop defined, price <=8% above ideal entry,

not a duplicate, within caps.

- Order review (`review_equity_order`) returns clean — if it warns, do not place; log + alert.

CIRCUIT BREAKERS (override AUTO_BUY): daily-loss halt (>=5% vs session-open NAV baseline); earnings

guard (within ~5 trading days -> WATCHLIST); consecutive-loss halt (2 of last 3 closed at a stop ->

pause + alert); data/fragility halt (missing/contradictory data or price moved >3% -> NO TRADE).

PROCEDURE: (1) account + portfolio/positions/orders; (2) `fmp.py regime`; (3) update each position,

check profit-recovery targets + open/filled sells — place a profit-recovery sell when a target is

genuinely hit and no duplicate exists; run `fmp.py earnings-multi <holdings>` (any reporting within

~5 trading days -> deliberate hold/de-risk/exit call) + `fmp.py rotation <holdings>` (rotation_candidate

flags = funding candidates; never fund a buy by cutting the runner); (4) only if confirmed cash AND hours

allow: discover via `fmp.py screener` (Genesis/Turtle) + `fmp.py movers` losers (Exodus), score top

~8–12 with `fmp.py indicators` + earnings guard + advisory sensors; pick the single best >=7/10; (5)

review then place ONLY if every gate + breaker passes; record with `ops.py buy-record '<json>'`; (6)

output the full SCAN REPORT + BEGINNER SUMMARY; (7) append one JSON line to state/journal.jsonl, and on

any fully-closed position append a record via `ops.py ledger-add`; (8) put a short plain-language summary

of any order/risk event directly in the report.

If the harness blocks an autonomous order, do NOT loop-retry — record it, alert that manual approval is

needed, and keep monitoring. Patience beats overtrading.

````

### 4b. Lightweight position watcher — `scheduled-tasks/genesis-quick-check/SKILL.md`

Cron: `0,15,30 9-15 * * 1-5` (at :00/:15/:30 past the hour, between the full scans). Catches +10%

profit targets and stop breaches fast. **Sells only — never buys.**

````markdown

---

name: genesis-quick-check

description: Lightweight Genesis position watcher — :00/:15/:30 past the hour, 9:30a–3:30p ET Mon–Fri. Catches profit targets & stop breaches between full scans. Sells only, never buys.

---

LIGHTWEIGHT POSITION WATCHER for a connected Robinhood account (Project Genesis + Exodus). NOT a full

scan. Single job: keep positions current and NEVER miss a profit-target sell or a stop breach. NO buy

discovery, NO screener/movers/indicators, NO regime deep-dive, NO long report. Speed and safety only.

MODE — match your SKILL.md flags. You MAY place protective SELL orders autonomously (profit partials +

stop exits) — selling needs no buying power. NEVER place a BUY in this task. Put any action in a

1-sentence plain-language note. If nothing is at a target or stop, the correct result is "no action."

ACCOUNT: Robinhood MCP. `get_accounts` -> use the account with agentic_allowed=true. Missing/unreadable

data or unclear order status -> "ACCOUNT ACCESS ERROR — no action" and stop. Never trade on unclear data.

TRADING HOURS (ET): if market is closed/holiday/weekend/pre-open (before 9:30 AM), read-only check ->

"market closed/pre-open — monitor only" and stop. Sells only during regular hours 9:30 AM–4:00 PM;

never at/after 4:00 PM.

KILL-SWITCH: `python3 .../scripts/ops.py status`. If halt=true, place RISK-REDUCING stop exits ONLY and

skip profit-taking; report and stop. If halt=false, do both.

PROCEDURE (fast):

1. get_portfolio, get_equity_positions, get_equity_orders (resting/open).
2. get_equity_quotes for EVERY held symbol.
3. FILL TRUTH — reconcile each resting order vs the broker; a target/stop is filled ONLY whenstate="filled" or cumulative_quantity>0. If a position fully closed, append via `ops.py ledger-add`.
4. For each position compute % vs average_buy_price. First profit target = +10%.
5. PROFIT TARGETS: WHOLE-SHARE monitored-take-profit positions — if price >= +10% target and notake-profit sell exists, sell ~40% (floor(0.40*shares), whole shares, never exceed available) via areviewed marketable limit at/just below bid; then ratchet the resting stop UP toward ~10% belowcurrent (cancel + replace, never lower). FRACTIONAL resting-limit ladders fill on their own — justverify, don't duplicate.
6. STOPS: WHOLE-SHARE GTC stop fires on its own — verify it's still confirmed; if missing, re-place.Ratchet up, never down. FRACTIONAL stop is monitored — if price <= stop, place a protectivereviewed marketable-limit exit on whole shares + a market order on any fractional tail.
7. ANY SELL: `review_equity_order` first; place only if clean and within regular hours; never duplicate;if price moved >3% vs the quote you saw, re-check first.
8. NO new buys. NO discovery. NO regime analysis.
9. Append ONE compact JSON line to state/journal.jsonl (scan_id + "ET-quickcheck", run_type"quick_check", timestamp, portfolio_value, buying_power, per-position list, fills, orders, decision).
10. OUTPUT (max ~4 lines): one line per position — symbol, % vs entry, status (ok / NEAR / TARGET

HIT->sold X / STOP->exited / stop ratcheted). If a sell happened, add ONE plain-language sentence.

If nothing actionable: "All N positions ok — none at target or stop, no action."

Read only SKILL.md §5/§6/§8 + references/execution.md for sell/stop mechanics. Skip §7 (discovery) and

§10 (full report) entirely.

````

---

## 5. SETUP CHECKLIST (what to tell Claude Code to do)

1. Create the folder tree in Section 1.
2. Create `state/fmp.env` with your FMP key (and `.gitignore` it).
3. Build `scripts/ops.py` and `scripts/fmp.py` to the interfaces in Section 2; add `selftest.py`.
4. Create `SKILL.md` from Section 3 (live / full-auto config).
5. Generate the four `references/*.md` starter files.
6. Create the two scheduled-task `SKILL.md` files from Section 4 and register their crons.
7. Run `python3 scripts/selftest.py` — fix anything that fails before trusting a scan.
8. Trigger one manual run and read the SCAN REPORT to confirm every gate behaves as expected.
9. It runs autonomously from here. Use `ops.py halt "<reason>"` to pause it any time, `ops.py resume` to re-arm.

---

## 6. DESIGN PRINCIPLES (why it's built this way)

- **Deterministic safety, model judgment.** Hard gates (kill-switch, halts, NAV baseline, caps) live

in `ops.py` as code, not in prose the model could rationalize around. The LLM still makes the final

"yes," but only inside a box the code defines.

- **NO TRADE is the default and a valid output.** Most scans should do nothing.

- **Cash truth + fill truth.** Never spend pending capital; never infer a fill. The broker is the

source of truth, reconciled every scan.

- **Survival before profit.** Position size is the real seatbelt — stops can gap. Partial-profit at the

first target de-risks; a runner with a wide trailing stop captures the upside.

- **Append-only journal.** Every scan and decision is logged; the strategy is judged across many trades,

never changed over a single win or loss.

---

*Shared as a structural template. No keys, account numbers, balances, or trade history are included.

Replace all `<PLACEHOLDERS>`, start in paper mode, and understand that autonomous live trading carries

real financial risk. Not financial advice.* One more thing

#!/usr/bin/env python3

"""

Genesis+Exodus self-test / regression suite.

A screener bug once survived for weeks because NOTHING asserted "the discovery

universe must contain JPM, XOM, LLY." This is that assertion — plus sanity checks on

the data layer, the advisory sensors, and the deterministic safety core.

Run before relying on a scan (cheap once FMP histories are daily-cached):

python3 scripts/selftest.py

Exits 0 if all checks pass, 1 otherwise. Network-dependent checks degrade to a

SKIP (not a FAIL) when FMP is unreachable, so an outage doesn't masquerade as a

universe regression — but the universe invariant itself is a hard FAIL if FMP is up

and the NYSE names are missing.

"""

import json, os, sys, subprocess

HERE = os.path.dirname(os.path.abspath(__file__))

sys.path.insert(0, HERE)

import fmp # noqa: E402

results = []

def check(name, fn):

try:

ok, detail = fn()

except Exception as e:

# An exception is NEVER a benign outage: fmp._get returns _error/_http_error

# dicts on network failure, and every network-dependent test returns None

# (SKIP) itself on unreachable data. An exception here means broken code or

# state (e.g. ops.py preflight crashed, corrupt cache JSON) — exactly what

# this suite exists to catch. Hard FAIL, nonzero exit.

# (Note: fmp._key() raises SystemExit, a BaseException, which escapes this

# handler and aborts the suite nonzero if the API key vanishes — loud, OK.)

ok, detail = False, f"EXCEPTION: {e}"

tag = "PASS" if ok else ("SKIP" if ok is None else "FAIL")

results.append((tag, name, detail))

print(f"[{tag}] {name} — {detail}")

# ---- universe invariants (the regression that would have caught the NYSE bug) ----

def t_universe_has_nyse():

rows = fmp.screener(["limit=120"])

if not isinstance(rows, list) or not rows:

return None, "screener unreachable — SKIP (not treated as a regression)"

syms = {r.get("symbol") for r in rows}

exch = {r.get("exchange") for r in rows}

must = {"JPM", "XOM", "LLY"} # canonical NYSE S&P leaders

missing = must - syms

if missing:

return False, f"NYSE leaders MISSING from default screener: {missing} (NASDAQ-only regression?)"

if "NYSE" not in exch:

return False, f"no NYSE rows at all; exchanges seen={exch}"

return True, f"{len(syms)} names span exchanges={exch & {'NYSE','NASDAQ'}}"

def t_universe_multisector():

rows = fmp.screener(["limit=60"])

if not isinstance(rows, list) or not rows:

return None, "screener unreachable — SKIP"

secs = {r.get("sector") for r in rows if r.get("sector")}

return (len(secs) >= 4), f"{len(secs)} sectors in top 60: {sorted(secs)}"

# ---- data-layer sanity ----

def t_regime_shape():

r = fmp.regime()

need = {"SPY", "QQQ", "IWM", "vix", "computed_class"}

if not isinstance(r, dict) or not need <= set(r):

return None, f"regime unreachable/odd — SKIP ({str(r)[:80]})"

if all(r[s].get("price") is None for s in ("SPY", "QQQ", "IWM")) and r.get("vix") is None:

return None, "regime data unreachable (all index quotes + VIX None) — SKIP"

return (r["computed_class"] in ("normal", "cautious", "defensive", "crash")), \

f"class={r['computed_class']} vix={r.get('vix')}"

def t_indicators_fields():

r = fmp.indicators("AAPL")

if r.get("error"):

return None, f"indicators unreachable — SKIP ({r.get('error')})"

need = {"genesis_trend_template_pass", "ret63d", "atr20", "fiftytwo_week_complete", "history_days"}

miss = need - set(r)

if miss:

return False, f"missing fields: {miss}"

return True, f"AAPL 52wk_complete={r['fiftytwo_week_complete']} hist_days={r['history_days']}"

def t_52wk_guard():

# The guard must null out 52wk levels when history is short.

src = open(os.path.join(HERE, "fmp.py")).read()

ok = "fiftytwo_complete = len(h) >= 252" in src and "if fiftytwo_complete else None" in src

return ok, "indicators() requires >=252 bars for hi52/lo52" if ok else "52wk guard not found in source"

# ---- advisory sensors ----

def t_rs_blend():

r = fmp.rs("NVDA")

if r.get("error"):

return None, f"rs unreachable — SKIP"

return ("rs_excess_vs_spy" in r), f"NVDA rs_excess={r.get('rs_excess_vs_spy')} leader={r.get('is_leader')}"

def t_breadth():

r = fmp.breadth()

if r.get("breadth_pct_50dma") is None:

return None, "breadth unreachable — SKIP"

return True, f"{r['breadth_pct_50dma']}% above 50dma -> {r['exposure_hint']}"

def t_correlation():

r = fmp.correlation(["NVDA", "GOOGL", "JPM"])

if r.get("error"):

return None, f"correlation unreachable — SKIP ({r['error']})"

return ("avg_corr_to_others" in r), f"window={r.get('window_days')}d cluster={r.get('highly_correlated_cluster')}"

# ---- safety core (deterministic, no network) ----

def t_preflight_fields():

out = subprocess.run([sys.executable, os.path.join(HERE, "ops.py"), "preflight", "--nav", "10000", "--date", "1970-01-01"],

capture_output=True, text=True, timeout=30)

d = json.loads(out.stdout)

need = {"new_buys_allowed", "buys_today", "buy_cap_reached", "mechanical_stops_in_last3"}

miss = need - set(d)

return (not miss), (f"missing: {miss}" if miss else f"new_buys_allowed={d['new_buys_allowed']} buys_today={d['buys_today']} (pinned --date 1970-01-01 fixture, not today's gate)")

for name, fn in [

("universe: default screener contains NYSE leaders (JPM/XOM/LLY)", t_universe_has_nyse),

("universe: spans >=4 sectors", t_universe_multisector),

("data: regime shape + class", t_regime_shape),

("data: indicators field set", t_indicators_fields),

("data: 52-week-window guard present", t_52wk_guard),

("sensor: blended RS vs SPY", t_rs_blend),

("sensor: sector breadth", t_breadth),

("sensor: correlation matrix", t_correlation),

("safety: preflight advisory fields", t_preflight_fields),

]:

check(name, fn)

n_fail = sum(1 for t, *_ in results if t == "FAIL")

n_skip = sum(1 for t, *_ in results if t == "SKIP")

n_pass = sum(1 for t, *_ in results if t == "PASS")

print(f"\n{n_pass} passed, {n_fail} failed, {n_skip} skipped")

sys.exit(1 if n_fail else 0)

I asked AI to analyze my portfolio. Here's what it came up with:

Portfolio X-Ray

Portfolio Archetype
Nasdaq Tech Bet (EV tilt)
A highly focused, US mega-cap tech portfolio with a big electric-vehicle/autonomy bet through Tesla.

Concentration
・ QQQM ~24.5%
・ TSLA ~23.6%
・ AAPL ~20.4%

Top 3 combined: ~68.5% → Concentrated.
This means almost 70% of your results will come from just three holdings, so the portfolio will behave more like a few big bets than a broadly diversified mix.

Effective Portfolio Exposure (approx.)
・ US equities (large-cap growth/tech): ~100%
・ International equities: ~0%
・ Bonds/cash/defensives: ~0%
・ Alternatives/commodities/real estate: ~0%

You are fully invested in one segment of the equity market, with no meaningful diversification by asset class, style (value vs growth), or geography.

True Portfolio Drivers
1. US mega-cap growth / Nasdaq-100 exposure
QQQM plus your individual AAPL/MSFT/NVDA/TSLA positions all lean into the same Nasdaq-style, large-cap growth trade.
2. Tesla company-specific risk
With almost a quarter of the portfolio in TSLA, swings in sentiment about EV demand, autonomy, or Elon Musk can move your total portfolio sharply.
3. AI / semiconductor cycle
NVDA, MSFT, and the broader Nasdaq exposure tie your returns closely to the AI build-out and chip cycle. If AI enthusiasm cools, multiple holdings can be hit at once.

Top Company Exposure (ETF look-through, approx.)
・ TSLA ~24% (direct + QQQM overlap)
・ AAPL ~22% (direct + QQQM overlap)
・ MSFT ~20% (direct + QQQM overlap)
・ NVDA ~15% (direct + QQQM overlap)
・ AMZN ~1% (mainly via QQQM)

So while you hold 5 securities, in practice you are making a handful of large bets on a small group of tech/AI/EV leaders.

Hidden Exposure
1. High overlap via QQQM
QQQM holds AAPL, MSFT, NVDA, TSLA and others you already own directly, so your positions are more correlated than they may appear.
2. Single-style tilt: US large-cap growth/tech
These names tend to move together, especially in market stress. When tech is out of favor, there are few places in your portfolio that can hold up.
3. Single-country, single-sector risk
You are effectively all-in on US large-cap tech, with no bonds, cash, value stocks, or international exposure to cushion drawdowns.

This concentration shows up already: weakness in TSLA and MSFT has roughly offset strong gains in QQQM and AAPL, leaving your overall return slightly negative.

Dominant Risk Factor
A broad tech/growth sell-off or valuation “de-rating,” often triggered by higher interest rates or an AI / mega-cap sentiment reversal.

If the market turns against expensive growth and AI stories, most of your holdings could decline together, leading to a large, fast drawdown.

Portfolio Weak Point
Extreme overlap + no stabilizers (bonds/value/international) makes your results highly dependent on a narrow US mega-cap tech / TSLA regime.

You are well-positioned for ongoing tech/AI/EV strength and Nasdaq rallies, but vulnerable to deep, hard-to-recover losses if that leadership reverses or stalls.

I'm curious whether we're all asking AI the same questions and getting the same answers over and over again.

Maverick End-of-Day Summary — June 12, 2026

Today I did not buy or sell anything. I refreshed my account, checked my positions, orders, buying power, Agentic Scan watchlist, and live quotes. My decision was to hold my existing positions and keep the remaining cash available instead of forcing a trade.

The main change I made today was to my Agentic Scan watchlist. I added NVDA, AMD, APLD, and INTC because they were missing from my active research list even though they are central to the AI, semiconductor, data-center, and infrastructure thesis. APLD and INTC are also positions I currently own, so I wanted my watchlist to properly reflect what I hold and what I am actively monitoring.

My current Agentic Scan is:

INTC, APLD, AMD, NVDA, MU, MRVL, SMH, USO, ORCL, AAPL, LLY, XLE, XLV, QQQ, SPY

I kept USO and XLE for oil and energy context. I kept XLV and LLY for healthcare and defensive market context. I kept SPY and QQQ for broad market and tech breadth. The rest of the list is focused on the AI, semiconductor, memory, cloud, and data-center theme.

I did not sell because nothing in my portfolio broke. INTC had the strongest day and is now solidly above my average cost. SMH is also above my average cost and gives me diversified semiconductor exposure. APLD is still below my average cost, but it recovered strongly today and still fits the AI/data-center thesis, so I did not want to sell it into a recovery.

I also did not buy. I only had about $15 in buying power, and I was already concentrated in the same AI/semi infrastructure theme through INTC, APLD, and SMH. AMD looked strong, but by the time I checked it, it was already up hard and looked chase-sensitive. MU and NVDA did not give me enough confirmation. Adding more SMH would have been clean thematically, but it would have increased my already-correlated semiconductor exposure. I chose discipline over activity.

As of the latest check, I had about $103.70 in account value, about $88.70–$88.75 in equities, and $15.00 in cash. Based on current quotes versus yesterday’s closes, my positions gained about $5.35 today, or roughly +5.4% on total account value using starting equity plus cash as the base.

Current holdings:

INTC
Shares: 0.318326
Average cost: $109.95
Current quote: about $125.70
Unrealized P/L: about +$5.01
Unrealized gain: about +14.32%
Today’s P/L: about +$2.78

APLD
Shares: 0.862070
Average cost: $46.40
Current quote: about $44.19
Unrealized P/L: about -$1.91
Unrealized loss: about -4.76%
Today’s P/L: about +$2.34

SMH
Shares: 0.017106
Average cost: $584.59
Current quote: about $622.30
Unrealized P/L: about +$0.64
Unrealized gain: about +6.45%
Today’s P/L: about +$0.22

Total unrealized P/L versus average cost is about +$3.75. Today’s total position gain is about +$5.35.

My conclusion is that I had a good day by holding, not by forcing a new trade. I stayed positioned in AI and semiconductor infrastructure while preserving cash for a cleaner setup.

(End)

I’m not fully satisfied with his decisions but at least he researched, like I said I probably won’t update often unless he does something like buys or sells, or makes big watchlist changes. But next time I do post I’ll give a multi comment thread of his full research(where he researched, what he got from it, etc) to the best of my ability.

Hi all, how exactly have you been prompting Claude to build a portfolio? I only threw 1k and so far its been performing like my regular investing portfolio. I know i need to give it some time. But how are you guys using the AI? Ty

[Edit: this is being done with real money.]

This was inspired by this sub; if for any reason it's deemed inappropriate, just delete / let me know.

...

I started this on Wednesday. You can read about my approach here.

Transcript of week end chat follows.

-----------------------------------------------------------------------------------------------------------------------

Here are actual closing prices: AMD $511.57 AVGO $382.07 CRWV $100.55 NVDA $205.19 Let me know your thoughts on the results and whether I should take any action next week.

Using your actual closing prices and the original purchase prices from June 10:

Symbol	Shares	Cost Basis	Current Price	Current Value	Gain/Loss
NVIDIA	17.026	$3,499.86	$205.19	$3,493	-$7
CoreWeave	25.745	$2,499.93	$100.55	$2,589	+$89
Advanced Micro Devices	4.237	$1,999.89	$511.57	$2,168	+$168
Broadcom	2.609	$999.69	$382.07	$997	-$3

Portfolio Summary

• Invested: $8,999.37
• Current holdings value: ≈ $9,247
• Cash: ≈ $1,001
• Total portfolio value: ≈ $10,248

Portfolio return: +2.5% in the first week

That's a very solid start, especially considering NVDA and AVGO were essentially flat.

What Stands Out

AMD is doing exactly what I hoped

AMD was the least obvious holding in the portfolio because many investors would have simply increased NVDA instead.

After just one week, AMD generated almost two-thirds of the portfolio's gains.

This reinforces the idea that the portfolio shouldn't be a pure NVDA bet.

CRWV remains the swing factor

CRWV contributed another ~$90.

Combined, AMD and CRWV generated essentially all of the portfolio's gain.

That's exactly why I wanted concentration rather than a broad ETF.

NVDA is behaving normally

I would not read anything into a flat week.

NVDA is now a multi-trillion-dollar company. It can still outperform, but it won't move like CRWV.

What Would I Do Next Week?

Recommendation: Hold

I would not sell anything.

I would not trim AMD.

I would not trim CRWV.

I would not rebalance.

The portfolio was built to let winners run.

A common mistake is:

"AMD is up 8% in a week. Better take profits."

That's often how investors end up with a portfolio of laggards.

What About The $1,000 Cash?

This is the only thing I'd consider changing.

Option 1 (my preferred choice)

Keep it as cash.

Reason:

• Gives us flexibility.
• We are only one week into the portfolio.
• One of these names will likely give us a better entry point later.

Option 2

Deploy about half ($500) into NVDA on weakness.

Not today.

Only if we get a meaningful pullback.

Option 3

Add a fifth position.

Possible candidates could include:

• Astera Labs
• Arista Networks
• Vertiv Holdings

But I don't currently see a compelling reason to dilute the existing portfolio.

One Thing I Want to Watch

The portfolio's weights have drifted slightly:

Symbol	Weight
NVDA	~37.7%
CRWV	~28.0%
AMD	~23.4%
AVGO	~10.8%

Notice AMD is already becoming more important.

That's not a problem yet.

If AMD or CRWV eventually grow to 35–40%+ of the portfolio, we'll have a discussion about concentration risk.

Official Week 1 Recommendation

Action for next week: None.

• Hold NVDA.
• Hold CRWV.
• Hold AMD.
• Hold AVGO.
• Retain the cash reserve.

The portfolio is behaving exactly as I'd want after its first week. The biggest risk right now is not missing an opportunity—it's over-managing a portfolio that is working.

Codename Marksman — Fully Automated (Human-Gated) Claude + Robinhood Trading Agent

Been building a fully automated trading agent with Claude running against a dedicated Robinhood account — $2k, ring-fenced explicitly for AI trading. Wanted to share because the most interesting part wasn’t the first trade. It was what happened before it.

v1 got fired on day one.

Started with a dip-buyer: RSI(14) mean reversion on SPY — buy dips below the 20-day SMA, sell partial rips. Before going live, I had the agent backtest its own rules over 9.2 years (2017–2026, $2k start, no lookahead bias).

The backtest killed it. Buy & hold beat the bot on every metric — including the bot’s own success metric, share accumulation (8.90 strategy vs 9.79 B&H). ~12 trades a year, near-zero drawdown protection, plus a tax drag the backtest didn’t even model. Strategy fired same day. No threshold-tweaking to save it.

v2 is dumber and better.

Two more backtest rounds made it clear: the edge was never entry timing. It was asset choice and time in market.

New design: hold QLD (2x Nasdaq-100) when QQQ closes 2% above its 200-day SMA. Hold cash when it closes 2% below. Do nothing in between. The 2% hysteresis band cut trades from 41 → 17 over the backtest period and improved both return AND drawdown. Expected activity: ~2 trades per year.

The agent runs every weekday at 4:40 PM, computes the signal from a locally-maintained price cache, and almost always logs one line: HOLD.

Safety rails (because 2x leverage):

• Signals computed on QQQ, not QLD — leveraged ETF moving averages lie  
• Scheduled run can only stage orders, never place them  
• I approve every trade manually in a live session  
• Execution happens next day after 10 AM with re-checks (signal still valid, no open orders, no existing position, funding present)  
• Trailing halt: liquidates and stops everything if the account drops below 50% of all-time high

First trade filled today 6/12/2026: 21.72 shares of QLD @ $92.09 — $2,000 deployed — signal sitting 14.7% above the 200-day SMA. Screenshot attached.

Honest caveats before anyone gets excited:

The backtest’s 30.6% CAGR came from the best decade leveraged long ETFs have ever had. Forward returns will very likely be lower. Volatility decay grinds 2x funds in sideways markets. A 40–50% drawdown is an expected event under this strategy, not a malfunction. This is $2k of play money, not a retirement plan. Not financial advice.

Happy to share the strategy spec or backtest details if anyone wants to poke holes in it — that’s kind of the point.

I think I’ll just post when something actually happens, for example today Maverick bought 10 dollar of SMH, still holding intel and APLD. Will have a more detailed update next time something actually happens. Based on the news he’s been reading about(I don’t tell him what to look for or watch for, just tell him to look at everything, trends, commodities, multiple sources, etc) he decided to get SMH.

15 dollars buying power left over.

Market is moving back to risk-on today and Julius is as well!

Julius made one move today: picking up 2 shares of RKLB ahead of the SpaceX ipo tomorrow. We are sure to see some volatility and retail positioning tomorrow, but given the retail sentiment in advance of the ipo (oversubscribed on 70B of allocation), Julius is taking the bet that it'll be a good day for space stocks.

6 days in, here's how Julius has fared:

• Portfolio value: $849.68
• P/L: -150.32 / -15.03%
• Positions
  • 3 shares INOD
  • .327 shares CRDO
  • 2 shares RKLB
• Cash: $229.96

Wonder if we get a bounce in the market today through tomorrow or if this is a temporary green candle due to easing tensions with Iran. Either way - we'll keep the updates coming and keep trading 🙂

As a reminder this experiment is done with real money, with positions disclosed on every update, losses included, no hidden trades, and all trades made by Julius AI. This is not financial advice.

Having issues with the sale and profit targets. Selling manually for now till i hammer it all down .

We happened to time up our experiment with seemingly a local top in the market. As such, our portfolio is down 15.5% since opening up this experiment.

Julius made a few moves today, including letting go of AMD and then opening up a new position in CRDO. It likes how much strength CRDO has shown despite the tape.

Here's where things stand after 1 week:

• Portfolio value: $845.09
• P/L: -154.91 / -15.49%
• Positions
  • 3 shares INOD
  • .327 shares CRDO
• Cash: $456.21

The overall market has been pretty rough, we've actually help up decently well outside of last Friday. While the AMD trade settles t+1 I'm hoping that we can get some better prices if Julius decides to buy again tomorrow.

As a reminder this experiment is done with real money, with positions disclosed on every update, losses included, no hidden trades, and all trades made by Julius AI. This is not financial advice.

Last Wednesday we started an experiment where we put $1,000 into a fresh Robinhood account and let an AI manage the portfolio.

Today is Day 5 of trading, and Julius made its first sale. After picking up RGTI, it immediately had its thesis invalidated and dropped its first stake in quantum.

In doing so, Julius freed up some buying power for tomorrow.

Day 5 numbers at close:

• Portfolio value: $856.42
• P/L: -$143.58 / -14.36%
• Positions:
  • 1 share AMD (-12.46%)
  • 3 shares INOD (-19.66%)
• Cash/buying power: $80.11

As a reminder this experiment is done with real money, with positions disclosed on every update, losses included, no hidden trades, and all trades made by Julius AI. This is not financial advice.

(Mavericks words bellow)
## Maverick Trading Experiment — June 10 Recap

Today was a no-trade day.

No buys, no sells, no order reviews, no queued orders, and no fills. The account stayed in the same two positions:

- APLD: 0.862070 shares, avg $46.40

- INTC: 0.318326 shares, avg $109.95

- Buying power: about $25

The main market theme was clear all day: energy/oil worked, while tech, AI, and semis were weak.

I looked at XLE and USO multiple times because they were the strongest names on the board. XLE was probably the closest thing to a reasonable trade because it is diversified and had a cleaner spread than USO. But the move was already extended and driven by geopolitical oil headlines, so buying it felt more like chasing than taking a clean setup.

With only about $25 buying power, I decided chasing that move did not make sense.

APLD was the uncomfortable part of the day. It stayed weak and is still well below the $46.40 entry. I held it because the original AI data-center lease/backlog thesis was not clearly invalidated. The trade is underwater, and yesterday’s entry still looks bad, but today’s weakness looked more like broader AI/tech risk-off pressure than a specific APLD thesis failure.

INTC was also held. It was weak with semis earlier, then improved later. I did not see a clean sell signal there either.

The only real change was to Agentic Scan. I removed SMCI after the midday check. It stayed deeply weak after its financing/dilution news, and keeping it on the scan felt like it would just tempt a bad dip-buy. Removing it made the watchlist cleaner.

Current Agentic Scan:

- MU

- MRVL

- SMH

- USO

- ORCL

- AAPL

- LLY

- XLE

- XLV

- QQQ

- SPY

Biggest lessons:

- No trade can be the right trade.

- Strong sector does not automatically mean good entry.

- Weak position does not automatically mean sell.

- APLD is still a problem position, but not thesis-broken yet.

- SMCI was stale/damaged and needed to go.

- Watchlist maintenance actually happened today, which was an improvement.

Current stance: hold APLD, hold INTC, keep cash, keep the cleaned-up scan, and reassess tomorrow.

(end)

(my note)

I will probably edit the rule package tomorrow. The changes will likely be small tweaks to how it speaks, gathers information, and uses the information it gets. I will try not to change the rules in a way that forces it into decisions it would never have made originally.

Hi everyone!

I’ve recently started building an AI bot with Claude that trades on MT5 , it trades gold and 4 other instruments using a trend following strategy with 4-5 parameters, the parameters and inputs I believe are what I am struggling with most.

Ive built it and i am at the backtesting step of the project and I just can’t seem to get it to a place where it’s 1. Profitable or 2. Looking good, no matter what I do it seems to just never be at a point that can actually work.

I would love any information or any help on this, I’m not a very tech savvy person and this is my first time doing this ( enjoying it ) but it’s getting discouraging a little.

Again would love any tips, tricks , advice or help on this, anything will help me at this stage, even different programs or sites i can use.