How a 24/7 AI Agent Built Inside Claude Code Helped Beat the Market — And How You Can Build One Too

The Benchmark That Started Everything

My very first live trade using a Claude Opus 4.7 trading agent went live on a Tuesday morning at exactly 8:30 a.m., and I was sitting at my desk watching numbers move in real time with my coffee going cold beside me.

This whole thing started because of a benchmark.

I was scrolling through the official release notes for Claude Opus 4.7, and right there in the performance data, I spotted a section labeled agentic financial analysis.

The jump from the previous version was about 4 percent, and that got me thinking hard.

A few weeks before that, I had already run a 30-day challenge where I gave an AI trading agent $10,000 and let it trade stocks through the Alpaca API.

That agent was running on the older model, and by the end of the challenge, it had beaten the S&P 500 by about 8 percent.

When I saw the upgraded benchmark numbers for Claude Opus 4.7 AI trading agent performance, I knew I had to rebuild the whole system from scratch using the new model.

That decision is what this article is about.

We strongly recommend that you check out our guide on how to take advantage of AI in today’s passive income economy.

What Made Claude Opus 4.7 Worth Upgrading To

Before I get into the actual build, I want to explain why this model upgrade matters for a use case like trading specifically.

The official Anthropic release notes for Claude Opus 4.7 listed several benchmark improvements, and the one that stood out most was the agentic financial analysis score, which came in at 64.4 percent.

That number is not a guarantee that the model can predict the market or read candlestick charts like a professional day trader.

What it actually measures is how well the model can read through financial filings, build a reasoning-based thesis on a company, and make coherent decisions backed by data.

That maps almost perfectly to a fundamentals-driven strategy, the kind where you are trying to beat the S&P over months, not hours.

The claude opus 4.7 live trading workflow I was building was designed for exactly that kind of long-term, research-backed approach.

It is not a day trading bot looking for scalp opportunities on MACD crossovers.

It is more like having a disciplined research analyst who wakes up before the market opens, reads the news, checks your holdings, and tells you what to do next.

One other thing worth noting is that Claude Opus 4.7 was specifically described as being built for full-throttle agentic work, with a strong emphasis on judgment under ambiguity and self-verifying outputs.

Those two qualities are exactly what you want in a trading bot that makes decisions autonomously while you sleep.

The Feature That Made Everything Possible: Claude Code Routines

What Are Routines?

If you have never heard of Claude Code routines, here is a simple way to think about them.

Imagine you have an assistant who wakes up every morning at 6 a.m., reads a set of notes you left on the desk, does a list of tasks, writes down what they learned, and then goes back to sleep until the next scheduled task.

That is basically what a routine does inside Claude Code.

You set a cron schedule, you write a prompt that tells the agent what to do when it wakes up, and then you point it at a project folder full of files that act as the agent’s memory.

The combination of claude opus 4.7 autonomous trading routines and these scheduled prompts is what turns a regular AI chat session into a system that runs 24 hours a day without you having to be there.

Routines can be set to run locally on your machine, or they can run remotely in the cloud.

The remote option is the more powerful one because your agent keeps running even when your laptop is closed or your internet is down.

The only requirement for remote routines is that your project lives inside a GitHub repository, since Claude Code clones the repo in a cloud environment, runs the task, commits any file updates back to the repo, and then destroys the temporary environment.

The Full Tech Stack I Used

Every Tool in the System and Why I Chose It

Here is exactly what I used to build this claude opus 4.7 stock trading agent from start to finish, along with the reason each tool is in the stack.

Claude Code with Routines — This is the scheduler and the brain of the operation.

Instead of building a custom automation pipeline, Claude Code handles the full agentic loop on its own, which means it figures out problems, reads files, makes decisions, and writes back results without needing me to hold its hand.

Claude Opus 4.7 — This is the model that runs inside each routine session.

Every time a cron job fires, it spins up a new session using Opus 4.7, which brings the upgraded reasoning and financial analysis capability to every single trade decision.

Alpaca API — This is the brokerage layer.

Alpaca is a real stock trading platform that offers both paper trading accounts and live trading accounts through a clean, developer-friendly API.

You sign up at alpaca.markets, and once your account is approved, you get an endpoint URL, an API key, and a secret key that you use to authenticate trade requests.

Paper trading accounts come preloaded with $100,000 in virtual money, so you can test without risking anything real.

Perplexity API — This is where the daily research comes from.

Every morning before the market opens, the agent uses the Perplexity API to search for relevant news, earnings reports, and market signals for the stocks it is watching.

You get your API key from the settings panel inside your Perplexity account under the API platform section.

ClickUp — This is where the agent sends its daily reports.

At the end of each trading day, the agent compiles a summary of what it did, what the portfolio looks like, and how it is performing against the S&P 500, and it sends that directly to a ClickUp notification channel.

You grab the API token from your ClickUp account settings page under the ClickUp API section.

GitHub — This is what makes remote routines possible.

