AIDA: An AI Outage Registry with Evidence from On-Chain MEV

summary

The gist

Generative AI has made trading software cheaper to write, but no systematic dataset has recorded when these services fail.

In short

The study created a registry of AI outages (AIDA) and compared them with recorded trading activities like MEV transactions. It found that as AI made writing trading software cheaper, developers focused on strategies needing only public code. Crucially, live bots continued trading during AI outages, showing execution is autonomous while development is stalled.

Key concepts

AI Incident and Disruption Archive (AIDA)
This is a registry tracking 5,868 deduplicated outage incidents from 30 providers between 2025 and 2026. It verifies foundation model outages against official status pages or postmortems to provide concrete data on when AI services fail.
Maximal Extractable Value (MEV) Transactions
These are verified transactions that represent the highest possible value extracted from blockchain activity. The study uses these to track specific trading strategies, such as atomic arbitrages and sandwich attacks, across Ethereum and Layer-2 chains.
Run-Time Dependence
This refers to how trading code behaves when AI services are unavailable. The research shows that while new code development stops during outages, existing deployed bots continue to execute trades autonomously on the blockchain.
Sandwich Attackers
These are traders who exploit transaction ordering by placing one transaction before and another after a target transaction to profit from the price movement. The study noted that these attackers declined as AI made building such specialized code more difficult.

Terminology used across episodes

This episode discusses

The paper

AIDA: An AI Outage Registry with Evidence from On-Chain MEV · Read on arXiv

Wenbin Wu

Cambridge Centre for Alternative Finance, Cambridge Judge Business School, University of Cambridge

Generative AI coding tools have lowered the cost of writing trading software, but no systematic dataset records when these services fail. We introduce the AI Incident and Disruption Archive (AIDA), a multi-vendor registry of 5,868 deduplicated outage incidents across 30 providers from 2025 to 2026, with foundation-model incidents verified against primary status-page or postmortem URLs. Pairing AIDA with 5,041,034 verified maximal extractable value (MEV) transactions by 8,516 Ethereum addresses, their contract creations, and a 22-month Base Layer-2 panel of 1,099,593,191 swaps and 29,120 private executors, we establish two findings. First, entry into MEV expanded where code and public state suffice, as active arbitrage addresses quadrupled from late 2024 to late 2026 and liquidators grew by a third, while sandwich attackers, who need private order flow and builder access, declined. Execution nonetheless remained concentrated, with the top fifty addresses executing two thirds of verified trades. Second, AI outages stall new trading code while deployed bots keep trading. On Ethereum, addresses releasing a private executor fall to 0.67 on the day of an eight-hour disruption (0.68 for executor creations during OpenAI outage hours) and to 0.66 at lag two before rebounding on day three; on Base, operator top-level creations fall to 0.76 during OpenAI hours and executor-deploying operators to 0.88 at lag two. Non-trading creations, automated factory clones, and live arbitrage and sandwich execution across both chains remain unchanged. Cheaper code thus lowers the barrier to building MEV contracts, while private order flow, latency and capital still determine who wins execution.

Transcript

Introduction to the show: ident: Quantitative Finance. The day in quantitative finance: models of markets, risk and prices.

Ruth: We're looking at the paper: "AIDA: An AI Outage Registry with Evidence from On-Chain MEV".

Warren: Here's the gist of the paper. Generative AI has made trading software cheaper to write, but no systematic dataset has recorded when these services fail.

Ruth: First, entry into MEV expanded where code and public state suffice, as active arbitrage addresses quadrupled from late 2024 to late 2026 and liquidators grew by a third, while sandwich attackers, who need private order flow and builder access, declined.

Warren: Second, AI outages stall new trading code while deployed bots keep trading across both chains.

Ruth: Data Construction and Identification The study introduces the AI Incident and Disruption Archive (AIDA), a multi-vendor registry of 5,868 deduplicated outage incidents across 30 providers from 2025 to 2026, with foundation-model incidents verified against primary status-page or postmortem URLs.

Paper summary: Ruth: So we’re talking about this paper today from arXiv, titled "AIDA: An AI Outage Registry with Evidence from On-Chain MEV". It looks at how generative AI is changing the landscape for writing trading software and what happens when that technology goes down.

Warren: Yeah, so the core idea is that even though writing trading code has gotten cheaper because of these AI tools, nobody has a systematic dataset to tell us when those services actually fail. That’s what this paper claims they’ve created.

