Your AI Copilot.

Be honest about the last bad trade — not the polite version, the real one.

You knew it was wrong while you were doing it. You knew you were down on the day and sizing up to get back.

You knew the market was chopping and your edge needs a trend.

You knew the stop was too wide for the lot.

You knew you were entering because you were bored, angry, behind target, or trying to make the chart apologize.

The knowledge was all there, and it changed nothing — because at the moment that mattered, there was no one in the room but you and your worst impulse.

That is the real problem, and almost nobody names it correctly. Not knowledge — supervision. Professional desks solve it with structure: a risk officer, a second set of eyes, a checklist someone actually enforces. You trade alone in a bedroom with five monitors and the supervision of absolutely nobody, which means you get the rules of a professional and the impulse control of a raccoon with a brokerage account.

The move that costs almost nothing: build yourself a copilot. Not a signal bot, not a magic AI that predicts the next candle, not an "AI trading system" that prints money while you sleep — that's the part of the internet where common sense goes to get mugged (and it's a scam). A copilot is the boring, powerful thing instead: a personal AI that holds your rules, checks your trades against them, sizes by your plan, and reviews your sessions without flattering you. It's the calm, rule-following version of you — on call 24/7, never tired, never tilted, never desperate to win a loss back. You build the trader you are when you're calm, then let it check the trader you become when you're not.

Save this and actually build it — it takes an afternoon. And send it to the trader who knows every rule and breaks them all alone. That trader doesn't need another indicator. They need someone in the room.

The 60-second version

You don't have a knowledge problem; you have an execution problem — and execution fails because you're unsupervised at the exact moment your judgment is worst. A copilot is supervision you can build: use a Claude Project, a custom GPT, or any AI workspace that saves instructions and reads your files. You give it your trading constitution — your edge, your regime, your risk rules, your sizing limits, your correlation cap, your kill-switch, your review process — and then you give it three jobs: before the trade, red-team it; while sizing, enforce the rule; after the session, review without flattery.

It does not predict markets, generate signals, create an edge, or replace your judgment. It supervises your judgment. The catch is honest: it's only as good as the rules you give it. If your rules are vague, it enforces vagueness; if your process is reckless, it helps you be recklessly consistent — garbage in, garbage out. Which is exactly why building it helps: to build it, you have to write the system down, and most traders have never done that. They think they have rules. They have vibes wearing bullet points. A copilot makes vibes illegal.

I — The problem is supervision, not knowledge

You already know most of the rules — count R, don't size up in a drawdown, don't revenge-trade, trade your regime, cap correlated exposure, no martingale, stop after the daily loss limit. You know all of it. That didn't save the last bad trade, because knowledge is not the same as enforcement. The smartest people in high-pressure fields still use checklists — not because they're stupid, but because pressure makes obvious things disappear. Aviation learned it after a bomber so complex it killed an expert test pilot; medicine learned it when a 19-item surgical checklist cut major complications by about a third and deaths by over 40% across hospitals worldwide (WHO / NEJM, 2009). A checklist isn't for people who don't know what to do — it's for people who know exactly what to do and still fail under pressure. A trading copilot is a checklist that argues back. It's not there to educate you at 2 a.m.; it's there to stop the 2 a.m. version of you from editing the plan.

Who is in the room when you click?

If the answer is "nobody," then the worst version of you has admin rights — and that's a security flaw.

II — What a copilot is, and what it is not

Be ruthless here, because this is exactly where most AI-trading products turn rotten. A copilot is not:

• a predictor, a signal generator, or an oracle;
• a black box, a replacement for your system, or a permission slip to stop thinking.

It does not know where price is going. It does not have a secret feed from the future. It does not "feel institutional liquidity," and it does not smell where gold goes next, because gold does not emit a fragrance called alpha. A copilot is:

• a rule-keeper, a red-teamer, a sizing enforcer, and a journal analyst;
• a second set of eyes — a skeptic you can summon before you do something dumb.

Its job is not to be clever; its job is to be consistent. Keep that distinction bright and you'll avoid most AI-trading nonsense.

