LLM trading prompt examples: templates you fill in yourself

Educational only. Not investment advice. Crypto trading carries significant risk of loss.

Why templates and not ready-made strategies

Search for llm trading prompts and you'll find plenty of people willing to hand you theirs — a full block of text with entry conditions, thresholds, and exit rules already filled in. Don't copy it. A prompt someone else wrote is their strategy, built from their read of the market and their tolerance for risk, not yours. You can feed their words into a model, but you can't evaluate whether any given decision is right, because you don't have access to the intent behind the rule — only the rule itself.

That gap shows up the moment a signal looks wrong. If the model skips a setup you'd have taken, or takes one you wouldn't have, you need to trace the decision back to a criterion you understand well enough to judge. With your own wording, that trace is immediate — you wrote the invalidation clause, so you can tell straight away whether the model honored it. With borrowed wording, you're stuck guessing at what the original author intended, which is a worse position than having no strategy at all. It looks like discipline while actually being blind trust in a stranger's judgment.

This is also where authorship stops being a style preference and becomes the thing that keeps a trading tool a tool. A prompt you wrote is your own analysis, executed faithfully by a model. A prompt someone else wrote and handed to you as a preset is closer to a recommendation — a decision made on your behalf and dressed up as a setting. Every template below is built to make copying pointless: each line carries a bracket only you can fill in before anything runs.

The anatomy of a trading prompt

Strip away the specific wording and every working trading prompt is built from the same four blocks, whether it runs a few lines or a full page.

Market context — the data the model actually sees: price action, funding rates, whatever technical readings your approach relies on, maybe a sentiment digest. This part is usually assembled by the tooling around the model rather than typed by hand each cycle, but you should still know what's in it, since a model can only reason over what it's handed.

Entry criteria — yours. The specific conditions that define a setup you'd actually take: what structure, what confirmation, what has to be true before you'd put money behind it. No template can supply this part for you, because it's the part that encodes your edge.

Risk rules — also yours. Position size, stop-loss logic, a minimum reward relative to risk. These aren't optional flavor text tacked on at the end; leave them out and a thesis is just a bet with no floor under it.

Output contract — the shape of the answer you need back: a decision (long, short, or skip), the specific levels, and a short written thesis explaining why. Getting this part precise carries as much weight as the analysis itself — a well-reasoned answer that arrives as loose prose instead of a parseable decision is useless to whatever has to act on it next.

Entry prompt template

Every ai trading prompt needs the same handful of pieces once you strip away specific wording. Here's one shaped as an entry template — fill in every bracket before it goes anywhere near a live signal:

