← Financial Trader Cloud Trader Hub · Backtest

Vertex Macro | Financial Trader Cloud · AMZN Backtest Desk · May 2026

Build A Custom Cerebro Code Talk For Amazon Timing And Position Management [Part 2]

Series: Backtest

Note: 06

Article
Kiro workshop
01 Build with Kiro: Prompt-First Product Design for a Tagalog Learning App
02 Build with Kiro: Educational-First Dev Tips for a Tagalog Learning App
03 Build with Kiro: Deep-Dive Development Flow for a Tagalog Learning App
04 Build with Kiro: Localize a Tagalog Learning App into Chinese Variants Workshop
05 Build with Kiro: Grammar and Pronunciation Enrichment Pipeline for Tagalog Cards Workshop
06 Build with Kiro: Unique and Reviewable Extra Examples in a Tagalog Learning App Workshop
07 Build with Kiro: Factory Engineering Health Hooks Workshop
08 Build with Kiro: Etch Process Window Risk Test Automation Workshop
09 Build with Kiro: Photolithography Drift Risk Development Workshop
10 Engineering Team Get Started — Daily Fab-Duty Use of fab spc drift sync portal
11 Engineering Team Addendum — Daily Fab-Duty Use of fab spc drift sync portal
12 Kiro: Field Engineering Workshop for Spec-Driven Factory Software
13 Kiro: Hands-On Lab — Build a Typed Factory Risk Portal from Scratch
14 Kiro: Prompt, Code, and Type Standards Playbook for Engineering Developers
15 Kiro: Why a Strong React Prompt Prevents Type Declaration False-Starts
17 Build with Kiro: Create a Factory Automation Portal React UI
18 Build with Kiro: Create the Automation Analytics Engine Behind a Factory Automation Portal
19 Build with Kiro: Add an AI Factory Automation Assistant to a Factory Automation Portal
21 Kiro: 2-Hour Professional Developer Workshop Guide
22 Kiro: Build the Fab SPC Drift Synchronization Portal from Scratch
23 Kiro: Prompt Library and Deep Code Explanation Appendix
30 Build with Kiro: Create a Factory Automation Portal UI
31 Build with Kiro: Create the Automation Analytics Engine Behind a Factory Automation Portal
32 Build with Kiro: Add an AI Factory Automation Assistant to a Factory Automation Portal
33 Build with Kiro: Rebuild the CME Direct-Style Quant P&L Leaderboard UI
34 Build with Kiro: Recreate the Quant Analytics Engine Behind the P&L Board
35 Build with Kiro: AWS AI-Powered Trading Desk Assistant for the Quant Board
36 One-Page Trading Portal SOP
AgentCore
A1 Build with AgentCore & Strands: Gateway MCP Tool Fabric Developer Workshop
A2 Build with AgentCore & Strands: Governed Multi-Agent Risk System Developer Workshop
A3 Build with AgentCore & Strands: Runtime Sovereign Risk Agent Developer Workshop
Exam practice
E1 Build a Multilingual AWS Exam Practice Launch System with Vibe Coding
E2 Build an AWS Exam Practice Room with Vibe Coding Dev Tips
E3 Build the Practice Engine Behind a Static AWS Exam Room
Amazon Q
Q1 Amazon Q: CloudShell-First Developer Workshop for ACM Certificate Auto Renewal
Tagalog Practice Room
T1 Build a Tagalog Learning App for AWS Manila Community Day with Prompt-First Product Design
T2 Build Tagalog Learning App for AWS Manila Community Day with Educational-First Dev Tips
T3 Deep Dive Development Flow for a Tagalog Learning App for AWS Manila Community Day
T4 Build Localize a Tagalog Learning App into Chinese Variants for AWS Manila Community Day
T5 Build a Grammar and Pronunciation Enrichment Pipeline for Tagalog Cards for AWS Manila Community Day
T6 Make Extra Examples Unique and Reviewable in a Tagalog Learning App for AWS Manila Community Day
Roadmap
R1 Enterprise Data Analytics Roadmap: 100 Deep Scenario Questions
R2 Front-End Development Roadmap: Real-World Enterprise Scenarios
Hong Kong Community Day
C1 A Hong Kong Weekend with AWS Community Day: From Cloud Sessions to Harbour Lights
C2 The Speaker’s Luxury Weekend: Present an AWS Story, Then Let Hong Kong Take the Stage
C3 Seventy-Two Hours in Hong Kong: The Grand Tour for an AWS Community Day Speaker
Manila Community Day
C4 AWS Community Day Manila: A Joyful Weekend of Cloud, Culture, and True Friendship
C5 AWS Community Day Manila: Where Cloud Builders Find the Happiest Spirit of the Philippines
C6 AWS Community Day Manila: Build, Break, Repeat, and Belong in a City of Joy
C7 First-Time Visitor Tips for Manila, Philippines
Philippines × Hong Kong
C8 Philippines Hong Kong Capital Market Upgrade
Backtest
B1 Build Institutional Amazon Long-Only Backtesting Agents With Bedrock AgentCore And Strands Agents
B2 Build Regime-Aware Amazon Position Management With Backtrader, AgentCore, And Strands Agents
B3 Build Benchmark-Relative Amazon Timing Systems Using Nasdaq, S&P 500, Dow, AgentCore, And Strands
B4 Build A Governed Amazon Trade-History Factory With Bedrock AgentCore, Strands Agents, And Backtrader
B5 Build An Agentic Amazon Backtest Operating Model With Bedrock AgentCore And Strands Agents [Part 1]
B6 Build A Custom Cerebro Code Talk For Amazon Timing And Position Management [Part 2]
B7 Build Trader Review Records For Amazon Strategy Results And Lessons Learned [Part 3]
B8 Build A Governed FSI Amazon Position Management Playbook With AgentCore And Strands [Part 4]
B9 Build a Sovereign Risk Trading Agent with Amazon Bedrock AgentCore for Yield Spreads, FX Hedging, and Debt Repricing
B11 Build Modern Volatility Trading & Lawful Thailand Recovery Planning Agents: A Memory-Driven Strands Multi-Agent Risk Protection System
B12 Build Short Straddle Trading-Risk Governance with Amazon Bedrock AgentCore Memory
B13 Building Production-Ready Credit & Yield Staking AI Agents on Amazon EKS
Challenge
01 Weekend Productivity Challenge: Fab SPC Drift Synchronization Portal
02 Weekend Productivity Challenge: Quant P&L Commander — An AI-Powered Trading Productivity Portal on AWS
03 Weekend Annoying Task Challenge: Trading Desk Execute Summary On Cloud, On Chain, On Air
04 Weekend Agent Challenge: The 6 AM Trading Risk Review
05 Weekend Creative Challenge: Leadership Card Game
06 Full Stack Challenge: Community Day Board App
Leadership Card Game
01 Leadership Card Game: Last Skill Cloud Did Not Automate
02 Anatomy of a Leadership Round: How the Leadership Card Game Actually Plays
03 Leadership Card Game: When the Opportunity Stops Belonging to the Organizer
04 Weekend Creative Challenge: Leadership Card Game
05 From a Weekend Challenge Project to $1,386 Crowdfunding: The Leadership Practice That Changes How You Show Up at Work
06 From a Weekend Challenge Project to $1,386 Crowdfunding: A Day 1 Path Into the Tech Industry
07 From a Weekend Challenge Project to $1,386 Crowdfunding: Build a Professional Brand by Transferring Opportunity
08 Leadership Card Game — Crowdfunding Campaign
09 PR/FAQ 01 — Leadership Card Game launches for community builders
10 PR/FAQ 02 — Enterprise facilitators adopt Leadership Card Game for live leadership drills
10 PR/FAQ 03 — Multilingual Leadership Card Game opens global practice rooms for builder ownership
AWS Builder Center
01 AWS Builder Center, its community spirit, and AWS Builder Jacket
02 Inside AWS Builder Center, where a global technical platform becomes a place to learn, contribute, and belong
03 AWS Community Builder huge success
04 AWS Builder Center huge success
05 A weekend inside AWS Builder Center, from community inspiration to unmistakable AWS Builder Jacket