Iris: It sets up this thing called AIDA, which is a multi-vendor registry of five thousand eight hundred sixty-eight deduplicated outage incidents across thirty providers from two thousand twenty-five to two thousand twenty-six and they verified the foundation model incidents against status pages or postmortems > <ref:2611.01656#pg1,a multi-vendor registry of 5,868 deduplicated outage incidents across 30>

Ruth: And they paired that with about five million verified maximal extractable value transactions by eight thousand five hundred sixteen Ethereum addresses, contract creations, and a two-two month panel on Base Layer two with over one billion swaps >

Warren: They’re looking at atomic arbitrages, sandwich attacks, and lending liquidations from primary rules across the whole Ethereum span over five million verified strategy transactions by eight thousand five hundred sixteen addresses > <ref:2611.01656#pg1>

Iris: The main point is they establish two findings based on this data >

Ruth: Okay, so what are those two things they found when you look at this AIDA registry and that transaction data?

Warren: First, entry into maximal extractable value expanded exactly where writing code and public state were enough, which makes sense since the cheaper software lowers the barrier to entry >

Iris: They found that active arbitrage addresses grew four times between late two thousand twenty-four and late two thousand twenty-six and liquidators grew by a third, while sandwich attackers actually shrank > <ref:2611.01656#pg1,late 2026, and liquidators grew by a third, while sandwich attackers>

Ruth: So it seems like AI is making it easier for people to build things that rely on code and public state, but the more complex stuff requiring private order flow isn't as much affected right now >

Warren: Right. And second, they found that AI outages stall the creation of new trading code while bots keep trading across both chains >

Iris: On Ethereum, addresses releasing a new executor contract dropped sharply on the day of a multi-hour disruption and then rebounded within days, which suggests a multi-day development pipeline >

Ruth: So what this means for someone listening right now is that developers probably use AI for the off-chain engineering work, but when those AI services stop working, the live execution bots just keep trading without missing a beat >

Warren: It points to how they rely on these coding services for building things, but the actual live trades run autonomously when the systems fail >

Iris: The study notes that private order flow and latency still determine who wins execution even though cheaper code is making it easier to build those contracts >

Ruth: So the implication here is that AI helps with off-chain engineering while the on-chain trading part keeps running on its own, but you still need good execution speed and capital to win in the actual market >

Warren: Exactly. The paper's title, "AIDA: An AI Outage Registry with Evidence from On-Chain MEV", frames it as a way to track this whole relationship between AI coding tools and live on-chain trading >

Iris: It really tries to resolve an identification problem that price and volume studies struggle with because aggregate data alone doesn't tell you if a disruption is affecting the building of software or the execution of live trades >

Ruth: So what do we get from this paper in terms of what it changes for us as market observers?

Warren: It gives us evidence that AI coding tools are helping MEV developers with off-chain engineering, but those developers still depend on live execution running autonomously when the AI services go offline >

Iris: The study shows that the entry pattern confirms this: the expanding base of MEV developers enters exactly where code and public state suffice because of cheaper software >

Ruth: It seems like it’s a two-part story, then: AI helps build things faster, but the live execution itself is more resilient than we thought as long as those bots are deployed >

Warren: That resilience is tied to how long the development pipeline takes, which the outage data shows can be multi-day when services are down >

Iris: It’s important to remember that the researchers are trying to separate whether a disruption affects building trading software or live trades, and their findings show they're complementary >

Ruth: So if you only listen to this paper, the big picture is that we need to look at both the development side and the execution side when we analyze how AI impacts MEV >

Conclusion: Ruth: So we’re wrapping up this look at AIDA, which is this AI Outage Registry with Evidence from On-Chain MEV paper by those researchers on arXiv today.

Warren: Basically, they built a way to track when AI coding services actually fail while you're trading on the blockchain.

Iris: They used this archive of outage incidents and paired it with massive amounts of data, like millions of swaps and strategy transactions across Ethereum and Base Layer two.

Ruth: The authors are trying to untangle whether these outages stop new software from being built or if the bots that are already running can keep trading without issue.

Warren: It looks like they found that AI helps developers write off-chain code, but when those services drop, the live execution bots just keep running across both chains.

Iris: The data shows a sharp drop in new executor contracts on Ethereum right after a disruption, which suggests developers rely on those AI tools for engineering but the live trading part is pretty resilient.

Ruth: So what this means for us is that we need to look at both the development side and the execution side when we analyze how AI impacts MEV.

Warren: It means that even if you have cheap code, who wins execution still comes down to who has fast access and enough capital because of latency and order flow.

Iris: And this paper shows how important it is to separate the building part from the live trading part when you’re trying to understand this whole system.

More episodes

← Home