All the memory files, trade logs, strategy documents, and routine prompts live in a private GitHub repository, and the agent commits any updates back to that repo after every session so the next run picks up right where the last one left off.

VS Code with Claude Code Extension — This is where I built everything out at the start.

VS Code is free, and the Claude Code extension lets you run Claude Code while seeing all your project files in the sidebar at the same time, which makes the early setup much easier than working inside the Claude desktop app.

Understanding the Memory Architecture First

Why This Part Matters More Than the Trading Strategy

Before you write a single line of a prompt or set up a single cron job, you need to understand how a stateless agent can behave like it has memory.

Every time a routine fires, Claude Code wakes up with zero memory of anything that happened in previous sessions.

It has no idea what trades were made yesterday, no idea what the market looked like last week, and no idea what the current portfolio holds.

The way you solve that is with files.

Think of the project folder as the agent’s long-term brain.

Every time the agent runs, it starts by reading a set of files that contain the trading strategy, the current portfolio state, the trade log, and any recent research notes.

Then it does its job for the session.

Then, before it shuts down, it writes any important new information back into those same files so the next session can pick up with full context.

This file-based memory system is what makes claude opus 4.7 trading workflow automation actually work over time.

Without it, every run would start fresh with no learning and no continuity.

The files the agent works with include things like an agent instructions document, a trading strategy file, a trade log, a research log, and a weekly review document.

Each one serves a specific purpose, and together they act as the full personality and discipline of the bot.

Step One: Define Your Trading Strategy First

Write It Down Before You Touch Claude Code

The first step in this build has nothing to do with code or APIs.

It is about writing down your actual trading strategy in plain language before you open Claude Code at all.

Think of it like teaching someone to ride a bike.

You would not just hand them a bike and walk away.

You would explain how to balance, how to steer, and how to stop before they ever get on.

The same idea applies here.

The more detail you give the agent about how you want it to trade, the more consistent and disciplined it will be.

For my setup, I had already been running a claude opus 4.7 automated investment agent on an older system, so I was able to extract the full strategy, all the buy signals, sell signals, risk rules, and research methods, and migrate that knowledge directly into the new Claude Code project.

If you are starting from scratch, grab a piece of paper or open a Google Doc and write down every thought you have about how you trade.

What signals make you want to buy?

What makes you want to sell?

How often do you check the news?

How much of your portfolio are you willing to put into a single stock?

All of that becomes the strategy file that the agent reads at the start of every session.

Step Two: Setting Up the Project in Claude Code

From Blank Folder to Working Agent in One Brainstorm Session

Once your strategy is written, you open VS Code, create a new project folder, and start Claude Code inside it.

The first conversation you have with Claude Code is just a brainstorm.

You tell it what you are building, you paste in your strategy notes, and you let it ask you questions until it has everything it needs.

From that brainstorm, Claude Code will propose a full folder structure for the project.

In my case, it created a memory folder with all the context files, a scripts folder with helper files, and a routines folder where each of the five routine prompts would eventually live.

It also created and populated the claude.md file, which is the main instruction document that the agent reads at the start of every session.

This is where you define the agent’s identity, its rules, its guardrails, and its overall mission.

The agent in my setup is named Bull, and the claude.md file is about 156 lines that cover everything from how it should handle a losing trade to how it should format its daily ClickUp summary.

After the project structure is set up, the next thing you do is push everything to GitHub so the remote routines can access it.

Claude Code can handle this for you by authenticating with your GitHub account through the CLI and then committing all your files to a new private repository.

Step Three: Guardrails and Risk Rules

What Happens When You Give an AI $10,000 With No Limits

This is the step that most people skip and then regret.

A claude opus 4.7 trading agent with no guardrails is like giving a brand new driver a sports car with no speed limit signs.

It is going to go fast because it can, not because it should.

Before going live, you need to write specific risk rules into the trading strategy file.

Some examples from my setup include a maximum position size of 5 percent of total portfolio value per stock, a daily loss cap that triggers a stop on all new activity if the portfolio drops by a certain percentage in one day, a rule against buying options, a rule limiting new positions to no more than three per week, and a rule requiring a trailing stop loss on every open trade.

These guardrails live in the memory files and get read at the start of every session, so the agent always knows its limits no matter what the market is doing.

Step Four: Building the Five Routine Prompts

The Exact Schedule the Agent Runs Every Weekday

Once the project is structured and the guardrails are in place, it is time to define the cron schedule and write the prompt for each routine.

For my claude opus 4.7 scheduled trading agent, I settled on five routines running on weekdays only.

Pre-Market at 6:00 a.m. — The agent wakes up, reads all memory files, uses the Perplexity API to research market catalysts, and drafts a list of trade ideas to consider when the market opens. It only sends a notification to ClickUp if something urgent comes up.

Market Open at 8:30 a.m. — The agent executes any trades that were planned in pre-market, sets 10 percent trailing stops on every new position, and logs everything in the trade log file. A ClickUp notification is sent only if a trade is actually placed.