Description: Professional AMZN exposure management needs regime awareness, liquidity discipline, volatility control, trade surveillance, benchmark comparison, and explainable model-risk documentation. Build an AgentCore and Strands research workflow that converts strategy ideas into custom engine tests, dark-mode performance charts, ledger evidence, AWS governance artifacts, and investment committee narratives for institutional FSI users.


Disclaimer

Educational Purpose: Content presented here focuses exclusively on legitimate financial planning education, aiming to improve understanding of concepts, methodologies, and analytical approaches without promoting any specific securities, strategies, or market participation decisions.

No Personalized Advice: No personalized recommendations, solicitations, or assurances are provided, and no guarantees of future performance, outcomes, or returns are implied, expressed, or otherwise suggested under any circumstances within this educational material.

Data Limitations: Uploaded results rely on deterministic, offline data because live data was unavailable within the sandbox environment, and therefore outputs should be interpreted as illustrative examples rather than real time analyses.

Long-Only Scope: All research language used is long only, avoiding options, puts, short selling, or bearish strategies, ensuring the discussion remains focused on traditional asset ownership and positive directional exposure concepts overall.


Explain The Engine Before Explaining The Chart

A five-hundred-percent AMZN gain can tempt a speaker to start with the outcome. This article starts with the code path instead: price inputs, indicator series, Boolean entry and exit signals, cash handling, commission, risk exits, equity curve, and trade ledger. If that path is not explainable, the chart is not ready for committee discussion.

