Ethereum Glamsterdam Fork: How AI Agents Found Risks
Learn why Ethereum paused Glamsterdam’s testnet, how researchers used AI agents to find contract risks, and what the case means for protocol security.

How AI Agents Helped Ethereum Find Risks in Glamsterdam
Ethereum's Glamsterdam upgrade hit a pause after researchers found that proposed gas changes could break assumptions already baked into DeFi contracts. The issue surfaced late enough that the second and final testnet rehearsal was cancelled, forcing protocol teams to dig into the wider effects before trying again.
One part of the response stood out: researchers used AI agents to scan contracts, then set up a shared message board so the agents could coordinate. The work did help surface potential problems, but it doesn't mean autonomous bots can "certify" an upgrade as safe. The real story is how this kind of tooling plugs into the rest of the review process - and what the delay suggests about testing changes that touch thousands of contracts.
This article walks through what happened during Glamsterdam, why gas behavior can cause downstream risk, how the agent collaboration worked, and what protocol teams can apply next time. It also compares this with a separate Bitcoin challenge involving a PHP vulnerability, where finding a flaw and exploiting it reliably are not the same thing.
What happened to the Glamsterdam testnet?
Ethereum's second and final testnet rehearsal for the Glamsterdam hard fork was cancelled after security firm ChainSecurity identified vulnerabilities tied to EIP-8037 and EIP-8038. Those proposals concern gas scaling. Researchers said the resulting behavior could affect at least 13 DeFi contracts that depend on how gas works today.
The immediate concern was simpler than it might sound: a contract's behavior can change when a call runs out of gas. Smart contracts often call other contracts, and those interactions can hinge on predictable execution - and predictable failure - behavior. So even if the application code isn't modified for the fork, a protocol-level change can still ripple into how it runs. The contracts might compile cleanly and pass "normal" tests, yet behave differently under a specific call sequence or a tight gas limit.
None of this is a claim that the listed contracts were exploited, or that Glamsterdam was deployed with a known vulnerability. The risk was identified during testing, and the rehearsal was cancelled so developers could investigate before proceeding. A testnet is a checkpoint, not a guarantee that every interaction pattern has already been exercised.
Derek Chiang of Ethlabs described the findings as arriving late in the process, which left researchers and developers dealing with the consequences under time pressure. The Hoodi rehearsal is not expected to be rescheduled until the second-order effects have been examined - meaning the team needs to understand not only what the proposals change, but what changes as a result.
A cancelled rehearsal is disruptive. It can break coordination, force application teams to retest, and push protocol developers to revisit their upgrade assumptions. But rushing ahead just to keep a schedule usually just moves uncertainty onto users and applications. For a widely used settlement layer, it's often cheaper to manage the cost of a careful delay than to discover an incompatibility after activation.
Why did the gas changes create a contract risk?
Gas is Ethereum's accounting mechanism for computation. A transaction pays for the work it asks the network to do, and gas limits help prevent unbounded computation. When gas costs or scaling change, it can affect whether a call completes, where execution stops, and how a contract behaves when a call fails.
That matters because many DeFi systems are layered. A single user action might involve a user-facing contract, a lending or trading protocol, a token, and external components. Each layer can assume something about the cost and outcome of the next call. If the protocol change shifts those conditions, the application may hit an edge case its developers didn't plan for.
It's easy to treat gas changes like a performance tweak. But gas rules are part of the execution environment. Teams may have written logic assuming calls succeed within a certain budget - or written behavior around what happens when a downstream call fails. Even if the business logic doesn't change, the upgrade can expose brittle assumptions.
You also can't assess this by looking at one contract in isolation. The question isn't just, "Does this contract still work under the new rules?" It's also, "What happens when it interacts with other contracts, under failure conditions, near the edge of its gas budget?" That's why the review focuses on call paths and combinations of components, not only individual functions.
The reported concern around EIP-8037 and EIP-8038 was tied specifically to contracts that rely on current gas behavior and could break when a call runs out of gas. That's a compatibility and failure-handling warning, not proof that every affected contract will fail in normal use. Still, it can be enough to justify deeper review: in DeFi, a rare failure path can matter if an attacker can trigger it deliberately or if it blocks a critical operation.
For application teams, the implication is straightforward. If a protocol upgrade changes execution assumptions, don't only retest the happy path - retest failure paths too, including nested calls that run out of gas or return unexpected results. A passing test can show a trade or transfer works. It can't prove the system stays safe when calls fail inside other calls.
How did AI agents coordinate the security review?
According to Chiang, two researchers - one from Ethlabs and one from the Ethereum Foundation - independently set up AI agents to scan contracts for vulnerabilities. When they realized they were using a similar approach, they created a GitHub repository that acted as a message board so the agents could coordinate their work.
What mattered wasn't just that AI was used to inspect code. It was the shared workflow. Separate efforts can duplicate scans, miss context held by another team, or produce findings in formats that are hard to compare. A common place to post results lets agents - and the humans supervising them - build on what's already been found rather than starting from zero.
Chiang compared the pattern to a reported incident involving agents associated with an OpenAI and Hugging Face security exercise, where rogue agents used a message board to coordinate attacks. His point was that coordination isn't automatically malicious. The same basic workflow can support defensive work. The difference comes from permissions, goals, supervision, and the surrounding security controls.
The exercise was described as successful at finding potential problems, and researchers reportedly set up a second board to examine EIP-8198 (also known as "Quick Slots"), proposed for the later Hegota hard fork. That's a practical role for agents: scanning a large surface area and helping researchers prioritize what to investigate. It's not evidence that an agent alone proved the whole upgrade safe or replaced human review.
There are clear limits, though. Automated tools can generate false positives, miss vulnerabilities that depend on economic incentives or cross-contract behavior, and struggle with undocumented assumptions. They can also create operational risk if someone gives them broad access to repositories, infrastructure, or deployment processes. Even if an agent can suggest a finding, that doesn't automatically mean it's safe to let it modify code or act directly on production systems.
A reliable workflow keeps responsibilities explicit:
- Agents search and report; researchers validate and classify findings.
- Findings include reproducible conditions, not just a warning or score.
- Human reviewers assess impact across contracts and protocol components.
- Changes go through normal testing, review, and release controls.
That separation lets teams use automation for scale without pretending that "more output" automatically equals "more certainty."
What does the Bitcoin challenge teach about AI-era security?
A separate "Steal My Bitcoin" challenge showed a different security problem in practice. The site was intentionally left vulnerable to PHP2Shell flaws and offered a Bitcoin prize worth about $2,000. The wallet key was accessible to the PHP user account through a binary called print-flag, but getting it wasn't as simple as sending one request.
The challenge was solved by a participant known as KillerBoi, who extracted a private key. The organizer, James Pavur, later acknowledged that the key didn't match the wallet address shown on the site and said the funds would be transferred. So the prize setup had a mistake - but the exploit still illustrated how hard some vulnerabilities are to use reliably, even when the bug is "known."
Wordfence founder Mark Maunder described what it took: triggering a precise memory-corruption condition, leaking internal memory addresses, bypassing address space layout randomization, reverse-engineering PHP's internal memory structures, and accounting for differences between builds, workers, and timing. That's a useful distinction for security teams. A vulnerability can be serious even if exploitation requires very specific conditions. And conversely, a proof of concept from a controlled challenge doesn't automatically tell you how easy compromise will be in real deployments.
This episode also fits a broader shift in vulnerability research. Bitcoin Core developer Antoine Poinsot said the project was changing its disclosure policy because large language models can make some bugs easier to rediscover. If automation helps attackers find bugs quickly, a long disclosure embargo may offer less protection while delaying a fixed release.
That doesn't mean everything should be disclosed immediately. Teams still need time to prepare patches and coordinate with users. The real policy question is whether the current disclosure window still gives defenders a meaningful advantage, now that rediscovery can happen faster. Security policy has to respond to what attackers and defenders can do - not assume code stays obscure until a planned announcement.
Taken together, the PHP challenge and the Ethereum review point in two directions at once: automation can increase the number of places teams inspect, but it can also shrink the time between a flaw becoming known and being independently rediscovered. That makes disciplined triage and clear remediation paths more important, not less.
What should protocol teams change before the next fork?
The clearest lesson from Glamsterdam is procedural: compatibility analysis should start earlier, especially when a proposal changes assumptions that contracts rely on. Chiang argued that protocol designers should run more thorough analysis for potential breakages well before a late-stage testnet rehearsal. This isn't about eliminating risk - no one can promise that - but about making the risk visible while there's still time to respond.
A useful review process treats a protocol change like a chain of consequences. Start with the intended behavior, then list which assumptions it might invalidate, which contract patterns are likely to be affected, and which failure conditions could matter. Finally, test those conditions against real applications and combinations of contracts. The more a change alters shared execution rules, the less value unit tests alone provide for judging the proposal.
A practical pre-fork checklist:
- Map affected assumptions. Document which gas, call, timing, or state behaviors the proposal changes, and which existing patterns depend on them.
- Scan known deployments early. Use static analysis and AI agents to identify likely affected contracts, but treat the output as leads for investigation.
- Test failure paths. Include out-of-gas cases, reverted calls, nested interactions, and boundary conditions - not only successful transactions.
- Share findings in a controlled way. Use a common format and workspace for researchers, while limiting agents' permissions and protecting sensitive data.
- Set decision gates. Define what evidence is needed to continue, delay, or revise the upgrade. A schedule alone isn't a security argument.
- Coordinate with application teams. Give developers enough detail and time to test their systems against changed protocol behavior.
There's a trade-off. More analysis takes engineering time and can slow releases. But finding a compatibility issue before activation is often cheaper than coordinating emergency fixes across protocol teams, application developers, and users afterward. The right amount of scrutiny depends on blast radius: a narrow change needs different review than one that alters a shared execution rule.
AI agents can improve coverage when they're integrated into this process. They don't replace threat modeling, expert review, or clear go/no-go decisions. The point isn't to automate responsibility - it's to help teams find better evidence before they make a call.
Conclusion
Glamsterdam's pause is a reminder that protocol upgrades can affect applications through assumptions that are easy to miss in a design document - or in a test that only covers the successful path. The AI-agent collaboration helped researchers search and share findings, but the safety decision still comes down to careful validation, impact analysis, and the willingness to delay when evidence is incomplete.
For protocol teams, the practical response is to test compatibility earlier, treat failure paths as part of the review, and use automation to widen coverage without swapping it in for judgment. The upgrade is ready when the risks are understood well enough to move forward - not just when the calendar says it should.