After the Knight Capital incident, I decided to read into the new Rule 107C that NYSE pushed-out August 1st for a one-year pilot. From what I've read, Knight claims that new code rolled out for this rule was the cause of Knight's system going haywire.

Today two ETF bond funds, SPDR BofA Merrill Lynch Emerging Markets Corporate Bond ETF and SPDR Nuveen S&P VRDO Municipal Bond ETF were halted due to erratic trading. There's not much detail about this right now, so whether this could be linked is purely speculative, probably just a fat finger trade with terrible timing.

I'm no expert on the rules of the exchange, but it seems to me that the only relevant "change" would be the following, taken from the NYSE site.

A "Retail Price Improvement Order" or "RPI" consists of non-displayed interest in Exchange-traded securities that is priced better than the best protected bid ("PBB") or best protected offer ("PBO"), by at least $0.001 and that is identified as such. Exchange systems will monitor whether RPI buy or sell interest, adjusted by any offset and subject to the ceiling or floor price, is eligible to interact with incoming Retail Orders. An RPI remains non-displayed in its entirety. An RLP shall only enter and RPI for securities to which it is assigned as RLP. Member organizations other than RLPs are permitted, but not required, to submit RPIs. An RPI may be an odd lot, round lot, or PRL. (Rule 107C(a)(4))

It follows that the only time a RPI is executed is if the market maker can beat the PBB or PBO by at least $.001. I just don't see how this change could cause the erratic trading that occurred. My understanding is Knight's loss was caused by having to unwind a massive position they accidentally took on, not by market making activities. Any thoughts on this? Am I missing something obvious here (besides that bugs can have lots of unintended consequences)?

  • $\begingroup$ Posting as a comment because this is just speculation, but my understanding is that the position was built up in the course of executing trades for clients. Since many of them are retail clients, and no doubt they received many client orders in the fateful half hour, those orders would have had to look for RPI orders. Also, they may have posted RPI orders, also on behalf of clients. Perhaps the bug in their system failed to recognize whether an order was executed, and so the systems continued mistakenly placing new orders. $\endgroup$ Commented Aug 7, 2012 at 18:05
  • $\begingroup$ In short, there is no reason to doubt the veracity of their claim. In fact, there's really no plausible alternative explanation. $\endgroup$ Commented Aug 7, 2012 at 18:06
  • $\begingroup$ @TalFishman : speculation is unavoidable here so I guess you could have posted that as an answer... $\endgroup$
    – SRKX
    Commented Aug 7, 2012 at 20:44
  • 5
    $\begingroup$ Here's a theory: nanex.net/aqck2/3525.html $\endgroup$
    – user508
    Commented Aug 8, 2012 at 1:16
  • 1
    $\begingroup$ @user508 You should post that as an answer, with an excerpt in case they take it down. $\endgroup$ Commented Aug 8, 2012 at 16:38

2 Answers 2


The best explanation/theory that I have heard about Knight's erratic trading was put forth by Nanex. I have pasted their summary of findings below.

We believe Knight accidentally released the test software they used to verify that their new market making software functioned properly, into NYSE's live system.

In the safety of Knight's test laboratory, this test software (we'll call it, the Tester) sends patterns of buy and sell orders to its new Retail Liquidity Provider (RLP) Market Making software, and the resulting mock executions are recorded. This is how they could ensure their new market making software worked properly before deploying to the NYSE live system.

When the time comes to deploy the new market making software, which is likely handled by a different group, the Tester is accidentally included in the release package and started on NYSE's live system. On the morning of August 1st, the Tester is ready to do its job: test market making software. Except this time it's no longer in the lab, it's running on NYSE's live system. And it's about to test any market making software running, not just Knights. With real orders and real dollars. And it won't tell anyone about it, because that's not its function.

For stocks where Knight is the only one running market making software as a RLP, and the Tester is the only algo trading that's crossing the bid/ask spread, then we'll see consistent buy and sell patterns of trade executions, all marked regular, and all from the NYSE, and all occurring at prices just above the bid or just below the ask. Examples include EXC and NOK and you can see these patterns in charts here. The Tester is functioning just as it did in the lab, and Knight's market making software is intercepting these orders and executing them. Knight won't lose any money on these trades, but they will be generating a lot of wash sales.

For stocks where Knight is not the only market maker, or when there are other algos actively trading (and crossing the bid/ask spread), then some, or all of the orders sent by the Tester will be executed by someone other than Knight, and Knight will now have a position in the stock. Meaning it could be making or losing money. The patterns generated for these stocks will depend greatly on the activity of the other players.

Because the Tester indiscriminately buys at the ask and sells at the bid, and because the bid/ask spreads are very wide during the open, we now understand why many stocks moved violently at that time. The Tester was simply hitting the bid or offer, and the side it hit first, determined whether the stock opened sharply up or down.

Since the Tester doesn't think it's dealing with real dollars, it doesn't have to keep track of its net position. It's job is to send buy and sell orders in test pattern waves. This explains why Knight didn't know right away that it was losing a lot of money. They didn't even know the Tester was running. When they realized they had a problem, the first likely suspect would be the new market making software. We think the two periods of time when there was a sudden drop in trading (9:48 and 9:52) are when they restarted the system. Once it came back, the Tester, being part of the package, fired up too and proceeded to continue testing. Finally, just moments before an economic news release at 10am, someone found and killed the Tester.

We can fully appreciate the nightmare their team must have experienced that morning.


Update via Bloomberg

Knight Capital Group Inc. (KCG)’s $440 million trading loss stemmed from an old set of computer software that was inadvertently reactivated when a new program was installed, according to two people briefed on the matter.

Once triggered on Aug. 1, the dormant system started multiplying stock trades by one thousand, according to the people, who spoke anonymously because the firm hasn’t commented publicly on what caused the error. Knight’s staff looked through eight sets of software before determining what happened, the people said.

  • $\begingroup$ Don't believe everything you read on Bloomberg; the data is not consistent with that story: nanex.net/aqck2/4008.html $\endgroup$
    – user508
    Commented Dec 10, 2012 at 19:05
  • $\begingroup$ @use508 I have to agree - marking the answer with the most evidence as correct. $\endgroup$
    – jeff m
    Commented Dec 11, 2012 at 15:15

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.