The articles do not recommend buying, selling, or holding Amazon. This part shows how to translate custom-engine mechanics into reviewable position-management language.


Positioning

The trader voice in part 2 is a code reviewer sitting beside the investment team. The goal is not to impress the committee with syntax. The goal is to show where market logic ends, where execution simulation begins, and where risk controls write evidence into the ledger.


The Client Problem Worth Solving

Many research presentations skip from indicator idea to performance table. That leaves risk, technology, and compliance teams guessing how the engine handled missing signals, open positions, costs, stop-loss triggers, take-profit exits, and end-of-test positions. This article closes that gap with plain-language code talk.


Business Outcomes This Workflow Supports

The workflow supports better code walkthroughs, cleaner model-risk questions, easier validation of long-only behavior, and clearer links between signal definitions and realized trades. It gives non-developers enough engine context to challenge results without turning the article into a full programming manual.


Table Of Contents

● Part 1: Institutional Opening And Trading Voice — Establishes the institutional trading voice, AMZN position context, communication discipline, and education-only framing.

● Part 2: Business Problem And Position Discipline — Defines why profitable long positions still need evidence-based entry, exit, sizing, drawdown, benchmark, and audit controls.

● Part 3: AgentCore And Strands Architecture — Explains agent roles, bounded authority, controlled tools, logged outputs, and reviewable financial-services workflow design.

● Part 4: Custom Cerebro Code Talk And Engine Controls — Maps custom engine logic, signal/execution separation, costs, ledgers, and code-review controls into trader language.

● Part 5: Momentum And Regime Strategy Records — Reviews momentum and regime strategy records through return, volatility, Sharpe, drawdown, trade count, win rate, and feasibility.

● Part 6: Executive Close And Governance Review — Turns code, charts, and ledgers into committee language and explains why human judgment remains the final control.

● Part 7: Engine Controls And Governance Lenses — Groups the engine-control details and governance lenses so policy, demo-data boundaries, ledger discipline, failure modes, and accountability are easy to follow.

● Part 8: AgentCore, Strands, And Custom Engine Code Talk — Separates the series focus, agentic operating model, and custom engine code explanation into one implementation section.

● Part 9: Performance Table And Momentum Strategy Records — Collects the strategy result table and five momentum/regime strategy records into one readable review section.