• Setup: Only consider a trade when [YOUR_SETUP — the specific price structure, level interaction, or derivatives condition you actually trust].
• Confirmation: Require [YOUR_CONFIRMATION — what has to be true, on top of the setup, before you'd act on it].
• Invalidation: Skip the idea entirely if [YOUR_INVALIDATION — the specific conditions that kill it, not just "if it looks wrong"].
• Risk: Risk no more than [YOUR_RISK_% — a fixed share of allocated capital] per position; place the stop-loss at [YOUR_SL_LOGIC]; require a minimum reward-to-risk of [YOUR_RR] before entry.
• Output: Return LONG, SHORT, or SKIP with the entry level, stop-loss, and take-profit target, plus a two-sentence thesis explaining the call.

Every bracket is a decision only you can make. If you're tempted to fill one in with a number you saw in someone's post or clip, stop — that number encodes their risk tolerance, not yours, and copying it defeats the entire point of writing the prompt yourself.

Manage-position prompt template

A manage-trade prompt runs on a different cadence than an entry prompt — it reassesses a position that's already open, not whether to take a new one. The shape is similar; the questions change:

• Hold condition: Keep the position open while [YOUR_HOLD_CONDITION — what has to keep being true for the original thesis to still stand].
• Partial-close trigger: Take partial profit when [YOUR_PARTIAL_RULE — the level, ratio, or condition that tells you to bank part of the position].
• Breakeven / stop-move rule: Move the stop-loss to [YOUR_BREAKEVEN_RULE — for example entry, once a specific condition is met] to protect the position without closing it.
• Hard exit: Close the position immediately if [YOUR_EXIT_CONDITION — the thesis-breaking condition that overrides everything else, including an open profit].
• Output: Return HOLD, PARTIAL_CLOSE, ADJUST_SL, or CLOSE, with the reasoning behind whichever action it picked.

Notice what's missing from both templates: a hardcoded number sitting outside a bracket. That's deliberate. Every concrete threshold in the prompt you put into production should come from your own analysis, not from an example on a page like this one.

Common prompt mistakes

Most broken llm trading prompts fail in one of several predictable ways.

Vague criteria. "Buy when it looks bullish" is not an entry condition — it's a mood. A model asked to act on a mood hands back an answer that sounds confident and traces back to nothing you can check. If you can't picture writing the same sentence into a rule-based system's config file, it's too vague for an LLM prompt too.

No invalidation clause. An entry condition without a matching "skip if" is half a strategy. Without an explicit invalidation, the model has no instruction for the setup that looks almost right but isn't — and "almost right" is exactly where bad entries live.

Letting the model choose position size. Sizing is a risk decision, not an analysis decision, and it belongs to you — not to whatever number the model's reasoning happens to land on for that call. A prompt that says "size appropriately" instead of naming a fixed rule is asking the model to set your risk tolerance on your behalf.

Stuffing indicators without saying how to weigh them. Listing a pile of data points the model should "consider" isn't the same as telling it which one wins when they disagree — say, a reversal candle closing right into a level you flagged as resistance, while the moving average underneath it still points up. Without a stated priority, the model resolves that tie however it resolves it, and the resolution stays invisible to you unless the prompt forces it into the written thesis.

Testing a prompt before trusting it

A prompt that reads well on the page still needs proving against a market that doesn't know what you meant. Paper trading is where that proof happens: run the exact prompt you intend to go live with, on the schedule you plan to use, for weeks rather than hours. A handful of signals proves almost nothing; a strategy needs to sit through more than one kind of week before its behavior means anything.

Read every thesis the model returns, not merely whether the trade won or lost. The thesis is the only place you can see whether the model applied your invalidation clause correctly, weighed the indicators the way you intended, or quietly drifted toward its own reading of "bullish" instead of yours. A string of correct-looking trades built on reasoning that missed your point is a prompt that's about to fail somewhere you didn't test.

Where the reasoning consistently misses your intent, tighten the wording — narrow a threshold, spell out a case you'd left implicit, name the indicator that should win a tie. Each fix stays a short rewrite of a few lines, not a rebuild. See how to build an LLM trading strategy for the fuller walkthrough of that iteration loop, from the first draft through validation.

Where to run them

Inside KAI, a prompt isn't a one-time setup step buried in a settings page — it's a first-class object you can open, read, and edit per strategy, for both the entry prompt and the manage prompt described above. The default templates KAI ships are deliberately incomplete: fill-in-the-blank scaffolding with the same bracketed placeholders you just read, not a filled-in "recommended" strategy dressed up as a default. Activation is gated on you supplying your own criteria — there's no version of onboarding that skips that step.

Once a prompt is saved, point it at whichever engine you want reasoning over it — Claude, Gemini, DeepSeek, or MiniMax — without touching a word of the wording, and switch again later the same way. Every signal it produces still needs your sign-off before anything reaches an exchange, and running the whole thing in paper mode costs nothing while you're still finding out whether your wording says what you meant it to say.

FAQ

Can I just copy a winning prompt from someone else?

You can copy text, but you inherit a strategy you can't evaluate. When its decisions look wrong you won't know whether to trust or fix it. Write your own criteria, even simple ones.

How long should a trading prompt be?

Long enough to be unambiguous, short enough that every line earns its place. Most solid prompts are under a page; clarity beats length.

Do prompts work the same on every model?

No. Identical instructions can produce different calls once another engine is reading them. Treat any swap as a reason to rerun paper trades before you trust it with real positions.

Not investment advice. Crypto trading carries significant risk of loss. Past signal performance does not guarantee future results.