Trading robots and automated systems

What the program actually does 

An automated system is software running inside a trading terminal with permission to place, modify and close orders on an account. The names differ by platform and by seller: expert advisor, robot, bot, algorithm, strategy, script. The object underneath the name is the same in every case, a list of conditional instructions executed over and over on data the terminal is already receiving. The platforms in use at YAL are MetaTrader 5, and both support programs of this kind, as most retail platforms do.

An instruction list has three kinds of line in it, and only the third leaves the machine. There are conditions to evaluate, such as whether a shorter moving average has crossed a longer one on the bar that just closed. There is state to check, such as whether a position is already open or how much free margin the account is carrying. And there is an action to submit, an order of a stated size with whatever attached instructions the writer specified. Everything the program knows is a number the platform gave it. It has no access to why a price moved, no knowledge that an announcement is due unless a line was written to look one up, and no capacity to notice that the market stopped behaving the way it did when the conditions were chosen.

That is the whole of what automation changes. A decision a person would take in the moment is written down in advance and then executed without further consideration. Consistency and speed are what the machine contributes: it does not hesitate, it does not miss a condition it was told to watch, and it does not depart from the list. It also does not depart from the list on the occasions when departing would have been the sensible thing, because sensible is not a category available to it.

The rules are the product 

When a rule set is written, the rules are the thing that exists and they are visible to whoever wrote them. When one is bought, what changes hands is ordinarily a compiled file, a document describing how the rules would have behaved across some stretch of past prices, and a price. The rules themselves are usually withheld, and the reason given is commercially real: disclosure would let a buyer reproduce them without paying. It also removes the only part of the product that could have been examined.

A simulation over historical data is an arithmetic exercise rather than a record. It takes a rule set, walks it across a stored series of prices, and reports what the rules would have instructed at each point. No order reaches a market, no money moves, and nothing in the process is observed by anyone other than the party running it. Its output depends entirely on choices that party made: which instrument, which stretch of history, what cost per trade was assumed, whether an order was assumed to fill at the price on the screen, and whether the parameters were fixed before the walk or chosen after it. The last of those does the most work, and it has a name.

Overfitting is what happens when a rule set is adjusted until it describes one particular stretch of history closely. Every rule set has parameters, the lengths, thresholds and distances that turn a general idea into an exact instruction, and each can be varied. A search across the combinations will always find one that fits the data it searched, because a large enough search finds a fit in any series, including a series of random numbers with no market in it at all. What the winning combination certainly describes is the search. Whether it describes anything else is the open question, and the document reporting it cannot answer that.

What a simulation assumes away 

The second gap between a simulation and an account is cost, and it is arithmetic rather than opinion. A walk across stored prices has to assume something about what each round trip costs, and whatever it assumes is multiplied by however many round trips the rules generate. Frequency is what multiplies the assumption fastest, and frequently trading rule sets are common, because frequency is also what makes a short stretch of history long enough to summarise.

Fills are the other omission, and they compound the first. A simulation reads a stored price and books the trade there. A live order goes into a market that is moving, at a moment when the price on the screen may no longer be the price available, and the gap between the two is widest in exactly the fast conditions a frequently trading rule set fires in. Practitioners treat that gap as a major source of divergence between a document and an account, and disagree about how much of it can be modelled in advance.

What breaks when nobody is watching 

A program that runs while nobody is at the machine carries a set of failures that a person clicking manually does not, and they are mechanical rather than strategic. The rules can be entirely as intended and every one of these can still occur.

• The program only runs while the terminal it lives in is running and connected. A closed laptop, a dropped connection or an update that restarts the machine stops the program, and any position it opened stays open regardless.
• After a break in connectivity, the program's record of what is open and the account's record can disagree, so an instruction can be submitted twice or a close can be missed entirely.
• A gap over a weekend or through a scheduled announcement moves price past the level at which an attached instruction was set, and the position closes at whatever is available rather than at the level specified.
• If free margin fails its requirement overnight, positions are closed by the counterparty on the counterparty's terms and in the counterparty's order, which is not the order the rules would have chosen.
• A rule set written for one instrument on one timeframe evaluates identically on any chart it is attached to. The conditions still compute, and they no longer mean what they meant.
• A size, a threshold or a decimal point typed wrong is executed exactly as typed, at whatever frequency the rules fire, until somebody notices.
• The program has no access to any fact about the world that has not been reduced to a number in its feed. A halted instrument, an unusual quote and an ordinary quiet morning are indistinguishable to it.

Who is selling, and what a licence covers here 

A vendor of trading software is ordinarily not a regulated party in any of this. An authorisation covers a firm that deals, holds client money and faces a client on a contract. Writing a program and selling it as a file is, in most regimes, not an activity requiring a permission at all, so the register check taught earlier in this module has nothing to find, and an absent entry is not a finding either way. What follows is narrower and worth stating plainly: the protections that attach to a regulated relationship attach to the broker relationship, and they do not travel to the sale of a file by somebody else.

One variation appears often enough beside the sale to be worth marking. Instead of selling the file, a seller offers to run the program on the buyer's own account, which requires access to that account rather than a download. That is a different arrangement with a different set of questions, and it is the subject of the next lesson.

Writing a rule set and buying one 

The difference between the two is not skill and it is not sophistication. It is visibility. A rule set written by hand comes with its assumptions attached: which conditions were chosen and which were discarded, how many parameter combinations were tried and over what stretch, what cost was assumed, what the program does when a connection drops. A bought rule set comes with a file and a claim, and there is no route from the second to the first. The two can behave identically on a chart and remain entirely different products in every respect that could be inspected.

The intermediate cases follow the same logic. A program distributed with its source readable is inspectable whatever else is true of it. A description of the rules in plain language is inspectable only to the extent that it matches the file, which is itself unverifiable when the file is compiled. A demo account, covered in an earlier module, runs against the same platform mechanics without money at stake, so it is where the plumbing of a program becomes observable: whether it fires when the conditions are met, what it does across a rollover, how it recovers from a restart. What a demo cannot show is cost and fills on a live account, which is the pair the document was already silent about.

Where practitioners disagree 

The first argument concerns what automation actually removes. One tradition holds that a written rule executed by a machine removes the moment of hesitation and the improvisation that follows it, because the machine has no opinion about the last loss. The other answers that discretion is relocated rather than removed, to the person who decides when the program is switched on, switched off, restarted with different parameters or abandoned. A rule set turned off after a difficult run and turned on again after a calm one is being traded discretionarily with extra steps. Both descriptions are accurate about different parts of the same arrangement, which is why the argument persists.

The second concerns whether holding data back settles the fitting problem. The convention is to search parameters on one stretch of history and then check the chosen combination against a stretch that was withheld. Critics point out that once a rule set has been revised in the light of what the withheld stretch showed, that stretch has been searched too, and in practice most rule sets are revised. There is also no test that separates a rule set that stopped fitting because the market changed from one that never fitted anything except its own search.

The third concerns disclosure. Sellers argue that rules published widely enough stop working, because a condition many participants act on at once changes the thing it is watching. Others answer that most retail rule sets are long standing conventions with different numbers in them, described in public for decades, and that non disclosure guards the sale rather than the rules. Neither side disputes the part that matters to a buyer: an undisclosed file cannot be checked by the person paying for it.