● Part 10: Trading Lessons, Source Notes, And Governance Close — Finishes with trading lessons, source notes, committee narrative, and final governance checklist.

Part 1: Institutional Opening And Trading Voice

Related summary: Establishes the institutional trading voice, AMZN position context, and communication discipline. It frames the article as education and planning support, not investment advice, recommendation, solicitation, or a promise of future returns.

The opening should not celebrate a position before it explains the control problem. A strong AMZN gain can create confidence, but confidence is not a substitute for entry discipline, exit discipline, sizing logic, drawdown tolerance, and benchmark-relative review.

The useful practice-note message is absorbed here as speaking discipline: use evidence language, state the data mode, name the assumptions, and avoid promising certainty. The article should read like institutional research, not like a promotional pitch.


Part 2: Business Problem And Position Discipline

Related summary: Defines why profitable long positions still require evidence-based entry, exit, sizing, drawdown, and benchmark controls. It connects portfolio management, risk oversight, technology governance, and audit requirements into one reviewable workflow.

The business problem is fragmented evidence. Portfolio teams want speed, risk teams want traceability, technology teams want secure orchestration, and compliance teams want appropriate language. The workflow aligns those needs by creating a repeatable research path.

Position discipline means every strategy should answer the same questions: why enter, why exit, how much exposure, what cost assumption, what drawdown path, and what benchmark context. Those questions are now part of the main article body rather than a note at the end.


Part 3: AgentCore And Strands Architecture

Related summary: Explains the agentic architecture by separating orchestrator, data agent, strategy agent, backtest tool, risk reviewer, and governance checker. Each component has bounded authority, controlled tools, and logged outputs for financial-services review.

The architecture separates code responsibilities. The Quant Orchestrator frames the request, the Strategy Agent produces entry and exit series, the custom engine simulates cash and shares, the Risk Review Agent reads metrics and ledger rows, and the Governance Agent checks whether the explanation matches the actual order path.

Agent governance means bounded authority. The agent can prepare evidence, but it cannot decide suitability, guarantee returns, or replace the investment committee. Logs and artifacts make the workflow challengeable.


Part 4: Custom Cerebro Code Talk And Engine Controls

Related summary: Explains the article-specific engine path, code talk, strategy logic, and review controls. The section converts implementation details into trader language that can be challenged by risk, technology, and governance stakeholders.

The code path should be explained as a control map. Inputs feed indicators, indicators create entry and exit signals, the engine simulates orders, costs are applied, the ledger is written, and metrics summarize the path. That sequence replaces line-by-line recital with business-readable logic.

Signal logic and execution logic should remain separate. A signal may say conditions are favorable, but the engine must still check cash, position state, commission, risk exits, and ledger updates. This separation improves review quality.

This article focuses on custom engine logic, code talk, momentum-plus-regime strategy records, and reviewable simulation controls. The reader should evaluate whether the code path makes those controls visible enough for a committee, risk reviewer, or technology owner to challenge.


Part 5: Momentum And Regime Strategy Records

Related summary: Reviews strategy records and lessons learned through return, volatility, Sharpe, drawdown, trade count, win rate, ledger quality, and operational feasibility. The section treats demo results as workflow evidence, not real market advice.

Strategy records should not be read as recommendations. They are evidence for comparing rule behavior, trade frequency, drawdown profile, and explainability. The numbers are especially limited when the data mode is deterministic offline demo data.

Lessons learned should be specific. A high-return strategy may have uncomfortable drawdown. A low-turnover strategy may be easier to govern. A high-trade-count strategy may create decision fatigue, slippage exposure, and operational burden.


Part 6: Executive Close And Governance Review

Related summary: Turns code, charts, and ledgers into committee language: what was tested, what improved, what failed, what remains uncertain, and why human judgment remains the final control before any production or allocation decision.

The close should translate research into governance language. The committee needs to know what was tested, what evidence was generated, which assumptions matter, what failed, and what remains a human decision.