An AI that claims to predict the market is a liar. An AI that helps you obey your own rules is a colleague.

III — Build it in an afternoon

No coding, no API, no "agent architecture" diagram that looks like someone spilled spaghetti on a whiteboard. You need three things.

1. A persistent AI workspace. A Claude Project, a custom GPT, or any tool that saves long instructions and reads uploaded files. The tool matters less than persistence — you want the rules to stay loaded, not re-explained every morning while your coffee gets cold.

2. A trading constitution. The system prompt. It defines who the copilot is, what your edge is, the regime it needs, how you size, when you skip, what counts as a rule break, how review works, and what the copilot is forbidden to do. This — not the AI — is the actual work.

3. Your journal and notes. Upload your trade journal in R, your strategy notes, your risk rules, and your regime definitions. Now the copilot has context: it can check new decisions against old evidence and tell you when a proposed trade doesn't match the system you claim to trade. That's uncomfortable. Good — comfort is how the bad trades got in.

IV — Job 1: red-team the trade

The highest-value job. Before you enter, paste the setup and make the copilot argue against it — not approve it, not cheer it, not say "great plan, good luck" (that assistant belongs in a group chat with fireworks emojis). You want a skeptic that checks: is this the right regime, does it match the setup, is the stop valid, is the size legal, are correlated positions already open, am I down on the day, am I trying to recover, is this FOMO or boredom — is this a setup or a story? Then it returns one verdict — GO / SIZE-DOWN / SKIP — with rule-based reasons, not a five-paragraph horoscope. The point isn't that the AI is always right (prompting it to reason and challenge a choice does measurably reduce bias, but it's no oracle); the point is that it forces you to explain the trade to something instructed not to flatter you. Half of bad trades die the moment you have to describe them out loud to a skeptic.

V — Job 2: enforce the size

This is where the copilot becomes more than a checklist: it calculates the allowed size from your rules — not your mood, not your confidence, not the fact that the last two trades won. The sizing logic reads your current equity, risk per trade, stop distance, current drawdown, regime, correlation cap, daily-loss state, and kill-switch state, and returns a size — or a SKIP. For example: base risk 1%, regime unclear so half size, drawdown −10% so the ladder says 0.66×, USD exposure already near the cap → verdict SIZE-DOWN or SKIP.

This is where it earns its rent, because the bad version of you is very good at negotiating size — "just this once," "small recovery lot," "back to breakeven then I stop." The copilot doesn't care about your emotional recovery plan; it sizes by the constitution. (It's fractional Kelly, the drawdown ladder, the regime filter, and the correlation cap enforced by something that can't be talked into "just this once.") You don't need the discipline to size correctly every time. You need the discipline to ask the copilot once — and obey.

VI — Job 3: run the review

After the session, paste the trades and the copilot reviews them in the language of the system — not vibes, but R, regime, expectancy, leaks, and violations. Instruct it to compute your total R, expectancy, win rate, average win/loss in R, results by regime, biggest rule violation, biggest sizing mistake, and the one change for next session — and to be blunt, with no flattery. Most traders don't review; they narrate. They explain the losses, remember the good trade, quietly skip the ugly entry, and turn the session into a story where they were almost disciplined. The copilot kills the story — not because it's smarter than you, but because it has no need to protect your ego. It replaces the story you tell about your trading with the data your trading actually produced. That's what a journal should have been all along.

VII — The prompt is your system, written down

This is the deepest part: the copilot is only as good as the prompt, and that is why it works. To build one, you must convert your trading from "I know my setup when I see it" into "this is my setup, these are the conditions, this is the regime, this is the risk, this is when I skip, this is when I stop." That conversion is painful — it exposes holes, and you'll find brackets you can't fill. Good. Those brackets aren't prompt problems; they're trading problems. Rules in your head bend when you're down 2%; rules in a constitution just sit there, rude and useful. You can't give a copilot a feeling. You have to give it a rule — which means you finally have to have one. That's using AI like a quant: the labor around the edge, not the pretense that the AI is the edge.

