Classification of Algorithmic Execution Systems
Algorithmic trading has been a great tool for performing things like buying a large listing of a portfolio trade, and pair trades, where you may wish to buy Stock A and sell Stock B when the A/B price ratio gets low enough. The rapid succession of trades in a rules-based strategy like this allows traders to take advantage of dips that may not last.
One class of strategies involves how a large block trade can be divided up into pieces, called __scheduled algorithms__. If you had a hundred small trades to place throughout the day, how might you design your algorithm to get them executed?
That's fine.
This sounds like a __volume-weighted average price (VWAP)__ strategy, where the goal is to get the VWAP or better for that day.
The other two ideas are used as well. Selling at even intervals throughout the day is a __time-weighted average price (TWAP)__ strategy, and submitting orders as a proportion of market volume is a __percentage-of-volume__ strategy.
That's fine.
This sounds like a __time-weighted average price (TWAP)__ strategy, where the goal is to sell at even intervals throughout the day.
The other two ideas are used as well. The goal of a __volume-weighted average price (VWAP)__ strategy is to get the VWAP or better for that day, and submitting orders as a proportion of market volume is a __percentage-of-volume__ strategy.
That's fine.
This sounds like a __percentage-of-volume__ strategy, where the goal is to submit orders as a proportion of market volume.
The other two ideas are used as well. The goal of a __volume-weighted average price (VWAP)__ strategy is to get the VWAP or better for that day, and selling at even intervals throughout the day is a __time-weighted average price (TWAP)__ strategy.
Which one sounds like it would be the most difficult to achieve?
Not really.
The computer would just submit a fraction of the trade every few minutes until it was done.
Absolutely.
The TWAP and percentage of volume just looks at either the clock or the trading volume to decide when to place the next trade. Simple. But trying to get or beat the VWAP is far from guaranteed. You would be using forecasted volume based on historical data, which could work.
Not really.
The computer would just submit orders that are about 10% or so of market volume until the order was complete.
But what unexpected thing might happen late in the day to ruin your plan of a VWAP strategy with a large block purchase?
Exactly.
You might have your order filled when suddenly volume picks up on some bad news, and price declines. The VWAP drops, and you're left with a relatively higher price.
No, actually.
If that happens, the VWAP rises, and you'll probably end up with a better price in relation.
Probably not.
That shouldn't be much of threat.
What size order would benefit the most from a liquidity-seeking algorithm?
Yes.
If you're trying to match a massive sell order with buy orders, you don't want to cause the price to fall. Liquidity seeking would be of utmost importance in this case.
No, that isn't it.
There wouldn't be any advantage to using liquidity-seeking algorithms for small orders.
Not really.
Consider the potential price impact of some order sizes.
Still other categories of execution algorithms include __arrival price algorithms__ designed to get close to the market price right when the order is received, and __dark aggregator algorithms__ that execute orders in less transparent markets and dark pools. Which of these sounds like a great tool to use if you want to be more secretive about your limit price?
No, definitely the dark aggregator pool algorithm here.
Of course.
Arrival price algorithms focus on the market price, trying to lock in that price for the trade, so this is useful when a manager fears that the price will move suddenly in the wrong direction. But dark pool aggregators work away from these transparent, "lit" markets in places where you don't have to disclose your limit prices and worry about information leakage.
Finally, __smart order routers (SORs)__ are constantly monitoring real-time data in many markets in order to determine where a trade can be placed for highest probability of executing a limit order. These are used primarily for small orders that won't have a large price impact as a market order, or won't leak too much information as a limit order.
That's smart!
To summarize:
[[summary]]
Another category of execution algorithms is __liquidity-seeking algorithms__, or "opportunistic algorithms," where trades occur over time while the computer watches for any opportunities like extra low-cost liquidity.
By trying for the best price
By selling at even intervals throughout the day
By submitting more orders when volume is heavier
TWAP
VWAP
Percentage of volume
Low volume
A heavy price increase
A heavy price decrease
Large orders
Small orders
Equal benefit for all orders
Arrival price algorithm
Dark aggregator pool algorithm
Continue