A responsible close avoids victory language. It says that agents can help document assumptions, run repeatable tests, compare behavior, and prepare better reviews, while human judgment remains the final control.


Part 7: Engine Controls And Governance Lenses

Related summary: Groups the engine-control details and governance lenses so policy, demo-data boundaries, ledger discipline, failure modes, and accountability are easy to follow.

Engine Control Surface

The engine constructor is the control surface: price series, starting capital, allocation, commission, stop-loss, and take-profit. Each parameter should be visible before a strategy run starts.

Signal Versus Execution

Signal generation and order simulation should remain separate. The Strategy Agent produces entry and exit booleans, while the engine handles cash, shares, costs, risk exits, equity, and ledger records.

Code Talk Discipline

A good code talk follows the operational path: inputs, indicators, signals, order simulation, costs, ledger creation, metrics, and charts. That language lets executives understand the control map without reading every line.

Offline Demo Framing

The uploaded results are deterministic offline demo records. They can teach workflow and review structure, but they should not be presented as real AMZN market-performance evidence.

Evidence Before Opinion

The research narrative should first identify data mode, rule logic, assumptions, costs, drawdown, and ledger availability. Opinion comes after evidence, not before it.

Demo Data Boundary

When results come from offline deterministic demo data, the article should say so in the main body. Demo records are useful for workflow education and review design, not for making a real allocation decision.

Ledger As Desk Memory

A trade ledger is the desk memory system. It shows when positions opened, when they closed, what size was used, which signal fired, and whether the process respected risk rules.

Failure Mode Review

Professional readers should see failure modes before conclusions. Trend rules can whipsaw, recovery rules can miss persistent weakness, and active signals can create turnover that looks cleaner in a notebook than on a desk.

Human Accountability

Agentic tools can gather, run, summarize, and organize, but the portfolio owner remains responsible for mandate fit, suitability, risk tolerance, and final judgment.


Part 8: AgentCore, Strands, And Custom Engine Code Talk

Related summary: Separates the series focus, agentic operating model, and custom engine code explanation into one implementation section.

Series Focus

This post is part 2 of four and concentrates on code talk, custom engine logic, and momentum-plus-regime strategy records. It uses Bedrock AgentCore and Strands Agents as the agentic operating model, the uploaded custom Cerebro-style engine as the code foundation, and the strategy summary records as the performance-review evidence. The discussion is educational, not a recommendation.


Bedrock AgentCore And Strands Agents Operating Model

The production design separates five responsibilities. The Quant Orchestrator receives the research request and decomposes it into data, strategy, execution, risk, and governance tasks. The Market Data Agent retrieves or validates AMZN and benchmark data. The Strategy Agent produces entry and exit signals. The Backtest Engine Tool runs the custom Cerebro-style simulation. The Risk Review Agent reads the trade ledger, performance metrics, and charts. The Governance Agent checks disclosures, long-only policy, data provenance, and suitability language.

AgentCore Runtime is the secure hosting layer for agents and tools, while Strands Agents provides a programming model for tool calling, orchestration, and agent behavior. In a regulated FSI environment, the agent should not directly approve a trade. It should create evidence, highlight uncertainty, and route outputs to human review.

For this code-talk article, the AWS layer matters because it keeps implementation evidence near the result. A reviewer should be able to retrieve the engine version, parameter surface, generated signals, trade ledger, and chart artifacts together, then confirm that the article's plain-English explanation matches the stored run.


Code Talk: Custom Cerebro-Style Engine Logic

Custom Cerebro engine pipeline
Custom Cerebro engine pipeline

The custom engine is intentionally small. The constructor stores the price series, starting capital, allocation percentage, commission, stop-loss percentage, and take-profit percentage. Those parameters become the control surface that the Risk Agent and Governance Agent can inspect before the strategy runs.

The run method receives two Boolean time series: entry and exit. The Strategy Agent builds those series from indicators. The engine is responsible for execution discipline. It aligns signals to the price index, fills missing signal values as False, and then walks forward through time without looking ahead.

