YT YouTube2Text

YouTube2Text → Transcripts → Full AI Trading Course 2026: Master Agentic Trading (Beginner to Pro)

Full AI Trading Course 2026: Master Agentic Trading (Beginner to Pro) — Transcript

by Alex Carter · 14,406 words · 2,206 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00Right now, while you're watching this,
0:01an invisible war is happening inside the
0:04order books of every major exchange.
0:06Millions of decisions are being made in
0:08milliseconds.
0:10Positions are being hedged, stops are
0:12being hunted, and whales are moving size
0:14without leaving a footprint.
0:17Most people think they're trading
0:18against other people. They aren't. You
0:20are trading against silicon. You are
0:22trading against algorithms that don't
0:24sleep, don't feel fear, and don't make
0:26mistakes. In this course, we aren't just
0:28going to learn about these systems, we
0:30are going to build one. We are going to
0:31move through the complete stack. First
0:33is the brain. We're going to be wiring
0:35Claude to Open Router for
0:37institutional-grade model access.
0:39Second, the eyes. We will be installing
0:41the Hyperliquid whale tracker to see
0:43smart money in real time and the
0:45TradingView MCP to let Claude read your
0:48charts directly. Third, the hands, where
0:50we will be connecting Weeks, Alpaca, and
0:52Interactive Brokers for multi-market
0:54execution. Fourth, the workforce, where
0:57we will be deploying agent frameworks
0:59like Sim Pi, Hermes, and Open Claude.
1:02Specialists that hunt for alpha while
1:03you sleep. Fifth is the command center,
1:06where we will be shipping a custom
1:07Python bot to a 24/7 VPS and unifying
1:11everything into a live ops dashboard. By
1:13the time we're done, you won't be
1:14staring at 12 browser tabs and
1:16second-guessing your entries. You'll be
1:18an operator. You'll wake up to a daily
1:20alpha brief waiting in your inbox, a bot
1:22managing your risk, and a system that
1:24finally puts you on the right side of
1:26the silicon war.
1:28Let's get into it. AI is already a big
1:31part of trading cryptocurrency. Not in
1:33theory, not in some lab somewhere. Live,
1:36on chain, and verifiable. There's a bot
1:39on Polymarket with a wallet address
1:41named sovereign2013
1:43that turned $1 into $3.3 million using
1:46AI. That's not a headline I made up. You
1:49can look it up on chain right now. This
1:51course is built on the blueprint
1:52established by pioneers like Jake
1:54Nesler, who let Claude code run a live
1:57trading stack with $100,000 of real
1:59capital. Every prompt, every drawdown,
2:02and every winning trade was documented.
2:04It proved a vital point. When you give
2:06an agent a wheel, it doesn't just help
2:08you trade, it is the trader. We are
2:10generalizing that exact stack here, add
2:13in three specific skills, five agent
2:16frameworks, and Claude routines to
2:17create a system that doesn't just
2:19survive the market, but masters it. And
2:22on Hyperliquid, an experiment called the
2:24Alpha Arena, took the biggest AI models
2:27in the world, Quinn, DeepSeek, Claude,
2:30GPT, Grok, and Gemini, gave each of them
2:33$10,000,
2:34and let them trade live perpetuals
2:36against each other. The results were not
2:39even close. Some of these models, models
2:41that millions of people are using right
2:43now to make trading decisions, lost the
2:45majority of their account in 4 days. And
2:48one of them did the complete opposite.
2:50AI-powered bots now account for roughly
2:5270 to 80% of all crypto volume. If you
2:56are still trading manually, you are not
2:58competing with other retail traders
3:00anymore. You are the liquidity. You are
3:02the other side of the trade that the AI
3:04is taking. That is not me trying to
3:06scare you. That is just what is
3:08happening right now. And here's the
3:10thing, the tools that are creating this
3:12gap are not locked behind a hedge fund.
3:15They are not expensive. They are not
3:17complicated. Claude costs $20 a month.
3:19The Hyperliquid API is completely free
3:22and public. TradingView, you probably
3:25already have. Telegram, you already have
3:27on your phone. The gap is not about
3:29access. The gap is about knowing how to
3:31put it together. This is the complete
3:33zero-to-hero course for AI trading with
3:36Claude. I am not going to give you
3:38theory. I'm not going to show you a demo
3:40that looks impressive, but falls apart
3:42the moment you try to replicate it.
3:44Everything I show you today, I have
3:46built and run myself. This is what you
3:48should expect, the exact contract for
3:50the next 2.5 hours. Real money, every
3:53tool. Claude plus open router, which
3:56gives you the key for every model.
3:58Three skills live. Wickstrader, Whale
4:00Tracker, and TradingView MCP. Three
4:03brokers connected. Wix, Alpaca, and
4:06Interactive Brokers.
4:08Polymarket plus Kalshi prediction
4:09markets. Claude routines automating your
4:12entire trading day. Agent PNL plus Sempy
4:15plus Hermes plus open claw all deployed.
4:19Custom Python bot on Hostinger running
4:2124/7. Telegram bot in your pocket.
4:24Custom dashboard tracking it all.
4:25Nothing skipped. Every command on
4:27screen. If you already code, skim. If
4:30you don't, then we're going to open a
4:31terminal together. Let's go. Before I
4:33show you anything, I need to say
4:35something that most AI trading videos
4:37will never tell you. Because if you come
4:39into this with the wrong expectation,
4:41you're going to get hurt. Here is what
4:43AI is genuinely good at. Writing code,
4:46building backtest scaffolding,
4:47synthesizing news from 10 different
4:49sources into one clean summary,
4:51sentiment analysis, reading a chart
4:54screenshot and giving you a structured
4:56technical breakdown, journaling your
4:58trades and finding patterns in your own
4:59data, risk logic, and turning a plain
5:02English strategy ideas into working Pine
5:05Script in under a minute. All of that
5:07Claude does better than any human
5:09working alone, faster, more
5:10consistently, and without getting tired
5:13at 2:00 in the morning. Here is what AI
5:15is bad at. Price prediction, full stop.
5:18Claude cannot tell you where Bitcoin is
5:20going tomorrow. Nobody can. And any tool
5:23that claims it can is lying to you,
5:25replacing your judgment. The market will
5:27always throw situations that no model
5:30has seen before. Black swan events,
5:32coordinated manipulation, macro shocks.
5:35AI has no edge in those moments. You do.
5:37And hallucinations. Claude will
5:39occasionally state something confidently
5:41that is completely wrong. A price that
5:44does not exist. A ticker that is not
5:46real. a statistic it invented. It does
5:49not happen constantly, but it happens.
5:52You always verify the critical data
5:53point yourself. So, here's the one rule
5:55I want you to carry through this entire
5:57course. Claude is a research assistant
6:00with execution hands, not an oracle. It
6:03does the work faster than you can. It
6:05catches things you would miss. It runs
6:07while you sleep, but it does not replace
6:09your judgment. It extends it. Keep that
6:12in your head and everything I show you
6:14today will make sense. Forget it and you
6:16will eventually hand an AI your account
6:18and wonder what happened. This course
6:20makes you capable of executing faster,
6:23not capable of predicting markets. Trade
6:25small until your own P&L proves
6:27otherwise.
6:29Now, before we get a deep dive into the
6:31course, here's what you need on your
6:32desk before you start. First, a laptop
6:35or a computer, Mac, Windows 11, or any
6:38modern Linux distro with at least 8 GB
6:41RAM minimum, but a 16 GB is recommended.
6:44Any CPU from the last 5 years is fine.
6:47Second is any reasonable internet
6:49connection. You're not streaming, you're
6:51making API calls. A cafe hotspot works.
6:54Third is at least 2.5 hours of your
6:56time. You can do it in chunks, but the
6:58install spine that covers from modules 3
7:01to 11 will benefit you from one
7:03continuous block. Fourth, a credit card
7:06for a few optional charges. Some tools
7:08needs to be paid like $5 for OpenRouter
7:11credit, $5 for Firecrawl hosting or VPS,
7:14which is around $5 to $8 per month.
7:16Railway for Send API, which is $5 per
7:19month after 30-day trial. Everything
7:21else is free tier. Before we dive into
7:23the modules, let's get your digital
7:25workspace organized. You'll want these
7:27apps open, signed in, and ready on your
7:29desktop. First, terminal. Any modern
7:33terminal will do.
7:34iTerm for Mac, Windows Terminal,
7:37PowerShell, or your default Linux
7:38Terminal. You'll be pasting commands
7:40here starting from module three. Second,
7:43browser. You'll use this to sign in to
7:45Claude, Open Router, Polymarket, and
7:48other essential platforms.
7:50Third, Cursor. You'll need this code
7:52editor to view and edit markdown {dot}
7:55md files, Python {dot} py files, and
7:58dashboard HTML as the course progresses.
8:01Fourth, phone. Keep your phone handy for
8:04Telegram. You'll need it for the
8:05integration steps once we start working
8:07with BotFather.
8:09Now, for the first module, we will talk
8:11about foundation. Before we open the
8:12terminal, we need to align on the mental
8:15model. Most retail traders fail with AI
8:17because they only use it for one thing,
8:20asking for a strategy. That's 5% of the
8:22capability. To win, we install AI into
8:26all three layers of the trading system.
8:28First is research. This is finding the
8:30edge. We're talking about tracking
8:32hyperliquid whales using Firecrawl to
8:35scrape the open web for sentiment and
8:37generating a daily alpha brief that
8:39compresses thousands of data points into
8:41the three things that actually matter.
8:43Second is strategy. This is turning that
8:45edge into rules. We use the TradingView
8:48MCP, which gives Claude 78 specific
8:51tools to auto-build Pine Script, run
8:53backtests, and look for multi-timeframe
8:55confluence.
8:57Third is execution. This is moving
8:59capital.
9:00We use the Wick's Trading Assistant
9:01skill to execute orders, use TradingView
9:04to send commands via webhook, set
9:06agentic risk management, and deploy
9:08custom bots on Hostinger that stay
9:10online 24/7. The edge isn't just one of
9:13these, it's the connection between them.
9:15Now, AI isn't magic, it's a force
9:17multiplier. It gives you four specific
9:20advantages that any retail trader can
9:22now rent for pennies.
9:23Reading speed. It reads 100 filings
9:26while you read one. You can give a model
9:27300 documents and it will return the
9:30outliers in 30 seconds for about 25
9:32cents. Production code. It writes
9:34professional-grade Python. We're talking
9:37CCXT wrappers and SQLite journals that
9:40pass every check and run live on the
9:42first try. Pattern recognition. Our
9:44whale tracker can scan 33,000 wallets in
9:4790 seconds.
9:49It sorts every profitable trader by P&L
9:52and sentiment while you're still
9:53refreshing a tab. Uptime. You sleep, the
9:56bot doesn't. Your system services and
9:59Claude routines run forever. This is an
10:01autonomous stack that earns while you're
10:03offline. Now, before we get into the
10:05tools, let me quickly demystify terms
10:07you're going to hear constantly in this
10:09space. Because if you do not know what
10:11these mean, some of this is going to
10:13feel more complicated than it actually
10:15is. Let's define them now so we don't
10:17slow down later. MCP, the model context
10:21protocol. Think of it like a USB-C port
10:24for Claude. It lets us plug in any
10:26broker, chart, or data source. Open
10:28router. This is our unified gateway. One
10:30API key that gives us access to Claude,
10:33GPT, Gemini, and DeepSeek with automatic
10:36fallback. Claude has what Anthropic
10:38calls skills. Think of them like apps
10:40you install on your phone. Someone
10:42builds a skill for hyper liquid whale
10:44tracking. You install it. Now, Claude
10:46can do that automatically without you
10:48writing a single line of code. I'm going
10:50to show you how to use these later in
10:51the course. API, which means application
10:54programming interface. This is the
10:56machine readable door that connects
10:58Claude directly to Weeks, Alpaca,
11:00Interactive Brokers, TradingView,
11:02everything.
11:03VPS, your virtual private server. A
11:06Linux box we rent for a few dollars a
11:08month so your bot lives in the cloud,
11:10not just on your laptop. Routines.
11:13Anthropic's cloud-hosted tasks. You
11:15schedule a prompt and it runs on their
11:17infrastructure even when your laptop is
11:19closed. Agents. Software that loops. It
11:22plans, acts, observes, and replans.
11:25We'll be deploying five different
11:26frameworks including Senpai, Hermes, and
11:29OpenClaude.
11:30Prediction markets, places like
11:32Polymarket and Kalshi. LLMs are
11:35shockingly good here because they
11:37compress massive amounts of context to
11:39predict real-world outcomes. The skills
11:41thesis and why this course leans heavily
11:44on Claude skills.
11:45Most people think prompt engineering is
11:47the secret. It's not. A skill is a
11:49folder. Inside is a specialized file
11:52that teaches Claude a whole domain,
11:54every command, every edge case, and
11:56every safety fault. By dropping three
11:59specific skills into the system, Claude
12:01suddenly knows how to trade Wix perps,
12:04track hyper liquid whales, and control
12:06your TradingView desktop with 78
12:08built-in tools. No manual coding
12:10required, no prompt engineering, just
12:12plug and play capability. These are the
12:14LEGO bricks. Now, let's go build the
12:16stack. Now, the second module covers the
12:18complete AI trading stack. This is the
12:21one-page map. Every tool, every broker,
12:24every agent platform, and every skill.
12:27If some name sounds unfamiliar right
12:28now, don't worry. Every single box on
12:31this map gets its own dedicated
12:32installation module later. Right now, I
12:35want you to see how the LEGO blocks fit
12:37together. One, models plus OpenRouter.
12:41Everything starts with a key. We use
12:43OpenRouter because it gives us one
12:44single API key to access over 300
12:47models. No vendor lock-in. If Anthropic
12:50goes down, we fall back to DeepSeek or
12:52Quinn in 1 second. Now, Claude has three
12:55different models, all with different
12:56strengths for different output. First is
12:58Claude Opus 4.7. This is the flagship of
13:02Anthropic made for heavy strategy
13:03design, code review, and Polymarket
13:06analyzer reasoning. Second is Claude 4.6
13:09Sonnet. This model will be our
13:10workhorse. 90% of this course runs on
13:13it. Third is Claude Haiku 4.5. This is
13:16for the cheap labor. This is mostly used
13:19for classifying news, triaging routines,
13:22and classification of takes for pennies.
13:24Other models include GPT, Gemini, and
13:27DeepSeek. You can swap these into your
13:29configuration at any time without
13:32changing your routines.
13:33This is incredibly useful for skeptic
13:36panel reviews, where you have multiple
13:38models critique a trade idea before you
13:40pull the trigger. Next is Quinn and
13:42Kimmy. These are your long context open
13:44models. If you need to ingest a 100-page
13:4810K filing or summarize massive log
13:50files on a budget, these are your go-to
13:53tools. Also, with Open Router,
13:55you can even set your model to auto.
13:57This tells the system to automatically
13:59choose the cheapest, most capable model
14:01available for the specific task you're
14:03running. It's the ultimate way to
14:05optimize your overhead while keeping
14:07your Hermes and Open Claw agents running
14:1024/7. All right, before we touch a
14:12single terminal, you need to understand
14:14what Claude actually is. There are three
14:16versions you need to know about. The
14:17first is claude.ai.
14:20This is the browser version. Think of it
14:22as a research assistant. You paste in a
14:24chart screenshot, a news article, a
14:27token contract. It reads it and gives
14:29you a structured breakdown. No code, no
14:32setup. Just open a tab and go.
14:35The second is Claude Desktop with
14:37Cowork. This is where it gets agentic.
14:40Cowork does not just talk. It acts. It
14:43can open apps on your computer, read and
14:46edit files, run scheduled tasks, and
14:48remember context across sessions.
14:51So, it knows what you told it yesterday.
14:53It knows your trading setup. It works in
14:56the background while you are doing
14:57something else. The third is Claude
14:59Code. This is the most powerful version.
15:02It is a command-line tool that writes,
15:04runs, and iterates code autonomously.
15:08This is what built the trading bots I'm
15:09going to show you later. This is what
15:11connects to your exchange and executes
15:13real trades. Now, let's talk about where
15:15the money actually moves. We connect to
15:18three primary brokers, plus prediction
15:20markets, plus the CCXT library for
15:23everything else. First is Wex. This is
15:26our primary crypto broker. It's no KYC,
15:29offers a massive deposit bonus, and most
15:32importantly, it has a V3 API built
15:34specifically for AI integration. It
15:37handles futures and spot in one account.
15:39Second is Alpaca. This is your home for
15:41US stocks and options. It's
15:43commission-free and has the best Python
15:45SDK in the game. It even has an official
15:48MCP server for cloud desktop. Third is
15:51Interactive Brokers. This is for the
15:53pros. If you're trading global markets,
15:55bonds, or CFDs, this is the requirement.
15:58We use the IB Insync Python library for
16:01pro-grade execution. We're also hitting
16:03prediction markets, which is where that
16:05$3 million bot lives I mentioned
16:07earlier. The first one is Polymarket.
16:10This is the global giant for
16:11crypto-funded event betting. Kalshi,
16:14which is the US regulated alternative
16:17for Polymarket. PMXT.
16:20This is a unified SDK that lets us
16:22arbitrage between Polymarket and Kalshi.
16:25If the same event has different prices
16:27on Polymarket and Kalshi, the AI locks
16:30in the profit automatically. And for
16:32everything else, we have CCXT.
16:36This is the universal translator for
16:38over 100 exchanges. It's how we talk to
16:41Binance for backtesting and BlowFin as a
16:43low-latency backup and a Great Weeks
16:46alternative. Finally, there's
16:48HyperLiquid. It has a free public API
16:50that requires no key for data reads.
16:53This is where our whale tracker skill
16:55pulls live data to see what the biggest
16:56fish in the pond are doing. With this
16:59course, you aren't just getting one bot,
17:01you're getting five different
17:02frameworks, where each does one thing
17:04better than the others. Most power users
17:06run a combination of these to cover
17:08every corner of the market. First is
17:10Agent P&L. This is the easiest entry
17:13point. It's a plain English Wex
17:15perpetuals agent. You can go from
17:17copy-paste to live trading in under 2
17:20minutes. It even has a public
17:22leaderboard, so you can see how your
17:24logic stacks up. Second is Sent by. This
17:27is your personal trading powerhouse for
17:29hyper liquid. It comes with 44
17:31specialized MCP tools and is battle
17:34tested with over $100 million in volume.
17:37Under the hood, it's powered by Open
17:39Claw. Third is Hermes. Developed by News
17:42Research, this Python-based framework is
17:45a beast with 95,000 stars on GitHub.
17:48It's self-improving, meaning it
17:49generates reusable skills from every
17:52successful task. It's also your gateway
17:54to Telegram, Discord, and Slack. Fourth
17:57is Open Claw. This is the heavyweight of
17:59the ecosystem with 345,000
18:02stars.
18:03Built on TypeScript and Node.js,
18:06it has the broadest integration
18:08possible, over 50 channels and 13,000
18:11community skills via Claw Hub. Fifth is
18:14Claude Routines. These are Anthropic's
18:16cloud-hosted scheduled tasks. This is
18:19how your logic stays alive and running
18:21even when your laptop is closed. You
18:23don't have to choose just one. We're
18:25going to install all five and you'll
18:26pick the combination that fits your
18:28specific trading style. Finally, we drop
18:30three super skills directly into your
18:32Claude code. This is the unfair
18:34advantage of this course. Whale Tracker,
18:36real-time hyper liquid whale research
18:38with zero API keys.
18:40TradingView MCP, 78 tools that let
18:43Claude literally control your
18:44TradingView desktop, scanning charts and
18:47writing Pine Script for you. We X
18:48trading assistant that lets you execute
18:50trades all in plain English.
18:52Individually, these tools are powerful.
18:55Combined, they create the daily alpha
18:57brief, where your AI tracks the whales,
18:59reads the charts, checks your portfolio,
19:02and hands you the day's setups on a
19:04silver platter. Study the map on this
19:06page. Bookmark the labels you don't
19:08know. Let's start plugging them in,
19:10which is exactly what we're going to do
19:12in the next module. In this module, we
19:14are installing every essential tool
19:16you'll need throughout the course. Five
19:18installs. Five verify commands and one
19:21project folder. This is the foundation.
19:23Every module that follows assumes this
19:25setup is perfectly in place. If you skip
19:28a step here, the bots won't run, the API
19:31won't connect, and you'll be
19:32troubleshooting code instead of trading
19:34markets. We're going to open five tabs
19:36and install these in order. Let's get to
19:38work. First is Python 3.12 or higher. Go
19:42to python.org, click on on download
19:45Python. Once the installer is
19:46downloaded, a pop-up will appear. Click
19:49on install Python and click yes to
19:51accept the terms. If you're on Windows,
19:53this is the most important part. Tick
19:55the box that says add Python to path
19:58during the install. If you miss that,
19:59nothing else works.
20:01If you're on Mac and have Homebrew, you
20:03can type the install command from the
20:04notes below instead. Second is node.js.
20:08Get the LTS version from nodejs.org.
20:12This is the engine for our MCP servers
20:14and the Open Claw framework we'll deploy
20:17later. Choose your operating system.
20:19Since I'm using Windows, I'll select the
20:21Windows installer. Accept the license
20:23agreement, then click next until the
20:25installation is complete. Third is Git.
20:27Download it from git-scm.com.
20:31We'll be using this to clone or copy the
20:34trading skills and bot repositories
20:36directly to your machine. Just accept
20:38the default settings during the install.
20:40Fourth is Cursor. This is our command
20:42center. Go to cursor.com. It's an AI
20:44native editor that allows Claude to
20:46actually see your code files. Click on
20:48download in the upper right corner.
20:50Accept the agreement, then click next
20:52until it installs. Fifth is your
20:54terminal. If you're on Mac, use the
20:57built-in terminal or iTerm2. On Windows,
21:00use Windows Terminal from the Microsoft
21:02Store, and always select the PowerShell
21:04tab. Never use the old cmd.exe. Once you
21:07can open PowerShell, you're done. Now,
21:10let's create your trading AI folder.
21:12This keeps the course clean and ensures
21:14Claude knows exactly where to look. Open
21:16your terminal and type the command on
21:18the screen. Everything we build from
21:20this point forward, every skill, every
21:22config file, goes inside this folder.
21:25Before we move to module four, we need
21:27three green lights. Type these into your
21:29terminal one by one. pi dash dash
21:31version. This must be 3.12 or higher.
21:35node dash version. You're looking for
21:37V22 or higher. git dash dash version.
21:41Anything in the 2.4 range is perfect. If
21:44you get a command not found error for
21:46Python on Windows, it's because you
21:48didn't tick that add to path box. Don't
21:51fight it, just rerun the installer. If
21:53node isn't showing up, close your
21:55terminal completely and reopen it to
21:57refresh the system. If you see those
21:59version numbers, you are officially
22:01ready. Your computer is no longer just a
22:03laptop. It's a high frequency
22:05workstation. Take a breath, close your
22:07browser tabs. In the next module, we are
22:10installing Claude code and wiring up
22:12your OpenRouter master key. Let's get
22:14into it. In this module, we are
22:16installing Claude desktop, the Claude
22:18code CLI, and signing up for OpenRouter.
22:21By the end of this module, you will have
22:23one master key that points Claude at
22:25over 300 different AI models. With
22:28Sonnet 4.6 as your default workhorse and
22:31Opus 4.7 for the heavy lifting. First,
22:35go to claude.ai. I highly recommend the
22:37pro plan for $20 a month. It unlocks
22:39Claude code and gives you the usage caps
22:41you need to actually trade. If you're
22:43planning on running whale alerts and
22:45risk checks 24/7, the max plan is the
22:47move. Once you've picked a plan,
22:49download Claude desktop. Keep it pinned
22:51to your taskbar. Later in the course,
22:53we're going to plug our MCP servers
22:56directly into this app so Claude can see
22:58your charts and files. Now, open that
23:00terminal we set up in from the last
23:02module. We are installing Claude code.
23:05This is the command line interface where
23:0770% of this course happens. Copy the
23:10install command from the notes below. If
23:12you see v2.x, you're live. Go ahead and
23:15type Claude to run it for the first
23:17time. It will give you a link to your
23:18browser. Just sign in with your pro
23:20account to authenticate. Next,
23:22openrouter.ai. Sign up, then on the
23:25dashboard, click on get API keys and
23:28create a new key named trading AI
23:30course. Copy that string starting with
23:32SK or V1. Save it in a password manager
23:35immediately. Never paste this key into a
23:38public GitHub or chat room. This key is
23:40essentially a credit card for AI models.
23:43If you leak it, bots will drain your
23:45credits in seconds. Go to credits and
23:47add a minimum of $5. At our scale, that
23:50will last you weeks of Sonnet usage.
23:52Now, we have to tell Claude code to use
23:55open router instead of talking to
23:56Anthropic directly. This gives us the
23:59fallback protection if one provider goes
24:01down. We need to create a settings file.
24:03In your terminal, you're going to create
24:05a folder called .claud and a file called
24:08settings.json.
24:09Inside that file, you're going to paste
24:11the configuration block from the course
24:13notes. Replace the placeholder text with
24:15your actual open router key. This tells
24:18the system, use open router as the base
24:20URL and use Sonnet 4.6 as my primary
24:24model. Now, a quick alternative if you
24:27want to keep things simple. If you
24:29prefer to use direct Anthropic billing
24:31and don't care about the multimodal
24:32fallback, you can skip open router
24:35entirely. It's a great fallback to keep
24:37in your back pocket and you can always
24:39switch between the two later as your
24:41stack grows. Let's verify the wiring. Go
24:44back to your terminal, enter your
24:45trading folder and type Claude. Once
24:47inside, ask it, "What model are you
24:49running on?" Reply with the full model
24:51ID. If it says Anthropic/Claude 3 Sonnet
24:554.6 or Opus 4.7 and via open router, you
24:59have successfully built an AI
25:00workstation that can think across any
25:02model on the planet. Finally, we're
25:04going to create a file called claude.md
25:07in your project route. This is Claude's
25:09persistent memory. Paste the house rules
25:12from the notes into this file. This
25:14ensures that every time you open Claude,
25:17it remembers your brokers, your risk
25:19limits, and your goal. And this is how
25:21you execute faster and trade smarter
25:23with Alex Carter. Now, the brain is
25:26online. In the next module, we will
25:28start connecting it to the exchanges.
25:30Now, for this module, we will connect
25:32Claude to WEX, which is our primary
25:34crypto broker. We're using WEX because
25:37it is built for this specific type of AI
25:39automation. It has a V3 API that's
25:42incredibly stable. It offers a $30,000
25:45deposit bonus for new accounts, and it
25:47allows you to get live in about 90
25:49seconds with no KYC required for initial
25:52trading.
25:53Full transparency, we partner with WEX.
25:56We chose them because their API doesn't
25:58choke when an AI agent like Claude
26:00starts firing multiple requests per
26:02second. If for any reason WEX doesn't
26:05work in your region, don't panic. This
26:07entire course is CCXT compatible,
26:11meaning you can swap WEX for Binance or
26:13Kraken with a single line of code, and
26:15which we will cover later on this
26:16course. First, use the VIP link in the
26:19notes below to sign up. Use a strong,
26:21unique password. Verify your email and
26:24make sure that VIP code is attached so
26:26you qualify for the trading credits.
26:29Before you touch the API, you must
26:31enable two-factor authentication. Go to
26:33account, then security, and turn on
26:35Google Authenticator. WEX will not even
26:37allow you to create API keys without
26:39this. Save your backup codes offline. If
26:42you lose your phone and your backup
26:44codes, you'd lose the account, period.
26:47Now, fund your wallet. Click on deposit.
26:49I recommend using USDT via the Polygon
26:51or TRC-20 networks. They have the lowest
26:54fees. Once the funds land, transfer them
26:57from your spot wallet to your futures
26:59wallet. Our AI agents trade out of the
27:01futures wallet by default. Never fund
27:04more than you are comfortable losing.
27:06Remember, most retail derivatives
27:08accounts lose money. Start small.
27:10Now, let's create the machine's
27:11credentials. Go to API management and
27:14create a new key. Label it AI trading
27:17bot. You must tick these three boxes and
27:20only these three. First is read, so the
27:23AI can see your balance. Second is trade
27:25via spot or futures,
27:27so the AI can execute orders. Third is
27:30IP whitelist. This is non-negotiable. If
27:34you see a withdrawal box, never enable
27:36it. If your API key ever leaks and
27:38withdrawal is enabled, your funds are
27:40gone. By whitelisting your current IP
27:43address, you ensure that even if someone
27:45steals your key, it physically won't
27:48work from any other computer but yours.
27:50Weex is going to give you three values:
27:52an API key, an API secret, and a
27:55passphrase. Weex shows that secret
27:57exactly once. If you close the window
27:59before saving it, you have to delete the
28:02key and start over. Copy all three and
28:04put them straight into your password
28:06manager. Do not put them in a text file.
28:09Do not email them to yourself. You now
28:11have a funded account, 2FA's live, and
28:13you have your three credentials tucked
28:15away in a secure spot. In module eight,
28:18we're going to drop these into Claude
28:19and let the agent take its first look at
28:21the markets. But first, we need to
28:23handle your equity in global markets,
28:25which we will cover in the next module.
28:27Now, in this module, we're moving into
28:29the heart of the US markets. We use
28:32Alpaca because it is quite simply the
28:35only broker that makes Claude-driven
28:36trading trivial. Why Alpaca? First,
28:39commission-free API trading. Zero fees
28:42on US stocks and ETF. Second, the paper
28:45trading is instant. You sign up and you
28:47get a $100,000 fake money account with
28:50zero KYC to start. Third, it supports
28:53fractional shares. You can tell Claude
28:55buy $50 of Apple and it handles the math
28:58for the decimal shares. But the killer
29:00feature is the official MCP server. This
29:03drops straight into Claude desktop
29:05giving Claude trading hands without you
29:08writing a single line of Python. Go to
29:10alpaca.markets and sign up. Once you
29:13verify your email, head to your
29:15dashboard. Look for API keys and make
29:17sure you select paper first. Generate
29:20your keys and copy both the key ID and
29:23the secret key immediately. Label these
29:25clearly in your password manager as
29:28Alpaca paper. It is shockingly easy to
29:31accidentally fire a live order when you
29:33think you're on paper. Don't be that
29:35guy. Now, we're going to give Claude
29:37desktop its hands. We need to edit a
29:40file called Claude desktop config.json.
29:43In the course notes, find the Alpaca MCP
29:46block. You're going to paste that into
29:48your config file replacing the
29:50placeholders with your paper API keys.
29:53Make sure the line that says
29:55Alpaca_paper
29:56is set to true. Once you save that file,
29:59restart Claude desktop completely. Quit
30:01the app then reopen it. This is the
30:03moment. We're going to give Claude a
30:05plain English prompt. Claude, use Alpaca
30:07to buy $200 of NVDA at market on the
30:10paper account. Show me my balance first
30:12to confirm we're on paper then place the
30:14order. Watch what happens on your
30:16screen. Claude will call the balance
30:18tool, verify the Alpaca_paper flag is
30:21true, then fire the order. If you have
30:23your Alpaca dashboard open in a browser
30:25tab, you'll see that order appear in
30:28under a few seconds. From this, you can
30:30give Claude prompts for stocks plus ETF,
30:33fractional options, and more. You now
30:36have a system where you can manage your
30:37entire portfolio with natural language.
30:41You can ask for your daily P&L, scan
30:43options chains for next Friday, or add
30:46Meta and Microsoft to a new AI watch
30:48list. In module 12, we're going to take
30:50this a step further by combining this
30:52Alpaca data with your week's crypto
30:54positions to create a unified daily
30:57alpha brief. Your stock market engine is
30:59officially online. Now, in this module
31:01is for the more advanced traders. If you
31:04plan on trading global markets, futures,
31:06or forex at a professional scale, you
31:09will eventually land at Interactive
31:11Brokers. While retail apps are great for
31:13getting started, IBKR is the end game
31:16broker. It gives you one login to trade
31:18nearly every major exchange on the
31:20planet, from New York to Tokyo. A quick
31:22warning, IBKR is a serious institution.
31:26Their KYC process takes about two to
31:28three business days for approval. If
31:30you're watching this right now, go sign
31:32up today. Everything else in this course
31:34still works while you wait for approval,
31:36and you can start on their paper trading
31:38account immediately.
31:40Go to interactivebrokers.com and open an
31:43account. Choose individual. The light
31:46version is for casual investors. Pro is
31:48the one that gives us the API access we
31:51need. Once you're approved and funded,
31:53you're ready to connect the machines.
31:55Unlike Wix or Alpaca, IBKR API requires
31:59their desktop software to be open and
32:01logged in on your machine. You can use
32:03the newer IBKR desktop or the classic
32:06Trader Workstation. For this course, I
32:08recommend TWS. It is the battle-tested
32:11gold standard for API. Once you're
32:13logged into TWS, go to configuration,
32:16then API, and then settings. Check the
32:19box that says enable active X and socket
32:22clients. Uncheck read-only API. We need
32:25Claude to have trading hands. Take note
32:28of your socket port. It should be 7497
32:31for paper and 7496 for live. The
32:34official IBKR API is notoriously
32:37difficult to code from scratch. That's
32:39why we use the IB InSync library. It's
32:42the Python wrapper that every serious
32:44retail algo trader actually uses. Go to
32:47your terminal and run this. In the notes
32:49below, you'll find a 25-line Python
32:52script. This is the moment we bridge the
32:54gap. We're going to run a script that
32:56connects to your local TWS session,
32:58identifies the Apple stock contract, and
33:00fires a buy order for one share. Run the
33:03script and in under 2 seconds, you'll
33:05see the order fill inside your TWS
33:07dashboard. What's powerful here isn't
33:10just buying one share of Apple, it's
33:11that with three words of code, you can
33:13switch from stocks to S&P 500 futures or
33:17forex pairs. You are now trading at the
33:19same level as the hedge funds. Right
33:22now, there isn't a native MCP for IBKR
33:25as stable as Alpaca's, but we don't need
33:27one. Because we've installed the
33:29IB-InSync library, we can simply ask
33:32Claude code to write our scripts for us
33:34on demand. You can ask Claude, "Write a
33:36Python script to check my open positions
33:38and close any that have a loss of more
33:40than 3%." Claude writes it, you run it,
33:43and the job is done. One final rule for
33:45your Claude.md file, always tell Claude
33:48to default to port 7497.
33:51Never assume you are on a live port
33:53unless you explicitly say so. Your
33:55professional bridge is built. You now
33:57have the crypt engine, the stock market
33:59engine, and the global pro tier engine
34:02all ready to go. In this module, we are
34:04officially moving into the execution
34:06layer. Up until now, we've been building
34:08the machine. Now, we're giving it its
34:10first set of specialized skills. In this
34:13part of the course, we are installing
34:14the Wix trading assistant. This isn't
34:17just a basic bot, this is a deep
34:19integration that allows Claude to open
34:21leveraged futures, calculate position
34:23sizes based on risk math, and attach
34:26stop-loss and take-profit orders, all
34:28from a single sentence in plain English.
34:30Open your terminal, navigate to your
34:32trading AI folder, and launch Claude
34:34code. We're going to give Claude its
34:36first skill by pointing it to the
34:38repository. Copy and paste the install
34:41prompt from the notes. You'll watch
34:43Claude perform a Git clone to pull the
34:45skill into its specialized folder, read
34:47the documentation, and summarize the
34:49tools it just learned. Once it's done,
34:51ask Claude, "Check if the Y Trader skill
34:53is installed and list its tools by
34:55category." You should see a menu of
34:57tools covering everything from account
35:00balance to market data and futures
35:02execution. Now, we need to feed Claude
35:04the Wix credentials you saved in module
35:075. The safest way to do this is through
35:09your shell configuration. Tell Claude,
35:12"Help me open my shell config file so I
35:13can add environment variables for the
35:15Wix skill." Claude will identify whether
35:18you need to edit your Z S H R C on Mac
35:20or your profile on Windows. You'll paste
35:23in your API key, secret, and passphrase.
35:26Once you save that file, reload your
35:28shell, and relaunch Claude. Your machine
35:30is now authenticated and ready to trade.
35:33Let's test the connection. Give Claude
35:35this prompt, "Use the Wix skill to check
35:37my futures balance. Show equity,
35:39available margin, and unrealized P&L."
35:42Claude will reach out to the Wix servers
35:44and return your real-time account data.
35:46If you see an unauthorized error,
35:49double-check your API secret and your IP
35:51whitelist from module 5.
35:54Now, the moment you've been waiting for.
35:56We are going to execute a real
35:58risk-managed trade with one prompt.
36:01"Check the current Bitcoin price, then
36:03calculate a position size for a long
36:06where I risk exactly 2% of my portfolio
36:10with a 3% stop loss and 10 times
36:12leverage. Execute with SL and TP at 2.5
36:16times my risk." Watch the terminal.
36:18Claude doesn't just guess. It fetches
36:20the price, checks your actual equity,
36:22does the math to find the exact number
36:24of contracts, fires the order, and then
36:27attaches the stop loss and take profit
36:29orders immediately. Keep in mind, this
36:31is a real trade. If you just want to
36:33watch tell Claude to do a dry run only.
36:36The skill will show you the exact JSON
36:38it would have sent without actually
36:40spending a dollar. The Wick's trading
36:42assistant is now your 24/7 execution
36:45desk. It handles futures with up to 125
36:48times leverage. It handles spot buying
36:51and selling. It generates daily reports
36:53and journals your trades. It can even
36:55copy a setup from a screenshot. Tone,
36:58finality.
36:59You just went from a retail trader to an
37:01AI augmented operator. I'll see you in
37:03module nine where we install the whale
37:05tracker and start hunting for alpha. In
37:07this module, we will plug into what I
37:10call the most valuable free data set in
37:12all of crypto, on-chain whale activity
37:14on hyper liquid. Here's the beauty of
37:16this skill. No API keys, no sign-ups, no
37:19monthly subscriptions. Just pure public
37:22data piped directly into Claude code.
37:24We're giving your AI the ability to look
37:26at the smartest money in the world and
37:28ask, "What are they holding right now?"
37:31Hyper liquid is a decentralized exchange
37:33where every single position is public.
37:36Entry prices, sizes, liquidations, it's
37:39all there. The whale tracker skill wraps
37:41that data into functions Claude can
37:43understand. Instead of spending hours
37:45digging through block explorers, you
37:48just ask in plain English, "Who is net
37:50long Bitcoin right now?" and get an
37:52answer in seconds. First, we need one
37:54lightweight Python package called
37:56requests. This is what allows the skill
37:58to talk to the internet. Open your
38:01terminal and run this prompt. Now, let's
38:03install the skill. Go to this link and
38:05click download skill. Unzip the folder.
38:08We need to move it into your {dot}
38:09Claude {slash} skills directory. Copy
38:12the commands from the notes below.
38:14There's one for Mac and a specific
38:16PowerShell version for Windows. Once
38:18that folder is moved, relaunch Claude
38:20code. You've just given your assistant a
38:22set of on-chain eyes. Let's see it in
38:25action. This is the moment that usually
38:27goes viral. Drop these prompts into
38:29Claude. What are the top 20 whale
38:30traders doing on hyperliquid right now?
38:33Give me their aggregate net exposure,
38:35the three most crowded longs, and any
38:37wallet that flipped direction in the
38:39last 24 hours. Keep it tight. I want to
38:41read this in 60 seconds.
38:43Watch as Claude parses thousands of data
38:46points, groups them by asset, and spits
38:48out a high-signal report. You now know
38:51exactly where the smart money is
38:52positioned before you ever place a
38:54trade. In the notes, I've given you
38:56seven signature prompts to steal. These
38:59are the exact ones I run every morning.
39:00Use smart money versus wrecked money to
39:03see where the winners and losers
39:05disagree. That is often where the
39:06asymmetric setup lives. Use the morning
39:09alpha scan to see what happened
39:10overnight while you were sleeping. Copy
39:13these into your clawed.md
39:15file under a favorites heading. That
39:17way, they're always just one click away.
39:20Your workflow just changed forever. No
39:23more Twitter bias or guessing. You are
39:25building your trade ideas on hard data.
39:27You know what the whales hold before you
39:29decide your own direction. But research
39:32is only half the battle. You still need
39:34to see the charts. I'll see you in
39:36module 10, where we give Claude control
39:38over your TradingView.
39:40In this module, we will unlock the
39:42single best skill in the entire course.
39:45We are installing the TradingView MCP.
39:48Up until now, Claude has been smart, but
39:49it's been blind. It had to rely on you
39:52to tell it what the charts look like.
39:54With these 78 new tools, Claude stops
39:56guessing and starts engineering. It can
39:58now read candles directly, write and
40:00debug Pine Script V6, run backtests, and
40:03this is the game-changer, auto-optimize
40:06your strategies while you go get a
40:07coffee. What does 78 tools actually
40:10mean? It means Claude can switch symbols
40:12and time frames, add indicators, and
40:14pull the full report from the strategy
40:16tester. It doesn't just see a chart, it
40:19sees an editable canvas. If a strategy
40:21isn't working, Claude can iterate on the
40:24code and retest it until it finds a
40:26profit factor that meets your standards.
40:28Let's get the repo onto your machine.
40:30Open your terminal and run this prompt.
40:32During the install, you might see a play
40:34right prompt. Say yes and let it
40:36install. This is the automation engine
40:38that allows Claude to drive the browser.
40:41Now we have to tell Claude where the
40:43server lives. You're going to open your
40:45.mcp.json
40:47file in your .claude folder and merge
40:49the block from the course notes. Make
40:51sure you replace the absolute path with
40:54the real location of the folder on your
40:56computer. If you're on a Mac, just type
40:58pwd inside the folder to get the exact
41:01string. This tells Claude, "When I ask
41:03for a chart, use this specific engine to
41:06go get it." To let Claude control your
41:08charts, we have to launch a debug
41:10version of Chrome. The repo handles this
41:12for you with helper scripts. If you're
41:14on Mac, run this. If you're on Windows,
41:16use this. This will open a new Chrome
41:18window, log in to TradingView, and keep
41:21this tab open. This is the bridge Claude
41:23uses to reach into the chart. Let's see
41:26the real power. We are going to ask
41:27Claude to not only write a strategy, but
41:29to brute force the best settings for us.
41:33Claude will write a dual EMA crossover
41:35strategy, then it will systematically
41:37run dozens of variations, changing the
41:39fast EMA, the slow EMA, and the ATR
41:43multiplier. It will rank them by profit
41:45factor and hand it you the top five
41:47winning variants with their exact
41:49inputs. You just did a week's worth of
41:51manual backtesting in under 5 minutes.
41:53You now have 78 tools at your disposal.
41:56Your stack is complete. You have the
41:58reasoning core, the whale tracker for
42:00on-chain alpha, and the TradingView MCP
42:03for technical mastery. I'll see you in
42:05module 11, where we combine all three
42:07into your daily alpha brief. Your agent
42:10can now read charts and track whales,
42:12but it's still missing one thing, the
42:13news. To trade at a high level, your AI
42:16needs to see what's happening on the
42:18open web. From CoinGecko and earnings
42:20calls to FOMC minutes and exchange blog
42:23posts, we're using Firecrawl because it
42:25does something incredible. It takes any
42:27messy URL and turns it into clean,
42:30machine-readable markdown. It strips
42:33away the ads and the clutter, handing
42:34Claude exactly the data it needs to make
42:37a decision. First, head over to
42:39firecrawl.dev.
42:40Create a free account. The free tier is
42:42more than enough to follow along with
42:44this course. Grab your API key. It'll
42:46start with FC-. Copy that key and put it
42:49into your password manager. We are about
42:52to wire it directly into your Claude
42:53desktop. Open Claude desktop. Inside
42:56this, you're going to merge the
42:57Firecrawl block from the course notes.
43:00Paste in your API key, save the file,
43:02and fully quit Claude desktop. You
43:05should now see new superpowers like
43:06Firecrawl scrape, crawl, and search.
43:09Claude can now officially browse the
43:11internet. Let's prove the pipeline
43:13works. Give Claude this prompt. Use
43:15Firecrawl scrape on the CoinGecko
43:17Bitcoin page and return the current
43:19price, 24-hour volume, and the top three
43:22exchanges. Watch how it works.
43:25Claude doesn't just guess the price
43:26based on its training data. It reaches
43:28out to the live site, reads the current
43:30numbers, and summarizes them for you in
43:32seconds.
43:34Firecrawl's powerful, but you have to
43:35use it strategically.
43:37If you need on-chain data, stick with
43:39the whale tracker. If you need price
43:41action, use the TradingView MCP. But if
43:44you need news, earnings reports, or
43:46project documentation, that's where you
43:48call Firecrawl. Don't waste your credits
43:51scraping static information like
43:52Wikipedia that Claude already knows. Use
43:55Firecrawl for live data that moves
43:57markets. I've included three prompts in
43:59the notes that are absolute
44:01game-changers. Use the macro pulse to
44:03scrape the latest Federal Reserve
44:05statement and have Claude rate how
44:07hawkish it sounds on a scale of 1 to 10.
44:10Use the news digest to pull the last six
44:12articles from a major crypto news site
44:15and summarize only the ones that could
44:16move the market in the next 24 hours.
44:19Your intelligence stack is officially
44:21complete. You have the reasoning core,
44:23the whale tracker, the chart vision, and
44:26now web access. In the next module, we
44:29are going to combine all of these into
44:31the holy grail of this course, the daily
44:34alpha brief. This is the moment
44:35everything you've installed starts
44:37talking to each other. We are moving
44:39past tools and into a system of
44:41intelligence. The daily alpha brief is a
44:44single master prompt that chains weeks,
44:47the whale tracker, the TradingView MCP,
44:50and FireCrawl into one morning briefing.
44:52This isn't just a summary, it is the
44:54research loop that replaces your entire
44:56doom scroll routine. In under 2 minutes,
44:59it tells you exactly what to watch, why
45:01you're watching it, and what size you
45:03should trade. Up to this point, we
45:05focused on research. No trades fired.
45:07That's intentional. You want your agent
45:09to understand the market before it
45:11touches your money.
45:12The daily alpha brief provides four
45:14distinct layers of truth. The macro
45:16layer, Fed chatter and overnight news
45:19via FireCrawl.
45:20The on-chain layer, smart money
45:21positioning via the whale tracker. The
45:24technical layer, trend and support and
45:26resistance via TradingView. The
45:28portfolio layer, your current risk and
45:30available margin via the week scale.
45:33When these four talk to each other,
45:34hallucination liquidations disappear.
45:37I've provided the master prompt in the
45:39notes below.
45:40This is your daily ritual. When you
45:42paste this into Claude code, you're
45:44going to see a symphony of tool calling.
45:46Claude will scrape the headlines,
45:48aggregate whale exposure, read the
45:504-hour charts for Bitcoin and Solana,
45:52and check your actual account balance.
45:55It then synthesizes all of that into a
45:57single trade plan. It picks the highest
45:59conviction setup, sizes it based on your
46:02account risk, and outputs the exact
46:04order you need to place. We don't want
46:07to copy-paste this every morning. We
46:08want efficiency. Take that prompt and
46:11drop it into your claude.md file under
46:14the heading {slash} daily alpha. Now,
46:17you can just type {slash} daily alpha in
46:19your terminal and Claude will execute
46:21the entire chain automatically. You've
46:23just turned a complex multi-tool
46:25workflow into a single keystroke. Once
46:27you've lived with this for a week, you
46:29can start upgrading the brief. You can
46:31pipe the text into 11 Labs so your AI
46:33reads the market to you while you're
46:35making coffee. You can ask Claude to
46:37assign a confidence score from 1 to 10
46:39and only show you setups that are seven
46:41or higher. You can even have Claude
46:43append every brief to a markdown
46:45journal, making your research fully
46:47auditable over time. You're no longer a
46:49retail trader guessing at the next move.
46:52You're an operator running a
46:53professional research desk. The stack is
46:55live. The brief is running. In the next
46:58section of the course, we move into
47:00autonomous operations. I'll see you in
47:02the next module.
47:04Up until now, you've been the one
47:05triggering the AI. You type the command,
47:07Claude does the work. But the goal of
47:09this course is to build a system of
47:11intelligence that works while you sleep.
47:14Enter Claude routines. This is
47:16Anthropic's native cloud-hosted
47:18environment. You set a cron-style
47:20schedule, pick your tools, and Claude
47:22runs your logic in the background. It
47:24can email you a summary, fire an alert
47:26to your phone, or trigger an MCP side
47:29effect. This is the easiest way to make
47:32your daily alpha brief completely
47:33self-driving. Head over to this site,
47:36log in with your pro or max account.
47:38Keep an eye on your plan limits. As of
47:402026, pro users get five routine runs
47:44per day, while max users get up to 15.
47:47You want to budget these wisely. Don't
47:48run a research scan every 5 minutes if
47:51you're on a pro plan. Save them for the
47:53high-impact moments. Let's turn your
47:55module 12 research into a routine. We'll
47:58set this to run every weekday at 7:30
48:01a.m. so it hits your inbox before the
48:03market opens. Paste this routine
48:06setting. Paste the full master prompt
48:08from the previous module. Now, instead
48:10of you asking Claude for the news, the
48:13news finds you. This routine is your
48:16radar. We'll set it to run every 2 hours
48:1924/7. The prompt is simple. Check the
48:22top 20 hyperliquid wallets. Only reply
48:25if a top 10 wallet opens a position
48:28larger than $5 million or if a whale
48:30flips direction on Bitcoin. Tell Claude,
48:33if no criteria are met, reply with the
48:35word skip. This prevents your inbox from
48:38getting cluttered with nothing to report
48:40emails. You only get notified when there
48:42is actual blood in the water. This is
48:45the most important routine you'll ever
48:46set up. It's a safety net. Set this to
48:49run every hour during your active
48:51trading window. It pulls your open
48:53positions across Weeks, Alpaca, and
48:56Interactive Brokers. It calculates your
48:58total open risk and checks for any
49:00position missing a stop loss. If you've
49:03drifted past your 2% risk limit, Claude
49:05flags it immediately. It's the unsexy
49:08work that keeps you in the game. So,
49:10when do you use a routine versus a local
49:13script? Claude routines are perfect for
49:15read and report tasks. They require zero
49:18infrastructure and run even if your
49:20laptop is at the bottom of a lake.
49:22However, if you want to run arbitrary
49:24Python code or place complex automated
49:27orders without a human in the loop,
49:30you'll need a VPS. We're going to build
49:32that pro tier setup in module 24 using
49:35Hostinger. For now, set up your first
49:37three routines. Let the AI start doing
49:39the heavy lifting.
49:41In this module, you are going to ship a
49:42full Pine Script version 6 strategy from
49:45plain English. We're going to add
49:47confluence filters, draw support and
49:49resistance automatically, and debug
49:51those frustrating red squiggles just by
49:54describing them out loud to Claude. We
49:56start with a clean sheet, open your
49:57terminal, launch Claude code, and give
50:00it the rules for a classic trend
50:02following setup. Claude doesn't just
50:04write the code in a text box, it uses
50:06the MCP to open the Pine editor on your
50:09screen, paste the code, and compile it.
50:12If there's an error, Claude sees it and
50:14fixes it before it ever hands the
50:15strategy back to you. A basic strategy
50:18is often too noisy. We need to filter
50:20for high probability environments. Tell
50:23Claude to take that same strategy and
50:25add confluence filters. We'll restrict
50:28trades to the London and New York
50:29sessions, ensure the daily trend is in
50:32our favor, and crucially require a
50:35minimum amount of volatility. Claude
50:37will update the code and show you
50:39side-by-side stats. You'll see exactly
50:41how those filters affected your profit
50:43factor and your drawdown. We aren't just
50:46guessing that a filter works, we're
50:48proving it with data. Claude can also
50:50handle the visual side of the chart. We
50:52can ask it to write an indicator that
50:54auto detects the five strongest
50:56horizontal levels using pivots from the
50:59last 500 bars. Ask it to color support
51:02green and resistance red. In seconds,
51:05Claude writes the math, compiles the
51:07indicator, and publishes it directly to
51:09your live chart. You now have a
51:11custom-built technical analysis tool
51:13tailored to your specific style. When a
51:16script won't compile, stop Googling the
51:18error codes. Just copy the error message
51:20from the bottom of your TradingView
51:22screen and paste it into Claude. Claude
51:25uses the MCP to read the source code,
51:27identifies the root cause, whether it's
51:30a version mismatch or syntax error, and
51:32recompile the fix instantly. It's like
51:35having a senior Pine Script developer
51:37sitting right next to you. Before you
51:39get excited about a backtest, run it
51:40through the honesty filter. Sample size.
51:43If the strategy has fewer than 100
51:45trades, it's just noise. Cost, always
51:48tell Claude to include commission and
51:49slippage in the settings. Real trading
51:51isn't free. Repainting. Ask Claude to
51:54verify that no look-ahead indicators are
51:57used. A strategy that knows the future
52:00on a backtest will blow up your account
52:02in the real world. You now have the
52:04power to engineer an edge from scratch.
52:07In this module, we are building your
52:09mobile control plane. We're going to use
52:11Telegram's BotFather, install the
52:13official Telegram plugin for Claude, and
52:16pair your phone. By the end of this
52:18video, your entire trading stack, the
52:20whales, the charts, and the brokers,
52:22will be accessible from a single chat
52:24window in your pocket. First, open
52:26Telegram and search for @BotFather.
52:29This is the official way to create bots.
52:32Send the command {slash} newbot. Give it
52:35a name, something like TradingOps. Give
52:37it a unique username that ends in the
52:39word bot. BotFather will hand you an API
52:42token. Copy that immediately and put it
52:45in your password manager.
52:46This is the key that lets Claude log
52:49into your Telegram account. Now, go back
52:51to your terminal and launch Claude code.
52:54We're going to install the official
52:55plugin using {slash} commands. Type
52:58{slash} plugin install telegram and then
53:00{slash} reload-plugins.
53:02Finally, run the configuration command
53:04and paste in that token you just got
53:07from BotFather. You've just successfully
53:09linked the brain to the messenger. To
53:11make this work, we have to relaunch
53:13Claude with the Telegram channel
53:15attached. This allows messages to flow
53:17in both directions. Close your current
53:19Claude session and run the relaunch
53:21command from the notes. You'll see a
53:23message in your terminal saying the
53:24Telegram channel is active and waiting.
53:26Now, open Telegram on your phone. Find
53:29your new bot and hit start. Send it any
53:31message. Claude will print a
53:33six-character pair code in your
53:34terminal. Paste that back into Claude to
53:37lock the connection. Then, set the
53:39access policy to allow list. This is
53:41critical. It ensures that only your
53:43paired phone can drive the agent. If
53:45anyone else finds your bot and tries to
53:47issue a trade, they'll be denied
53:49instantly. Let's see what this actually
53:51looks like in the real world. Imagine
53:53you're out for dinner and you want a
53:55whale flash. You just text the bot, any
53:57top 20 wallet flips in the last 2 hours?
54:00Claude scans the chain and text you back
54:02in seconds. Want to check your book?
54:04Ask, what's open on Wix right now? And
54:07get your P&L delivered as a message. You
54:09can even execute trades. Tell Claude,
54:12propose a Bitcoin long. Claude will do
54:15the math and wait. It won't fire until
54:16you reply with the word go. This human
54:19in the loop safety rail is what keeps
54:21you from making accidental fat finger
54:23trades from your pocket. You are now a
54:25mobile first operator. You have the full
54:28power of a professional research and
54:30execution desk condensed into a chat
54:32app. In the next module, we're going to
54:34dive into advanced agentic workflows.
54:37This is the module where the thing
54:39actually trades. We are building the
54:40full automated pipeline. TradingView
54:43fires an alert, Engrock forwards it to
54:45your local server, and Claude acts as
54:47the final decision layer to place a risk
54:50size order on Wix. Fully automatic,
54:52fully auditable, no more manual entry.
54:55Think of this like a digital relay race.
54:57Your Pine Script fires an alert with a
54:59JSON payload. The TradingView webhook
55:02sends that data to your Engrock URL.
55:05Your Flask receiver, a tiny Python
55:07server, catches the alert and triggers
55:09Claude. Claude, using the Wix X skill,
55:12reads the data, applies your risk rules,
55:14and fires the order. Consistency is
55:16everything in automation.
55:18We use a standardized JSON schema. It
55:21includes the symbol, the side, the
55:23price, and your specific risk parameters
55:25like leverage and stop loss percentages.
55:28Copy the schema from the notes. This is
55:30the language your alert will speak to
55:32Claude. We aren't going to write this
55:33Flask server line by line. We're going
55:35to let Claude scaffold it. Paste the
55:37prompt from section 16.3 into your
55:40terminal. Claude will create
55:41tv_webhook.py.
55:44This script does three things. It
55:46validates the incoming alert, logs it to
55:48a file, and then shells out to the Wix
55:50skill to execute the trade. Notice that
55:53we aren't bypassing Claude. Claude
55:55remains the brain that decides exactly
55:58how to size the position before the
55:59order hits the exchange. TradingView
56:02lives in the cloud, but your Flask
56:03server lives on your laptop. To bridge
56:06that gap, we use ngrok. In your
56:08terminal, run ngrok http 5005.
56:12This creates a secure tunnel from the
56:13open web directly to your machine. Copy
56:16that ngrok-free-app
56:19URL.
56:20That is now your official webhook
56:22endpoint. Now, go to your TradingView
56:24chart, open the strategy we built in
56:26module 14, and click the alarm icon. In
56:29the message box, paste your JSON
56:31payload. In the webhook URL, paste your
56:35new ngrok address. Set the trigger to
56:38once per bar close. The first time your
56:41strategy conditions are met, the whole
56:43pipeline will fire. Do not scale this
56:45immediately. Run your first 10 alerts on
56:47a tiny $50 test account. Watch it place
56:50the entry, the stop loss, and the take
56:52profit correctly. Only once you've
56:54audited the logs and seen it work
56:56end-to-end, do you move to your main
56:58book. You have just closed the loop. You
57:01are no longer chatting with an AI. You
57:03have built an autonomous execution
57:05engine that responds to market data in
57:07real time. In the next module, we're
57:10going to look at one of the most
57:11profitable corners of the market,
57:13prediction markets. This is where things
57:15get truly interesting. We are moving
57:17beyond price action and into the world
57:19of prediction markets. This is the home
57:22of the legendary $3 million bot, and
57:24today, we're building our own.
57:27Prediction markets allow you to bet on
57:28real-world outcomes, politics, Fed
57:31decisions, even the weather. We're going
57:34to use Polymarket, which runs on Polygon
57:36using USDC and Kalshi, the US regulated
57:40venue. We're going to build a sovereign
57:42analyzer that uses Claude Opus 4.7 to
57:45research the news, calculate the odds,
57:48and stake real bets. Polymarket is the
57:50global giant. It handles billions in
57:52monthly volume. Because it's
57:54decentralized and uses a central limit
57:56order book, it has the deepest liquidity
57:59for crypto and pop culture events.
58:01Kalshi is the pro tier CFTC regulated
58:05venue. It's funded in US dollars and is
58:07the gold standard for macro events like
58:09CPI prints and Federal Reserve meetings.
58:12Both offer open APIs, which means Claude
58:15can price shop between them to find the
58:17best edge. Let's get your credentials
58:19ready. For Polymarket, connect your
58:21MetaMask or Coinbase wallet and fund it
58:23with USDC on the Polygon network. You'll
58:26need to copy your private key and your
58:28wallet address into your .env file.
58:31Then, install the client by running pip
58:33install prompt. For Kalshi, complete
58:35your KYC and fund it with USD. You'll
58:38need to generate an RSA key pair in
58:40their API settings. Install their SDK
58:43with pip install prompt as well. Now,
58:46the main event. We are going to live
58:47build analyzer.py
58:49using Claude code. We're telling Claude
58:51to build a script that takes a
58:53Polymarket URL as an input. It will
58:56fetch the current odds, then use Claude
58:58Opus 4.7 with the web search enabled to
59:00find the latest news. Claude will then
59:03return a JSON response with a yes or no
59:07decision and a confidence score. Notice
59:09the confidence gate. We tell the bot if
59:12confidence is high, bet $5. If it's
59:15medium, bet two. If it's low, skip it
59:17entirely. This gate is what prevents
59:20your bot from overtrading on noise. The
59:22real alpha lives in the gaps. Polymarket
59:25and Kalshi often list the same event,
59:27like will the Fed cut rates in June, at
59:30different prices. We use the PMXT
59:33library to unify both markets. This
59:35allows Claude to see both order books at
59:37once. If one market is at 60 cents and
59:40the other is at 65, your bot can buy the
59:43cheap side and lock in a nearly
59:44risk-free profit. Before you go live,
59:47keep your dry run flag set to true.
59:50Watch the logs for a few days. Arbitrage
59:52looks pristine in a screenshot, but in
59:55the real world, gas fees and slippage
59:57eat your margin. You now have an agent
59:59that understands the world as well as it
1:00:01understands the charts. We have spent
1:00:03this course building a deep custom
1:00:05infrastructure. But sometimes you just
1:00:08want to test a theory now. You want to
1:00:10go from an idea in your head to a live
1:00:12order on the exchange in under 120
1:00:15seconds. That is what Agent PNL is for.
1:00:18It is the absolute easiest way to get a
1:00:21Weeks trading agent running. You write
1:00:23your strategy in plain English, pick
1:00:24your model, and hit start. Your bot
1:00:27trades Weeks perpetuals on its own, and
1:00:29its performance shows up live on a
1:00:30public leaderboard. The best part? You
1:00:32don't have to take anyone's word for it.
1:00:34Every bot on the Agent PNL leaderboard
1:00:37is verifiable directly on the WX
1:00:39exchange. You aren't looking at a
1:00:41photoshopped screenshot. You can click
1:00:43through to the actual trade logs. It's a
1:00:45level of transparency that is rare in
1:00:47the world of crypto bots. Let's do a
1:00:50live run. Head over to agentpnl.io,
1:00:53connect your Weeks account using those
1:00:55API keys we generated back in module
1:00:57five. Now for the strategy, you don't
1:01:00need to code, just paste your logic in
1:01:02plain English. Pick your model, Claude
1:01:053.5, Sonnet is the gold standard here.
1:01:08Hit start. That's it. Your bot is now
1:01:10live. It's scanning the markets,
1:01:12managing your risk, and its PNL is
1:01:14streaming to the leaderboard in real
1:01:16time. Even if you prefer building your
1:01:18own custom Python bots, Agent PNL is a
1:01:22massive asset for three reasons. The
1:01:24benchmark, you can compare your custom
1:01:26strategies against public bots running
1:01:28on the same venue. The sandbox, it's the
1:01:31perfect place to paper test a new idea
1:01:34without setting up any of your own
1:01:36servers. Social alpha, the leaderboard
1:01:38is a live read on what's actually
1:01:41working in the current market. If a
1:01:43specific bot is crushing it, you can
1:01:45study its logic and even copy trade it.
1:01:47Now, let's be real about the tradeoffs.
1:01:50Because this is a no-code platform, it's
1:01:53less flexible than the custom Python
1:01:55agents we build later in the course. If
1:01:57you need 10 different data sources and a
1:01:59complex MCP stack, you'll outgrow this.
1:02:02Also, remember your strategy is running
1:02:04on their servers, not yours. Now that
1:02:06you've seen the easiest way to trade
1:02:08Weeks, let's look at the powerhouse for
1:02:10Hyperliquid.
1:02:12If Weeks is our primary crypto home,
1:02:14Hyperliquid is our primary on-chain
1:02:17home. To dominate that ecosystem, you
1:02:19need a specialist. Enter Senpai. Senpai
1:02:22is a turnkey personal trading agent
1:02:24built specifically for Hyperliquid. It
1:02:26packs 44 specialized MCP tools,
1:02:29persistent memory, and built-in Telegram
1:02:31alerts. This system has already
1:02:34processed over $100 million in volume.
1:02:37Under the hood, it's powered by
1:02:39OpenClaw, but today we're going to focus
1:02:41on getting it live in minutes. The
1:02:43easiest way to keep Senpai running 24/7
1:02:46is via Railway. One, go to senpai.ai and
1:02:50generate an authorization token. Two,
1:02:53head over to railway.app and use the
1:02:55Senpai template. Three, you'll need to
1:02:58fill in six environment variables,
1:03:00including your OpenRouter key and your
1:03:02Hyperliquid private key. Set your
1:03:04strategy parameters to a conservative 1%
1:03:07risk and five times leverage while
1:03:09you're testing. Once you hit deploy,
1:03:11Railway builds the agent in the cloud.
1:03:13You can close your laptop and Senpai
1:03:15will stay on the hunt. If you prefer to
1:03:17keep your keys on your own machine, you
1:03:20can install the Senpai skill bundle
1:03:22directly into Claude Code. Open your
1:03:24terminal and clone the repository. Copy
1:03:27the skills into your
1:03:28specialized.claudskills
1:03:30directory and relaunch Claude. You now
1:03:32have the exact same 44 tools, from
1:03:35opportunity scanners to wallet trackers,
1:03:37available right in your local terminal.
1:03:40Let's see what 44 specialized tools can
1:03:42actually do. Ask Senpai to rank every
1:03:44trader by ROI and consistency. It
1:03:47doesn't just look at P&L, it looks at
1:03:49the quality of the trading. Run the
1:03:51opportunity scanner to see which assets
1:03:53have smart money accelerating up the
1:03:56ranks. Or go full alpha and ask Senpai
1:03:59to build a copy trading strategy that
1:04:00mirrors the top three traders on the
1:04:02leaderboard with a 5% safety stop. You
1:04:05aren't just trading against the market
1:04:06anymore. You are standing on the
1:04:08shoulders of the most profitable giants
1:04:10in the ecosystem. Senpai also features a
1:04:13weekly arena. This is where agents go
1:04:16head-to-head. Every trade you make earns
1:04:18you points. Two points for every dollar
1:04:20volume. Even if you don't care about the
1:04:23prizes, watch the arena replays. It is
1:04:26the best way to see how top-tier AI
1:04:28agents reason under extreme market
1:04:30pressure. It's a masterclass in agentic
1:04:33logic. You now have a dedicated
1:04:35hyperliquid specialist. Whether it's
1:04:37running in the cloud or on your desk,
1:04:39you have the most advanced tools
1:04:41available for on-chain trading. In the
1:04:43next module, we're going to look at
1:04:45Hermes, the framework that allows your
1:04:47agents to learn and grow on their own.
1:04:50We've built execution bots and research
1:04:52assistants, but now we're installing the
1:04:54professor of our stack. Hermes is an
1:04:56open-source Python framework from News
1:04:58Research. It has nearly 100,000 stars on
1:05:01GitHub and a massive community behind
1:05:03it. But for us, only one feature
1:05:05matters, persistent memory.
1:05:07While other agents might forget what you
1:05:09talked about yesterday, Hermes remembers
1:05:11your prompts, your trade history, and
1:05:13your journals across every single
1:05:15session. It is the most alive feeling
1:05:17agent in this entire course. Let's get
1:05:20Hermes onto your machine. We're going to
1:05:22use the official setup script because it
1:05:24handles the heavy lifting. It installs a
1:05:26tool called UV for speed, creates a
1:05:29virtual environment, and links their
1:05:30Hermes command line interface directly
1:05:32to your system. Open your terminal and
1:05:35clone the repo. Run this prompt. Once
1:05:37that's done, you can call Hermes from
1:05:40anywhere on your machine just by typing
1:05:42his name. Now, run Hermes setup. This is
1:05:45where we wire the brain. Select Open
1:05:47Router as your provider. Use the same
1:05:49master key we generated in module 4.
1:05:52Pick Claude Sonnet 4.6 as your default
1:05:55model. Finally, enable the Telegram
1:05:57gateway. One of Hermes' unique strengths
1:06:00is its flexibility. If you don't like
1:06:02Telegram, you can bridge Hermes into
1:06:04Discord, Slack, or even WhatsApp. It
1:06:07meets you wherever you do your work.
1:06:09There are four commands you need to
1:06:10know. Hermes. It drops you into a live
1:06:13conversation where memory is always
1:06:15active. Hermes tools. This is where you
1:06:18add or remove capabilities.
1:06:21Hermes gateway. This starts the bridge
1:06:23to your messaging apps.
1:06:25Hermes doctor. If an integration fails
1:06:27or a key goes missing, run the doctor.
1:06:29It's the fastest way to diagnose your
1:06:31system. By default, Hermes is a standard
1:06:33agent. To make it self-learning, we need
1:06:35to edit the config file. Open your
1:06:38config.toml
1:06:40and flip persistent memory and skill
1:06:42generation to true. Now, when Hermes
1:06:44successfully completes a complex task
1:06:47like writing a new arbitrage script, it
1:06:49saves that logic as a reusable skill. It
1:06:52literally gets smarter the more you use
1:06:54it. You might be wondering, if I have
1:06:56Claude code, why do I need Hermes? Two
1:06:59reasons. First, open runtime. If
1:07:01Anthropic ever hits you with rate limits
1:07:04on a high volatility day, Hermes keeps
1:07:06running through any of the 300 models on
1:07:09Open Router. Second, the journal. Hermes
1:07:12is built to store long-term trade
1:07:13journals. It can look back at 6 months
1:07:15of your trades and identify patterns in
1:07:18your behavior that you might have
1:07:19missed. You now have an agent that
1:07:21doesn't just trade, it studies.
1:07:23In the next module, we're going to look
1:07:25at the engine behind it all, Open Claw.
1:07:28We are now looking at the titan of the
1:07:30ecosystem. Open Claw is the largest
1:07:33open-source Claw compatible agent
1:07:35runtime on the planet. As of April 2026,
1:07:38it has over 360,000
1:07:41stars on GitHub, a massive plugin
1:07:43marketplace called ClawHub, and a
1:07:46high-performance TypeScript design. But
1:07:48with massive reach comes massive risk.
1:07:50In March of 2026 alone, nine major
1:07:53security vulnerabilities were disclosed,
1:07:55including remote code execution. Even
1:07:58worse, independent audits found that up
1:08:00to 20% of the plugins on ClawHub are
1:08:02shipping malware or credential stealers.
1:08:05In this module, we're going to benefit
1:08:07from this massive ecosystem while
1:08:09ensuring your trading keys never leave
1:08:11your machine. Open Claw is a node.js
1:08:15based system. Run the install command in
1:08:18your terminal, but pay attention to the
1:08:19versioning. Never track the latest
1:08:22version in a production environment.
1:08:25That is how supply chain attacks reach
1:08:26you.
1:08:27Pick a known good stable version like
1:08:30the one listed in the course notes and
1:08:32pin it. When you run Open Claw start,
1:08:34the onboarding wizard will walk you
1:08:36through your Open Router keys and
1:08:38messaging channels. Before you install a
1:08:40single plugin, you need to understand
1:08:42the threats. Threat class A is
1:08:44credential theft. Agents have to read
1:08:47your .env files and wallet keys to work.
1:08:50A malicious plugin can stream those keys
1:08:52to a remote server in milliseconds.
1:08:54Threat class B is unauthorized trades. A
1:08:57charting plugin that asks for exchange
1:08:58permissions could drain your entire
1:09:00week's account while you're asleep.
1:09:02Treat Claw Hub like a dark alley
1:09:04marketplace. Do not install anything
1:09:06blindly. From this point forward, you
1:09:08follow a strict checklist for every
1:09:10plugin. Verify publishers only. Only
1:09:13install plugins with the blue check
1:09:15badge. Permission scrutiny. If a news
1:09:18reading plugin asks for shell access, it
1:09:20is a virus. Deny it. Sandbox everything.
1:09:23Never run Open Claw on your main
1:09:25development account. Run it as a
1:09:27dedicated low privilege user on your
1:09:29machine. If managing security patches
1:09:32sounds like a full-time job you don't
1:09:33want, use One Claw.
1:09:36This is the managed our SaaS version of
1:09:38the platform. The core team handles the
1:09:40CVE patches and audits the plugin shelf
1:09:43for you. You lose some open source
1:09:45street cred, but you gain a dramatically
1:09:47smaller tax surface for your money. Here
1:09:50is the ultimate pro move. You don't have
1:09:52to choose between security and features.
1:09:55You can use Hermes, which is Python base
1:09:57and safe as your brain, and use Open
1:10:00Claw only as a specialist tool for
1:10:02specific plugins.
1:10:03By using the agent communication
1:10:05protocol or ACP, you can run them side
1:10:08by side. You simply allow list the
1:10:10specific verified Open Claw plugins that
1:10:14Hermes is allowed to talk to. This is
1:10:16defense in depth. Even if an Open Claw
1:10:18plugin goes rogue, it physically cannot
1:10:21touch the rest of your system.
1:10:22You now have the keys to the largest AI
1:10:25agent library in existence, and more
1:10:27importantly, you have the armor to
1:10:29survive it.
1:10:30In the next module, we're going to look
1:10:32at advanced prompt engineering to make
1:10:34these agents even sharper. Trying to get
1:10:36one giant prompt to handle research,
1:10:38risk, and execution is exactly how
1:10:41accounts get blown up. In a real
1:10:43production environment, you don't use a
1:10:44generalist, you use specialists. Today,
1:10:47we are separating the job into three
1:10:49distinct agents. We'll use Open Claw as
1:10:52the orchestrator to coordinate the plan,
1:10:55and Hermes as the executor to handle the
1:10:57repeatable loops. They'll talk to each
1:10:59other over the ACP protocol. Together,
1:11:02they form a risk guardian system that
1:11:04protects your capital while you hunt for
1:11:06alpha. We're building a three-person
1:11:08team inside your machine, the alpha
1:11:11scanner. This agent reads the chain
1:11:13data, the charts, and the news. It
1:11:15outputs ranked trade ideas as JSON, but
1:11:19crucially, it is physically incapable of
1:11:21placing an order. The risk guardian,
1:11:23this is a stateless veto layer. It
1:11:25checks your total risk and looks for
1:11:27news blackouts like an upcoming Fed
1:11:28meeting. It only has two words in its
1:11:31vocabulary, approve or reject. The
1:11:34execute weak signal, this agent only
1:11:36listens to the guardian. If and only if
1:11:39a signal is approved, it calls the weak
1:11:41skill to fire the trade. For these
1:11:43agents to work together, they need to
1:11:45speak the same language. We use a
1:11:47standardized signal JSON shape. It
1:11:50contains everything, the entry, the
1:11:52stop, the confidence score, and the
1:11:54rationale. Because both Claude and
1:11:56Hermes validate the schema before
1:11:58acting, hallucinated trades are filtered
1:12:01out at the door. If the data doesn't fit
1:12:03the shape, the machine doesn't move. In
1:12:05the course notes, I provided the system
1:12:07prompts for all three. Your alpha
1:12:09scanner is programmed to run every 30
1:12:11minutes. Your risk guardian is the
1:12:13enforcer. It rejects any trade if your
1:12:16total account risk is over 6% or if
1:12:19there's a major CPI report in the next
1:12:2190 minutes. Your executor is the
1:12:24soldier. It doesn't generate ideas, it
1:12:26just follows orders that have been
1:12:28stamped with a guardian approved status.
1:12:31Now, where do these agents live? Open
1:12:32Claude runs the alpha scanner and the
1:12:34risk guardian. It's the perfect
1:12:36orchestrator for pulling from Fire
1:12:38Claude and TradingView. For the
1:12:39guardian, we can even use a smaller
1:12:41model like Haiku 4.5. It's fast, cheap,
1:12:45and more than enough for logic checks.
1:12:47Hermes runs the execution agent. Because
1:12:49Hermes has a learning loop, it actually
1:12:51gets better at hitting your fills and
1:12:53managing the Weex scale the more it
1:12:55trades. All three communicate over the
1:12:58ACP bridge we built in module 21. This
1:13:01setup allows you to fan out your signals
1:13:03to multiple channels. You could have a
1:13:05private Telegram for your own trades and
1:13:08a public alpha feed for your community,
1:13:10all driven by the same brain. You have
1:13:12transitioned from a single bot to a
1:13:14sovereign trading desk. Your risk is
1:13:17managed, your execution is specialized,
1:13:19and your research is automated. In the
1:13:21next module, we're going to look at the
1:13:23custom code layer, the CCXT bridge.
1:13:27Agents are incredible for research and
1:13:30complex decision-making. But for the
1:13:32tight inner loop, the moment-to-moment
1:13:34check of price just ticked, should I
1:13:36move my stop? You want old-school
1:13:39optimized code. In this module, we're
1:13:41going to use Claude code to scaffold a
1:13:43professional-grade Python bot. It will
1:13:46be type tested and production ready. It
1:13:48uses the Weex scale for the heavy
1:13:50lifting and handles the logic gates
1:13:52itself. This is the bridge between AI
1:13:55creativity and software stability. Our
1:13:57shopping list is built for global
1:13:59access. We use CCXT, which allows you to
1:14:02swap between Weex, Binance, or Kraken
1:14:05with a single line of code. We include
1:14:07Pydantic for data validation and Loguru
1:14:09for structured logs. This ensures that
1:14:12if the bot does something unexpected,
1:14:14you have a clear, searchable trail of
1:14:16exactly why it happened. We aren't just
1:14:19creating a single file. We are building
1:14:21a professional directory structure.
1:14:23I provided a master prompt in the notes
1:14:25that tells Claude to scaffold the entire
1:14:27project. From the strategy layer to the
1:14:30risk guardian and the execution wrapper.
1:14:33Claude will generate the models, wire
1:14:35the data fetcher, and create a makefile.
1:14:37This means you don't have to remember
1:14:38complex commands. You just type make
1:14:41test or make run paper.
1:14:43Notice that we require the bot to pass
1:14:44its own unit test before we even attempt
1:14:46to run it. If the risk rules aren't
1:14:48working in the test, the bot won't
1:14:50launch. In professional trading, safety
1:14:52isn't a feature, it's the foundation.
1:14:54Default paper, your bot will default to
1:14:56live equals false. You have to manually
1:14:59flip a toggle and set an environment
1:15:01variable to risk a single dollar. The
1:15:04daily kill switch, if your total loss
1:15:06for the day hits 3%, the bot is
1:15:08programmed to flatten all positions and
1:15:10exit. It protects you from yourself. The
1:15:13heartbeat, every time the loop runs, the
1:15:15bot sends a one-line status to your
1:15:17Telegram. If your phone goes silent, you
1:15:20know immediately that something is
1:15:21wrong. Once Claude finishes the
1:15:23scaffold, it's time for the first run.
1:15:26Move into your bot directory and run
1:15:27make install, then make test. If you see
1:15:30all green, you are ready for make run
1:15:32paper. Let this run for at least 48
1:15:34hours in paper mode. Review every single
1:15:37log entry. Check every simulated fill.
1:15:40Make sure the risk guardian rejected the
1:15:42trades it was supposed to. Only once the
1:15:44logs are boring and the math is perfect
1:15:46do you even think about going live. You
1:15:48now have a professional Python trading
1:15:50engine. It's clean, it's fast, and it's
1:15:53built to be managed by you and Claude as
1:15:54a team. Now that your bot is built, we
1:15:57need a place for it to live 24/7. Your
1:15:59laptop is not a production environment.
1:16:01If your Wi-Fi drops or your battery
1:16:03dies, your bot dies with it. To trade
1:16:05like a professional, your code needs to
1:16:07live in a hardened data center with
1:16:0999.9%
1:16:11uptime.
1:16:12In this module, we are moving your bot
1:16:14to a Hostinger KVM
1:16:172 VPS running Ubuntu 24.04.
1:16:21We are going to harden your SSH access,
1:16:24lock down the firewall, and wrap your
1:16:26bot in a system service so it auto
1:16:28restarts if it ever crashes. Head over
1:16:30to this link. I recommend the KVM 2
1:16:33plan. This is more than enough to run
1:16:35your bot plus multiple Claude code
1:16:37sessions.
1:16:38When choosing a data center, think about
1:16:40latency. Set a strong root password, but
1:16:42don't get too attached to it. We're
1:16:44going to disable it in the next step.
1:16:46The second your IP address hits the
1:16:48public internet, malicious bots will
1:16:50start knocking on your door. We are
1:16:52going to lock it down immediately.
1:16:54Create a dedicated user named trader.
1:16:57Upload your SSH public key from your
1:17:00laptop. Disable root login and password
1:17:03authentication. By doing this, even if
1:17:06someone guesses your password, they
1:17:07can't get in. Only your physical laptop
1:17:10carrying your unique key has the badge
1:17:12required to enter the server. Finally,
1:17:15enable the UFW firewall and only allow
1:17:18port 22 for your secure connection. Now,
1:17:21login as your new trader user, update
1:17:23the system, and install the Python 3.12
1:17:26runtime. You're going to get clone your
1:17:28trading repository, create a fresh
1:17:30virtual environment, and install your
1:17:32requirements. Copy your .env file from
1:17:36your laptop to the server. Now, take
1:17:38that VPS public IP address and go back
1:17:40to your Wix API settings. Whitelist this
1:17:43specific IP. This is your final layer of
1:17:46security. Your API keys will now refuse
1:17:48to work from any computer on Earth
1:17:50except this one specific server. We
1:17:53don't want to run the bot manually in a
1:17:54terminal window. We want it to be a
1:17:57system service. We're going to create a
1:17:59system unit file. This tells Ubuntu this
1:18:01bot is a priority. If the server
1:18:03reboots, start the bot. If the bot
1:18:05crashes, wait 5 seconds and restart it.
1:18:08Once you reload the daemon and hit
1:18:10start, your bot is officially a daemon,
1:18:12a background process that breathes on
1:18:14its own. Now that the bot is invisible
1:18:17in the background, how do you see what
1:18:19it's doing? You use journalctl.
1:18:21Type this. This gives you a live
1:18:23streaming view of your bot's heartbeat.
1:18:26Every trade, every risk check, and every
1:18:29API call shows up here in real time.
1:18:32Your laptop is now just a remote
1:18:33control. Your bot is live in a
1:18:36professional data center.
1:18:38In our final module, we're going to
1:18:39build the glass cockpit, the personal
1:18:42trading dashboard. You've done it.
1:18:44You've built the engine, the radar, the
1:18:46brain, and the safety net. But, looking
1:18:48at 12 different terminal windows and
1:18:50browser tabs is not how a professional
1:18:53operator works. You need one pane of
1:18:55glass. In this final module, we are
1:18:57building your live ops dashboard. We'll
1:19:00start by bootstrapping a
1:19:01high-performance HTML skeleton with the
1:19:04Wick scale. Then, we'll fold in every
1:19:06other piece of the stack from Alpaca
1:19:08stocks to your whale tracker data until
1:19:11you have a real-time glass cockpit for
1:19:13your entire trading empire. We're going
1:19:16to let Claude code do the heavy lifting
1:19:18here. Use the prompt in the notes to
1:19:20generate a single page dashboard. We
1:19:22aren't using heavy frameworks like React
1:19:24or Vue. We want speed. We're going with
1:19:27vanilla JavaScript, a dark theme to
1:19:29match our course aesthetic, and
1:19:31JetBrains Mono for the numbers because
1:19:33precision matters. This dashboard will
1:19:36auto-refresh every 30 seconds, showing
1:19:38your equity curve, your open positions,
1:19:41and your most recent signals from the
1:19:43log files. Once the skeleton is live, we
1:19:46start plugging in the rest of the
1:19:47course. One prompt at a time, you will
1:19:50ask Claude to add an Alpaca panel for
1:19:52your US stocks, add a whale pulse to see
1:19:55what the smart money is doing without
1:19:56leaving the page, add a heartbeat panel
1:19:58that monitors your VPS. If that dot
1:20:01turns red, you know your bot has
1:20:02stopped. Add your send P and agent P&L
1:20:06stats so you can see how your autonomous
1:20:08agents are performing. You're not just
1:20:10building a website, you're building a
1:20:12sovereign intelligence hub. Now, where
1:20:14does this live? If you want it for your
1:20:16eyes only, serve it from your hosting or
1:20:18VPS using Caddy and lock it behind your
1:20:21IP address.
1:20:22If you want a fast global URL, push it
1:20:25to Netlify. If you want to turn this
1:20:27into a business, you can anonymize the
1:20:29data and gate the dashboard behind a
1:20:32wall tier. Your proof room becomes a $29
1:20:35a month subscription that sells itself.
1:20:37Take a look at what has changed in your
1:20:39life. You went from 12 browser tabs and
1:20:42doom scrolling Twitter for entries to
1:20:44one single URL. Every morning the daily
1:20:47alpha brief hits your inbox while you're
1:20:49still in bed. Your custom bot handles
1:20:51the inner loop execution with a built-in
1:20:54risk guardian. And your dashboard shows
1:20:56you the results in real time. You are no
1:20:59longer playing the markets. You have
1:21:01engineered a professional advantage.
1:21:03Your computer is now a high-frequency
1:21:05workstation and your agents are your
1:21:08employees. The rest of the day, the rest
1:21:10of the day is yours. Congratulations.
1:21:13You have completed the trading AI full
1:21:15course. Now go out there and execute. A
1:21:18few hours ago this was a blank laptop.
1:21:21Now it is a professional grade AI
1:21:23trading stack. You have the research
1:21:25brain, the execution hands, the risk
1:21:27guardian, three brokers, and a custom
1:21:29bot running in the cloud. This is the
1:21:31shortest module in the course because
1:21:33the work is done. This is the one that
1:21:35tells you exactly what to do tomorrow
1:21:37morning. Let's look at the empire you
1:21:38just built. You have Claude code dialed
1:21:40in. Your Wix and Alpaca accounts are
1:21:43live. Interactive Brokers is bridged.
1:21:46You've installed the whale tracker, the
1:21:47TradingView MCP, and your daily alpha
1:21:50brief. You have cloud routines running
1:21:52your research, webhooks automating your
1:21:54trades, a custom bot hardened on a
1:21:57hosting or VPS, and a live ops dashboard
1:22:00that unifies everything. You didn't just
1:22:02watch a course, you shipped a production
1:22:04system. A quick moment of transparency.
1:22:07Every tool in this course from Wix to
1:22:08Hostinger pays me a referral when you
1:22:11use my links. That's how I'm able to
1:22:13keep this content high velocity and high
1:22:15production. When you start shipping your
1:22:17own strategies or building your own
1:22:20versions of this course, you should do
1:22:22the same. These are the tools we
1:22:24actually use. They are the backbone of
1:22:26the industry. This is the most important
1:22:29part of the course. This is how your
1:22:31life changes tomorrow morning. You've
1:22:33successfully delegated the grunt work of
1:22:35trading to the machines. If you want
1:22:37everything I showed you today, every
1:22:40prompt, every skill code, every setup
1:22:42guide, it is all inside my private
1:22:45group. Link is in the description, first
1:22:47link. Everything is in there. If you
1:22:49found this useful, leave a like. It
1:22:52genuinely does help the channel.
1:22:53Subscribe if you have not already.
1:22:55The system is live. The edge is yours.
1:22:58Now, go out there and execute. I'll see
1:23:00you at the top of the leaderboard.
1:23:02You're watching charts.
1:23:04Losing sleep.
1:23:06Missing setups.
1:23:08While bots with no emotions take the
1:23:10trades you should have taken.
1:23:13Trading is math. Humans feel. That's the
1:23:15whole problem. AI doesn't hesitate,
1:23:17doesn't revenge trade, doesn't freeze at
1:23:19the 2:00 a.m. liquidation candle. It
1:23:21just executes the plan every single
1:23:23time.
1:23:25Inside AI Trade Edge, I give you the
1:23:27full stack, autonomous trading agents,
1:23:30backtested strategies, plug-and-play
1:23:32templates, new tools every week. Not
1:23:35theory, real agents running while you
1:23:37sleep, while you're at the gym, while
1:23:39everyone else is still watching YouTube
1:23:40tutorials. Every week you wait, someone
1:23:43with worse charts and better systems
1:23:45profits. AI Trade Edge, first 100 spots,
1:23:48$79.99 a month, locked in forever. After
1:23:52that, the price goes up permanently.
1:23:54Stop watching, start executing, trade
1:23:56smarter with Alex Carter. Join now.

About this transcript

This page contains the full transcript of Full AI Trading Course 2026: Master Agentic Trading (Beginner to Pro) by Alex Carter, generated from the public captions YouTube serves with the video. The transcript has 14,406 words across 2,206 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.