VIII — What it cannot do

The honest limits, because this is where the grift lives if we don't draw the line. A copilot cannot create an edge — if your strategy loses, it helps you lose more consistently (very organized, very tragic). It cannot predict the next candle — it can only help you not break rules around it. It cannot verify numbers you didn't give it — paste fake journal data and it reviews fake data; tell it your win rate is 70% when the account says otherwise and it'll build a beautiful risk plan on a lie. And it can be confidently wrong, can agree too eagerly, can make arithmetic mistakes, and can treat your assumptions as facts unless told not to — which is why the constitution must include guardrails: don't invent prices or signals, don't assume my edge is real, treat my numbers as inputs to check, default conservative when uncertain.

A copilot amplifies your process: a good one becomes easier to follow, a bad one easier to repeat — garbage in, garbage out, only now the garbage has a clean interface. So build the process first, then let the copilot enforce it.

The copilot constitution

Copy this into a Claude Project, custom GPT, or any persistent AI workspace, and fill every bracket with your real rules. If you can't fill a bracket, don't skip it — that blank is a hole in your system.

You are my trading copilot.

Your job is to enforce my trading rules, red-team my decisions,
calculate allowed size, and review my sessions honestly.

You do not predict markets.
You do not generate signals.
You do not hold an independent market opinion.
You do not flatter me.
You do not help me justify breaking rules.
You are skeptical by default.

WHO YOU ARE
- You are my rule-keeper, risk checker, and review analyst.
- Your job is to protect the account from impulsive decisions.
- If I am about to break a rule, say so plainly.
- If information is missing, ask for it.
- If uncertain, default to the conservative action.

MY EDGE
- My setup / edge in one falsifiable sentence:
  [write the exact setup here]
- Market regime where this edge works:
  [trend / range / volatility / session / instrument]
- Market regime where this edge bleeds (do NOT trade):
  [the conditions where I should stay flat]
- Evidence supporting this edge:
  [journal sample / backtest / forward test]

MY RISK RULES
- Base risk per trade: [e.g. 1% of CURRENT equity]
- Size from current equity, not fixed lots.
- Regime sizing: full in [money regime], half in [survive], flat in [bleed/unclear].
- Correlation cap: total risk on one driver <= [e.g. 2%]
  (drivers: USD, risk-on/off, rates, commodity, crypto, equity beta).
- Drawdown ladder:
  at -[8]% reduce risk to 0.66x
  at -[15]% reduce to 0.5x
  at -[22]% stop and review
- Daily loss stop: [-3%]   Weekly loss stop: [-6%]
- Kill-switch: [the condition that halts everything]
- Forbidden: no martingale, no size-up to recover, no widening stops,
  no revenge trades, no trades outside regime, no trade without a stop.

JOB 1 - RED-TEAM BEFORE ENTRY
When I describe a proposed trade:
  1. Argue the strongest case AGAINST taking it.
  2. Check it against my edge definition and current regime.
  3. Check risk, stop distance, and position size.
  4. Check correlation exposure and daily/weekly loss state.
  5. Flag emotion: revenge, FOMO, boredom, urgency, overconfidence.
  6. Return one verdict only: GO / SIZE-DOWN / SKIP.
  7. Explain it using my written rules.

JOB 2 - SIZE THE TRADE
Given equity, stop distance, drawdown, regime, and open positions:
  1. Calculate base risk, then apply the drawdown ladder,
     regime sizing, correlation cap, and daily/weekly stops.
  2. Show the math.
  3. If allowed size is zero, say SKIP.
  4. Never suggest increasing size to recover a loss.

JOB 3 - REVIEW AFTER SESSION
When I paste trades (in R, with regime at entry):
  1. Compute expectancy, win rate, average win/loss in R.
  2. Analyze performance by regime.
  3. Identify rule violations and the single biggest leak.
  4. Say whether losses came from variance, wrong regime,
     oversizing, or rule breaks.
  5. Give one concrete correction for next session.
  6. Be blunt. No flattery.