class CustomCerebroEngine:
    def __init__(self, price, initial_cash=100000, allocation=0.95,
                 commission=0.0005, stop_loss=0.12, take_profit=0.35):
        self.price = price.astype(float)
        self.initial_cash = initial_cash
        self.allocation = allocation
        self.commission = commission
        self.stop_loss = stop_loss
        self.take_profit = take_profit

    def run(self, entry, exit):
        entry = entry.reindex(self.price.index).fillna(False)
        exit = exit.reindex(self.price.index).fillna(False)
        cash, shares, entry_price = self.initial_cash, 0, None
        trades, equity, position = [], [], []
        for dt, px in self.price.items():
            if shares > 0:
                stop_hit = px <= entry_price * (1 - self.stop_loss)
                target_hit = px >= entry_price * (1 + self.take_profit)
                if bool(exit.loc[dt]) or stop_hit or target_hit:
                    gross = shares * px
                    cash += gross - gross * self.commission
                    trades[-1].update({"exit_date": dt, "exit_price": px,
                                       "gross_pnl": (px - entry_price) * shares})
                    shares, entry_price = 0, None
            if shares == 0 and bool(entry.loc[dt]):
                invest = cash * self.allocation
                shares = int(invest / px)
                if shares > 0:
                    cash -= shares * px + shares * px * self.commission
                    entry_price = px
                    trades.append({"entry_date": dt, "entry_price": px,
                                   "shares": shares, "entry_reason": "signal"})
            equity.append(cash + shares * px)
            position.append(shares)
        return pd.Series(equity, index=self.price.index), pd.DataFrame(trades), pd.Series(position, index=self.price.index)

When the engine already owns shares, it checks three exit conditions: a strategy exit signal, a stop-loss breach, or a take-profit trigger. If one condition is true, the engine sells the long position, subtracts commission, updates cash, and records realized gross profit or loss in the trade ledger.


Part 9: Performance Table And Momentum Strategy Records

Related summary: Collects the strategy result table and five momentum/regime strategy records into one readable review section.

Strategy Result And Performance Review

Strategy ranking overview
Strategy ranking overview

The uploaded summary ranks twenty custom-engine strategies by total return, annual return, volatility, Sharpe, maximum drawdown, trade count, and win rate. The uploaded manifest identifies the engine as CustomCerebroEngine, shows strategy count of twenty and image count of twenty-two, and states the rules: long-only, no options, no puts, and no shorts.

The table below is a trader's record, not investment advice. Because the manifest states that the data mode is deterministic offline demo data, the numbers are useful for explaining workflow and code logic, not for making a real allocation decision. In production, the same workflow should be rerun against validated real AMZN and benchmark data.

RankStrategyTotal ReturnAnnual ReturnVolatilitySharpeMax DrawdownTradesWin Rate
1IchimokuLongStrategy1430.60%14.08%12.33%1.14-22.43%5347.17%
2DonchianTrendStrategy921.18%11.87%11.43%1.04-24.64%2070.00%
3ADXTrendStrategy723.63%10.72%9.13%1.17-16.88%11651.72%
4MultiFactorEnsembleStrategy604.05%9.88%11.23%0.88-24.44%14333.57%
5RelativeStrengthNDXStrategy587.02%9.75%11.17%0.87-23.23%13545.19%
6Breakout55Strategy555.52%9.50%10.65%0.89-24.14%2759.26%
7CCIMomentumStrategy551.10%9.47%9.81%0.96-19.07%11549.57%
8ParabolicSARStrategy497.68%9.01%11.78%0.76-24.28%35725.77%
9MACDTrendStrategy430.40%8.39%10.69%0.78-26.60%21441.59%
10MarketRegimeSPXStrategy421.61%8.30%10.44%0.79-23.20%16732.34%
11GoldenCrossStrategy330.81%7.31%9.80%0.75-27.62%1070.00%
12DowRiskFilterStrategy181.18%5.12%8.78%0.58-19.07%1855.56%
13RateOfChangeStrategy161.42%4.75%9.56%0.50-44.62%21345.07%
14EMACrossStrategy143.43%4.39%8.61%0.51-17.57%4050.00%
15RSIRecoveryStrategy50.38%1.99%5.50%0.36-23.55%1872.22%
16StochasticStrengthStrategy28.78%1.23%8.70%0.14-27.95%74140.35%
17KeltnerChannelStrategy27.40%1.18%3.74%0.31-10.50%1369.23%
18BollingerReversionStrategy16.69%0.75%4.66%0.16-28.36%4671.74%
19VolumeConfirmStrategy5.95%0.28%1.87%0.15-12.46%540.00%
20ATRChannelStrategy1.52%0.07%1.93%0.04-7.28%366.67%

