Advanced Bet Angel automation means moving past single-trigger bets to chained rule sequences in Guardian: rules that fire on market conditions, store values for later rules to read, use time-to-off triggers, and include automatic stop-loss and green-up logic. The skill isn't writing one clever rule — it's sequencing several so a whole trade executes, manages and exits itself.
This page contains affiliate links — if you open an account through them we may earn a commission at no cost to you. It never changes our verdict.
- Why go beyond basic triggers
- The anatomy of an advanced Guardian rule
- Chaining rules: the real unlock
- Market conditions and stored values
- Time-based and time-to-off triggers
- From the desk: an automated pre-off rule set
- Stop-loss and green-up automation
- The advanced-automation mistakes that cost money
- The verdict
This is a sub of our software automation pillar, and it's written for people who've already used Bet Angel Guardian to place a simple automated bet and want to know what the tool can really do. The leap from "one trigger" to "a self-running trade" is where automation stops being a gimmick and starts being useful — and it's almost entirely about how you sequence rules, not how clever any single rule is.
A quick honesty note up front: advanced automation does not turn a losing strategy into a winning one. It executes your edge faster and more consistently than you can by hand, and it removes the emotional fumbling that ruins manual trades — but if the underlying strategy loses, automating it just loses faster. Everything below assumes you've got a manual edge you're trying to systematise, which is exactly the right reason to automate.
Why go beyond basic triggers
You go beyond basic triggers when a single "if price hits X, place bet Y" rule can't express your actual strategy — which is almost immediately. A real trade has an entry, a management phase and an exit, plus conditions about when it should and shouldn't fire. A single trigger handles only the entry, leaving you to babysit the rest manually, which defeats the point of automating at all.
Advanced automation lets you encode the whole trade: enter only when the market is liquid enough and within a time window, scale in or out, move to a green-up once a target is hit, and bail to a stop-loss if it goes wrong — all without you touching the mouse. The payoff is consistency (the rule does exactly the same thing every time, with no hesitation), speed (it reacts in the fraction of a second you can't), and coverage (it can run across several markets at once while you watch one). Those three together are why a trader with a defined, repeatable edge eventually automates it.
The anatomy of an advanced Guardian rule
A Guardian rule has three parts, and advanced automation lives in how rich you make each. The conditions decide whether the rule is allowed to fire — and a good rule has several, not one: a price condition, plus a liquidity condition (only fire if there's enough matched or available), plus a time condition (only inside a window), plus often a state condition (only if a previous rule has run). The action is what it does — place a bet, cancel a bet, set a stored value, green up. The bet settings govern how — stake, the price to ask for, persistence, whether it's a back or lay.
Beginners write rules with one condition and a fixed action. Advanced rules stack conditions so the rule only fires in exactly the situation you intend, which is what stops automation from doing something stupid in a market state you didn't anticipate. The discipline is to think about every market condition in which you do not want the rule to fire, and add a guard condition for each.
Chaining rules: the real unlock
The single biggest step up in Bet Angel automation is chaining rules so that one rule's firing enables the next — turning a list of independent triggers into a sequence that walks a trade through entry, management and exit. You chain rules using rule groups and stored values: one rule fires and sets a flag or records a price; later rules check that flag before they're allowed to act.
A simple chain for a pre-off trade looks like this: Rule 1 enters the position when the price and time conditions are met, and stores the matched price. Rule 2 watches for the price to move in your favour by a set number of ticks and greens up. Rule 3 watches for the price to move against you by your stop distance and exits at a loss. Rules 2 and 3 both check that Rule 1 has actually fired (via a stored flag), so they can't act on a position that doesn't exist. That three-rule structure — enter, green-up target, stop-loss — is the backbone of almost every automated trade I run, and once you can build it cleanly you can build anything. It's the automation equivalent of the manual scalp plus green-up plus stop you'd do by hand.
Once you trust the basic three-rule chain, you extend it the same way: add a fourth rule that scales in a second slice of stake only if the first entry is in profit, or a fifth that tightens the stop after the green-up target has been touched. Each addition is just another rule reading a stored value the earlier rules wrote, so the chain grows without becoming unmanageable as long as every new rule answers one question — what state must the trade already be in for this to fire? Build them one at a time, watch each fire correctly in a live market before adding the next, and you end up with a sequence you actually understand rather than a black box you're nervous to leave running. That incremental, test-as-you-go habit is the single biggest practical difference between traders whose automation makes money and traders whose automation quietly bleeds it.
Market conditions and stored values
Stored values are what give Guardian a memory, and they're the feature that separates basic from advanced automation. A stored value lets one rule write a number — the price you entered at, the time you fired, a counter — that later rules can read and compare against. Without them, every rule is stateless and can only react to the current market; with them, your rules can reference what already happened in the trade.
The classic use is storing your entry price so a green-up rule can calculate "current price is N ticks better than stored entry" rather than you hard-coding a fixed exit price that's only right for one market. Another is a fired-flag so management rules know the trade is live. Another is a counter that limits how many times a rule can fire, which stops a misbehaving rule from machine-gunning bets. Combine stored values with market-condition checks — available-to-back size, total matched, last-traded price, time to the off — and you can express genuinely conditional logic: only enter if matched volume exceeds a threshold (so you're not trading a dead market), only green up if there's liquidity to get out, never fire outside your time window. This conditional richness is the difference between automation that helps and automation that does something idiotic the first time the market behaves unexpectedly. The same principle underpins fully coded bots in our trading algorithms guide.
Time-based and time-to-off triggers
Time is one of the most powerful and underused conditions in Guardian, because so many exchange edges are time-specific. The time-to-off trigger — fire only when the market is, say, between 8 and 2 minutes from the scheduled off — is essential for racing automation, because the pre-off market behaves completely differently early versus late, as covered in reading pre-race trends. Restricting your entry rule to the late window keeps your automation out of the thin, noisy early market where it would just churn commission.
You can also use absolute time conditions (only run during certain hours), and time-since-event logic via stored timestamps (green up if the trade hasn't hit target within X seconds). Time conditions are how you stop automation running when it shouldn't and how you build exits that don't depend solely on price. For pre-off racing in particular, a tight time-to-off window is usually the first guard condition I add to any entry rule.
The setup: a three-rule Guardian chain on a liquid all-weather handicap market, designed to automate a small pre-off back-to-lay scalp on the favourite so I could run it across two races at once.
Rule 1 (entry): conditions — time to off between 6:00 and 3:00, available-to-back at least £500, last traded price between 2.50 and 3.50. Action — back £100 at the current best back price, and store the matched price to a value called entry.
Rule 2 (green-up): condition — the favourite's price is two ticks shorter than entry and entry is set. Action — lay to green up across the book. On this race it fired when the price moved from a stored 3.00 to 2.94, laying £102 to lock about £6 — roughly £5.70 after 5% commission.
Rule 3 (stop-loss): condition — price is three ticks longer than entry. Action — lay to close at a loss. It didn't fire this time, but on the second race running in parallel it did, capping a drift at about £9 down instead of letting it run.
The lesson: the edge was tiny and the win was small, but the point is the chain ran both markets unattended — entered on conditions, took the green-up when it came, and stopped the loser automatically. Net across the two races was a small profit, and crucially I never touched the mouse. Automating a small, defined edge is about consistency and coverage, not about any single rule being clever.
Stop-loss and green-up automation
The most valuable automation you can build isn't the entry — it's the exit, because exits are where manual traders fail emotionally. An automated stop-loss fires the moment your loss condition is met, with no hesitation, no "I'll give it one more tick," no hope. That removal of emotion from the exit is, for many traders, worth more than any entry edge, because the discipline to cut losers is the hardest thing to do by hand.
Build the stop and the green-up as separate rules that both reference your stored entry price, and make sure exactly one can fire — once either the target or the stop is hit, the position closes and a flag prevents re-entry. The common failure is rules that can re-fire and re-open a position you just closed; guard against it with a fired-flag stored value. A clean enter/target/stop trio that references stored values and includes a fired-flag is robust, readable and the foundation of trustworthy automation. If you can't yet build a stop-loss that you'd trust to run unattended, you're not ready to leave automation running unattended — paper-test it first, as in paper trading.
The advanced-automation mistakes that cost money
Advanced automation has its own catalogue of expensive mistakes, distinct from manual trading. The first is leaving it unattended too soon — automation does exactly what you told it, including the bug you didn't notice, and an unsupervised flawed rule can fire repeatedly before you catch it. I watch any new rule set live for several sessions before trusting it alone. The second is no liquidity guard: a rule that enters regardless of available money will get matched at terrible prices or stuck unable to exit in a thin market; always condition on available size. The third is missing the stop: people automate the exciting entry and the satisfying green-up but skip the boring stop-loss, then a single drift wipes out a week of small wins.
The fourth, and most insidious, is over-complication — building a sprawling web of interdependent rules you can no longer reason about, so when it misbehaves you can't tell why. Keep rule sets small and readable; a trade you can't debug is a trade you shouldn't run. And the fifth is forgetting that automation amplifies whatever it's given: a profitable edge automated is profitable faster, but a losing edge automated is a faster way to lose. Test the strategy manually until you trust the edge, then automate the execution — never the other way round. The pillar's deep dive and our algorithms guide both stress the same order: edge first, automation second.
The verdict
Advanced Bet Angel automation is about sequencing, not cleverness. The unlock is chaining rules — enter, green-up target, stop-loss — that share state through stored values, guarded by market-condition and time-to-off checks so they only ever fire when you intend. Store your entry price so exits are relative not hard-coded, always add a liquidity guard, never skip the stop-loss, and keep the whole rule set small enough to debug. Automation gives you consistency, speed and coverage, but it amplifies whatever edge you feed it, so prove the strategy by hand first. Watch every new rule set live before trusting it unattended, and paper-test exits you'd stake real money on. Go deeper with the software automation pillar, the full Bet Angel review, and our guide to building trading algorithms.
Automation executes faithfully — including your mistakes. A flawed rule can fire repeatedly and lose fast before you notice. Most Betfair traders lose money overall; automating a losing strategy just loses quicker, and past results don't guarantee future returns. Always include a stop-loss, watch new rules live before leaving them unattended, and never stake more than you can afford to lose. 18+ only; help at BeGambleAware.org.
Build the enter-target-stop chain and let a defined edge run itself.
Automation Pillar Try Bet Angel →FAQ
What makes Bet Angel automation "advanced" rather than basic?
Basic automation is a single trigger that places one bet. Advanced automation chains several Guardian rules into a sequence — entry, green-up target and stop-loss — that share state through stored values and are guarded by market-condition and time-to-off checks, so a whole trade enters, manages and exits itself without you touching the mouse.
What are stored values in Guardian and why do they matter?
Stored values give Guardian a memory: one rule writes a number (like your entry price or a fired-flag) that later rules read and compare against. They let exits be relative to your actual entry rather than hard-coded, let management rules know a position is live, and let you limit how often a rule fires. They're the feature that separates basic from advanced automation.
Does automating a strategy make it more profitable?
No. Automation executes your edge faster and more consistently and removes emotional fumbling, but it doesn't create an edge. A losing strategy automated just loses faster. Always prove a strategy manually until you trust the edge, then automate the execution — never automate a strategy you haven't tested by hand.
Should I leave Bet Angel automation running unattended?
Not until you've watched it run live for several sessions. Automation does exactly what you told it, including any bug, and an unsupervised flawed rule can fire repeatedly before you catch it. Always include a stop-loss and a liquidity guard, keep rule sets small enough to debug, and paper-test exits before trusting real money to them unattended.
Related reading
Go deeper with the software automation pillar, read the full Bet Angel review, learn fully-coded automation in building trading algorithms, and practise risk-free first with paper trading. Apply the underlying edges via scalping and greening up.