GUARDRAILS
- Never invent prices, signals, statistics, or edge.
- Never assume my numbers are correct if they are incomplete.
- Never recommend a trade based on your own prediction.
- Never place trades. Never optimize my rules mid-decision.
- When in doubt, protect the account.

The daily prompts

Before a trade:

Red-team this trade before I take it. Argue against it first, check it
against my written rules, flag any emotion or rule violation, then return
one verdict: GO / SIZE-DOWN / SKIP.

Trade:   symbol · direction · entry · stop · target · setup · why now
Context: equity · today's P&L · current drawdown · current regime ·
         open positions · correlated exposure · daily/weekly loss status

After the session:

Review my session. Trades as R-multiples, with the regime at entry:
[paste]

Compute total R, expectancy, win rate, avg win/loss in R, result by
regime, my biggest mistake, every rule violation, and one correction for
next session. Be blunt. Do not flatter me. If I broke rules, name them.

Once a week:

Run a weekly process review using this week's trades and my constitution.
Compare trades taken vs trades my rules allowed; find repeated violations;
say whether losses were valid, wrong-regime, oversizing, revenge/FOMO, or
correlation stacking; tell me the one rule to tighten and the one I
followed well. No motivation — only process evidence.

The 20-minute build

Minutes 0–5 — Open the tool. Start a Claude Project, a custom GPT, or any persistent AI workspace that saves instructions and accepts a file. Nothing fancy — fancy is where procrastination hides.

Minutes 5–15 — Write the constitution. Paste the template and fill every bracket. Don't make it pretty; make it true. If you can't fill your edge, your regime, your risk cap, or your kill-switch, the copilot just found the hole — and that's already progress.

Minutes 15–20 — Red-team your last trade. Not the next one. The last one — the real one you already took. Paste it in, ask for a red-team, and read the verdict without arguing. That first review is usually the moment the tool becomes real, because it will probably say the thing you knew and ignored.

Where this meets ProEA

A copilot enforces rules — which means it needs rules it can actually read, and that's the quiet argument for owning source over renting a black box. A closed EA can't easily tell your copilot what it assumes, how it sizes, when it should stop, or what counts as a violation; readable source can. With MTR you can hand the copilot the real logic and risk rules, ask it to summarize the sizing layer, check whether a proposed setting violates the plan, and review trades against the system's own rules. That doesn't make MTR profitable, and it doesn't make any system safe — the copilot makes you more consistent with the process you chose, and MTR can lose. Inspectable rules plus a copilot to enforce them beat a black box you must trust and a discipline you don't have.

Does it claim to know the market, or does it help you follow your own plan?

Ask that of any "AI trading" product. Only one of those answers is real.

Disclosure

We sell source and evidence you can inspect — not outcomes, not guarantees. An AI copilot does not predict markets, generate edge, or guarantee profit; it enforces the rules you give it and structures your data. Large language models can be wrong, can be overly agreeable, can misread numbers, and can treat bad inputs as true unless instructed otherwise — use a copilot as a skeptical second opinion, not an oracle, and never let it place trades, invent signals, or override your risk controls. Garbage in, garbage out: a copilot built on a losing process will faithfully run a losing process. Trading is risky, leverage magnifies risk, and past performance is not future performance. The copilot's only promise is consistency with a plan you chose — which is valuable, and is not the same as winning.

Your first 20 minutes

Open a Claude Project or a custom GPT. Paste the constitution and fill it with your real rules — noticing every bracket you can't complete, because that blank is a hole in your trading. Upload your journal. Then red-team your last trade and read the verdict without arguing. You'll have built, in twenty minutes and for free, the one thing a lone trader almost never has: someone in the room who knows the rules and isn't afraid to tell you you're breaking them.

The one line to take with you

You don't need a smarter strategy or a magic AI. You need to follow the rules you already claim to have — so build the thing that makes you. The best AI in trading isn't the one that predicts the market. It's the one that predicts you — and stops you.