Strategy Record: Breakout55Strategy

Breakout55Strategy
Breakout55Strategy

Code talk. Breakout55Strategy buys a fifty-five-day breakout and exits on a twenty-day channel failure. For Breakout55Strategy, the signal definition should be reviewed separately from execution mechanics so the committee can distinguish market logic from order simulation, cost handling, and ledger production.

Performance review by trader. Total return was 555.52%, annual return was 9.50%, volatility was 10.65%, Sharpe was 0.89, maximum drawdown was -24.14%, trades were 27, and win rate was 59.26%. These numbers are uploaded custom-engine offline demo records, not real market results.

Trading record and lesson learned. The lesson for Breakout55Strategy is to use the record as a review prompt: inspect explainability, turnover, drawdown tolerance, cost sensitivity, and whether the rule adds position-management insight beyond the headline return.


Strategy Record: CCIMomentumStrategy

CCIMomentumStrategy
CCIMomentumStrategy

Code talk. CCIMomentumStrategy uses CCI above 100 as momentum entry and exits below zero. For CCIMomentumStrategy, the signal definition should be reviewed separately from execution mechanics so the committee can distinguish market logic from order simulation, cost handling, and ledger production.

Performance review by trader. Total return was 551.10%, annual return was 9.47%, volatility was 9.81%, Sharpe was 0.96, maximum drawdown was -19.07%, trades were 115, and win rate was 49.57%. These numbers are uploaded custom-engine offline demo records, not real market results.

Trading record and lesson learned. The lesson for CCIMomentumStrategy is to use the record as a review prompt: inspect explainability, turnover, drawdown tolerance, cost sensitivity, and whether the rule adds position-management insight beyond the headline return.


Strategy Record: ParabolicSARStrategy

ParabolicSARStrategy
ParabolicSARStrategy

Code talk. ParabolicSARStrategy approximates trend flips and shows how very active signals affect records. For ParabolicSARStrategy, the signal definition should be reviewed separately from execution mechanics so the committee can distinguish market logic from order simulation, cost handling, and ledger production.

Performance review by trader. Total return was 497.68%, annual return was 9.01%, volatility was 11.78%, Sharpe was 0.76, maximum drawdown was -24.28%, trades were 357, and win rate was 25.77%. These numbers are uploaded custom-engine offline demo records, not real market results.

Trading record and lesson learned. The lesson for ParabolicSARStrategy is to use the record as a review prompt: inspect explainability, turnover, drawdown tolerance, cost sensitivity, and whether the rule adds position-management insight beyond the headline return.


Strategy Record: MACDTrendStrategy

MACDTrendStrategy
MACDTrendStrategy

Code talk. MACDTrendStrategy enters when MACD histogram turns positive and exits when negative. For MACDTrendStrategy, the signal definition should be reviewed separately from execution mechanics so the committee can distinguish market logic from order simulation, cost handling, and ledger production.

Performance review by trader. Total return was 430.40%, annual return was 8.39%, volatility was 10.69%, Sharpe was 0.78, maximum drawdown was -26.60%, trades were 214, and win rate was 41.59%. These numbers are uploaded custom-engine offline demo records, not real market results.

Trading record and lesson learned. The lesson for MACDTrendStrategy is to use the record as a review prompt: inspect explainability, turnover, drawdown tolerance, cost sensitivity, and whether the rule adds position-management insight beyond the headline return.