Midday at 12:00 p.m. — The agent reviews all open positions and cuts any that are down more than 7 percent. It also tightens trailing stops on any winners to protect gains. Updates go back into the trade log.

Market Close at 3:00 p.m. — The agent does a full end-of-day review, updates the research log and portfolio snapshot, and sends the daily summary to ClickUp.

Weekly Review on Fridays at 4:00 p.m. — This one only runs on Fridays. The agent compares overall portfolio performance against the S&P 500, grades itself for the week, and writes a summary of lessons learned into the weekly review file.

Every single prompt in these routines includes an explicit instruction to read all memory files before doing anything and to write any updates back to those files before closing the session.

The prompts also specify that all API keys for Alpaca, Perplexity, and ClickUp should be pulled from environment variables, not from any file in the repository.

Step Five: Deploying Remote Routines in the Claude Desktop App

The Step That Actually Makes It Run While You Sleep

This is where everything comes together.

You open the Claude desktop app, click on routines, and select the option to create a new remote routine.

Remote routines run in the cloud, which means they fire on schedule even when your computer is off.

Before creating the routines, you set up a cloud environment inside the Claude desktop app.

This is where you enter your API keys for Alpaca, Perplexity, and ClickUp as environment variables, and where you grant the environment full network access.

Once the environment is saved, you create each of the five routines, paste in the correct prompt for each one, assign the cron schedule, point each routine at your GitHub repository and your cloud environment, and then turn on the allow unrestricted branch pushes permission so the agent can commit file updates back to the main branch.

After all five routines are created, you run each one manually at least once to verify it works before leaving it on its own schedule.

The first test run I did caught an issue where the Alpaca API key was not being found because the variable name in the prompt did not match the variable name in the environment exactly, letter for letter.

Once that was corrected, the weekly review routine fired cleanly, pulled the portfolio balance from Alpaca, compiled a report, sent it to ClickUp, and committed the updated review file back to GitHub.

The portfolio balance it pulled showed $9,859, and that matched exactly what I saw when I checked the Alpaca dashboard manually.

What the Results Actually Looked Like

30 Days, $10,000, and a System That Ran Itself

By the end of the first 30-day test using the older model, the agent had grown the $10,000 portfolio to a point where the return was about 8 percent above what the S&P 500 returned in the same period.

That result came from a system that ran completely on its own, made its own research decisions using Perplexity, placed and exited trades through Alpaca, and sent daily summaries to ClickUp without me doing anything manually.

The upgrade to the claude opus 4.7 ai investment strategy system is designed to improve on that result, primarily because of the stronger financial reasoning benchmarks and the better agentic decision-making that comes with the newer model.

The weekly review the agent sent after its first test run included a portfolio summary, a comparison against the S&P, a list of any trades made during the test period, and a self-grade where the agent rated its own performance as a C for that initial week.

That kind of self-reflection is built into the prompt, and it is what makes the system improve over time rather than just repeating the same patterns.

The Hidden Lesson Behind All of This

Files Are Not Just Memory — They Are the Agent’s Entire Personality

Here is the thing that took me a while to fully understand about building an ai trading agent with claude opus 4.7.

The trading strategy is only about 20 percent of what makes this system work.

The other 80 percent is the memory architecture.

The files you create, the way you structure them, the rules you write into them, and the discipline you encode into the claude.md file — all of that shapes how the agent behaves in every session.

A well-written agent instructions file with clear rules, specific guardrails, and a defined research process will outperform a vague one every single time, regardless of how smart the model is.

The model provides the reasoning engine.

The files provide the personality, the discipline, and the accumulated wisdom of every previous session.

Together, they create something that behaves less like a chatbot and more like a professional assistant who has been doing this job for months.

If you are building your own version of this system, spend more time on the memory files than on anything else.

Get the strategy written clearly, get the guardrails defined firmly, and make sure every routine prompt tells the agent exactly where to find the information it needs and exactly where to write its updates when it is done.

Do that well, and the claude opus 4.7 real-time trading automation system you build will keep getting smarter every single week it runs.

Final Thoughts

Start Small, Test Often, and Let It Learn

This system is not a get-rich-quick machine.

It is an experiment in what is possible when you combine a powerful reasoning model with a structured memory architecture and a disciplined trading strategy.

Start with paper trading on Alpaca before you put real money in.

Watch every routine run for the first two weeks.

Read through the conversation history after each session and look for places where the agent made a questionable decision or missed something obvious.

Update the memory files based on what you learn, tighten the guardrails, and improve the research prompts over time.

The claude opus 4.7 financial analysis trading agent gets better the more context you give it and the more consistently you update its memory files after each run.

That is the whole game.

Build the system, watch it run, teach it from its mistakes, and let it compound its knowledge just like a good investor compounds returns.

We strongly recommend that you check out our guide on how to take advantage of AI in today’s passive income economy.