Strategy Record: MarketRegimeSPXStrategy

MarketRegimeSPXStrategy
MarketRegimeSPXStrategy

Code talk. MarketRegimeSPXStrategy requires S&P 500 regime support plus AMZN trend support. For MarketRegimeSPXStrategy, the signal definition should be reviewed separately from execution mechanics so the committee can distinguish market logic from order simulation, cost handling, and ledger production.

Performance review by trader. Total return was 421.61%, annual return was 8.30%, volatility was 10.44%, Sharpe was 0.79, maximum drawdown was -23.20%, trades were 167, and win rate was 32.34%. These numbers are uploaded custom-engine offline demo records, not real market results.

Trading record and lesson learned. The lesson for MarketRegimeSPXStrategy is to use the record as a review prompt: inspect explainability, turnover, drawdown tolerance, cost sensitivity, and whether the rule adds position-management insight beyond the headline return.


Part 10: Trading Lessons, Source Notes, And Governance Close

Related summary: Finishes with trading lessons, source notes, committee narrative, and final governance checklist.

Trading Records And Lessons Learned

A trade record is more than a receipt. It is a memory system for the desk. Each entry date asks whether the trader had a repeatable signal or only a story. Each exit date asks whether the process respected risk or waited for emotion to negotiate. Each drawdown asks whether the sizing rule was honest about volatility.

The first lesson in the code-talk article is that signal logic and execution mechanics must be reviewed separately. A clean indicator can still produce weak evidence if the engine handles costs, stops, or open trades poorly.

The second lesson is that plain-English implementation review improves governance. When a committee can follow inputs, signals, orders, ledger rows, metrics, and charts in sequence, it can challenge the result without relying on trust in a notebook.

The third lesson is that active signals are a code-review stress test. High trade counts force reviewers to inspect whether the engine applies commissions consistently, records exits cleanly, avoids lookahead behavior, and keeps every ledger row tied to an explainable signal or risk event.


Source And Evidence Notes

This article uses the uploaded custom engine artifacts as its performance discussion source. The manifest states that the engine is CustomCerebroEngine, the data mode is deterministic offline demo data, the strategy count is twenty, the image count is twenty-two, and the rules are long-only with no options, no puts, and no shorts. The strategy summary file ranks all twenty strategies by total return, annual return, volatility, Sharpe, maximum drawdown, trades, and win rate. The uploaded code file supplies the engine structure, indicator definitions, signal map, metrics function, and Bloomberg dark-mode chart generation approach.

External architecture references: Amazon Bedrock AgentCore documentation describes AgentCore as a managed service for deploying and operating agents securely at scale, and AgentCore Runtime as a secure serverless environment supporting frameworks such as Strands, LangGraph, and CrewAI. Strands documentation describes deploying Strands Agents to AgentCore Runtime and using Python integration patterns for agent entrypoints. Backtrader documentation is referenced conceptually for the Cerebro pattern of gathering data feeds, strategies, analyzers, observers, and plotting facilities.


Committee Close Narrative

Here is the closing message to rehearse before presenting the research:

We are not here to celebrate a gain. We are here to inspect the process behind the gain. The Amazon position has been strong, but strength does not remove the need for risk discipline. We built a custom engine, organized twenty timing strategies, reviewed the records, and separated research evidence from recommendation language.

The correct conclusion is not that an agent should trade for us. The correct conclusion is that agents can help us document assumptions, run repeatable tests, compare strategy behavior, expose weak logic, and prepare better conversations with risk, technology, and governance teams. Human judgment remains the final control.


Final Governance Checklist

● Confirm the workflow is education and planning support, not investment advice.

● Confirm the position language is long-only and avoids derivative implementation.

● Confirm whether results are real-data backtests or offline demo outputs.

● Confirm each strategy has a trade ledger, equity curve, drawdown path, and performance summary.

● Confirm code, data, parameters, and charts are versioned together.

● Confirm the investment committee understands limitations before discussing any allocation decision.