# Fuzzing/Fuzz testing

Fuzzing, or fuzz testing, is an automated software testing technique that supplies invalid, unexpected, or random inputs to programs and monitors them for crashes, vulnerabilities, or other undesirable behavior.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Hardening JavaScript Programs against LLM-Based Vulnerability Detection

DevFeed: [Hardening JavaScript Programs against LLM-Based Vulnerability Detection](<https://devfeed.tech/articles/hardening-javascript-programs-against-llm-based-vulnerability-detection-146045.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25718>)

Author: Zhenhao Tian, Jintong Yu, Jingwei Feng, Jianwei Zhuge, Penghui Li

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [LLM security](<https://devfeed.tech/topics/llm-security.md>), [Compilers and Linkers](<https://devfeed.tech/topics/compilers-and-linkers.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [defense](<https://devfeed.tech/tags/defense.md>), [hardening](<https://devfeed.tech/tags/hardening.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [llm](<https://devfeed.tech/tags/llm.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>), [vulnerability-detection](<https://devfeed.tech/tags/vulnerability-detection.md>)

### AI overview

AntiAgent hardens programs before release by applying semantics-preserving transformations designed to impede LLM-based vulnerability detection. It evolves programs with known vulnerabilities, tracks when a detection agent misses or misreports them, and turns successful transformations into reusable rules. For a new program, an LLM and those rules work together to adapt the transformations. In tests on real-world JavaScript applications, AntiAgent reduced vulnerabilities detected by each of four agents, including Claude Code and Codex, by 52.0-60.7%, outperforming JS-Obfuscator and FPA on every agent. Transformed programs passed all project tests. The abstract also reports effectiveness on vulnerability types absent from the training corpus and on Python programs.

### Source excerpt

arXiv:2611.25718v1 Announce Type: new Abstract: JavaScript programs are often distributed as source code, so attackers can analyze them for vulnerabilities. LLM-based vulnerability detection agents now make this analysis much easier. To mitigate this emerging threat, we present AntiAgent, a defense that lets developers harden their programs against such detection agents. AntiAgent transforms a program before release to impede an agent's analysis. To find effective transformations, AntiAgent evolves a corpus of programs with known vulnerabilities and traces how a detection agent analyzes each evolved version. It keeps the versions on which the agent misses or misreports the vulnerability and extracts their transformations into reusable rules. To protect a new program, AntiAgent carefully divides the task between an LLM and the rules, so that the transformations adapt to the program while preserving its semantics. We evaluate AntiAgent on real-world JavaScript applications against four detection agents, including Claude Code and Codex. AntiAgent reduces the number of vulnerabilities that each agent detects by 52.0-60.7%, outperforming the conventional obfuscator JS-Obfuscator and the LLM-based transformation method FPA on every agent. The transformed programs pass all project tests, indicating that AntiAgent preserves the original program semantics. The transformation rules also remain effective on vulnerability types absent from the corpus and on programs written in another language like Python.

## My Least Favorite Example in Software Engineering

DevFeed: [My Least Favorite Example in Software Engineering](<https://devfeed.tech/articles/my-least-favorite-example-in-software-engineering-144363.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/my-least-favorite-example-in-software-engineering/>)

Author: Hillel Wayne

Published: 2026-11-19T15:40:32Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [example](<https://devfeed.tech/tags/example.md>), [property-based-testing](<https://devfeed.tech/tags/property-based-testing.md>), [reverse](<https://devfeed.tech/tags/reverse.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The familiar property-based testing example--generating a random list and checking that reversing it twice restores the list--shows what PBT is, but the author says it poorly teaches why the technique matters in real software. Examples should be understandable, representative of real use, and help learners find related cases. The author suggests the example spread because it is simple and language-agnostic, and because John Hughes's QuickCheck paper used it. Earlier authors, including Zohar Manna, Boyer and Moore, and Richard Bird and Philip Wadler, had used double reversal to illustrate proofs; Hughes used it as a property to test. The same example can suit one context and fail another, and double reversal was useful in Hughes's work on list representations. The critique is about teaching usefulness, not blame.

### Source excerpt

I'm doing a lightning talk at Brooklyn Web Workers on 11/30! If you're in the area, come check it out. If you're not in the area (like 99.90% of the world), you can just read this newsletter instead. As you probably know, I am obsessed with examples. Really, really, really obsessed with examples. The best examples should at least: Be simple enough to understand Clearly showcase the topic under discussion Actually correspond to how the topic manifests in the real world Give some rough idea on how to find other examples in the same vein Basically, the example needs to both help the student understand the topic and also why the topic matters. If not to them, at least to someone they know. A good example of a good example is demonstrating type safety with option types, which ensure that you always handle nulls in your program. It's intuitive, clear, and simple, and it shows why and how this would be useful in practice. But I'm not here to talk about good examples. I'm here to talk about bad examples Specifically my least favorite example. Property-Based Testing is a testing approach where we generate random inputs to a program and check the outputs all satisfy some property. And like half the PBT introductions online use this same example: test reverse-reverse: l = random_list() reverse(reverse(l)) == l I hate this example because 1) I see it every-freakin'-where, and 2) it fails the "this topic matters" criteria hard. It gives you some idea of what property-based testing is, but doesn't give you any way to relate it to actual real-world testing. I mean, who writes list reversal algorithms for their job?1 And sure, common examples of regular testing like add(1, 2) == 3 are also useless, but 1) regular testing is mundane and you can probably figure out more useful tests from that 2) most people can give you better examples than that! PBT, on the other hand, is quite exotic for most people and they need a lot of guidance on how to go from "learning about the concept of pr

## RootSink: Reproducible C/C++ Crashes with Tested Repair Sites

DevFeed: [RootSink: Reproducible C/C++ Crashes with Tested Repair Sites](<https://devfeed.tech/articles/rootsink-reproducible-c-c-crashes-with-tested-repair-sites-142181.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23336>)

Author: Suryansh Singh Sijwali, Achintya Lakshmanan, Abhiram Dodda, Shaiful Chowdhury, Suman Saha

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-c-plus-plus](<https://devfeed.tech/tags/c-c-plus-plus.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [repair](<https://devfeed.tech/tags/repair.md>)

### AI overview

RootSink offers 3,341 C/C++ crash records from 354 open-source projects, pairing reported crash sites with candidate root causes and weakness labels with evidence. For 1,954 records in its Reproduced tier, the authors reran the crash and confirmed the fixed version runs cleanly. A single fix hunk independently stopped the crash in 1,275 cases; these are tested repair sites, not necessarily the defects, and 1,273 are labeled as roots. In a blind audit of an earlier version, two co-author raters identified defects at 68% and 92% of tested repair sites they reviewed, compared with 37% and 51% of located roots. The dataset includes tasks, a patch scorer, and run logs.

### Source excerpt

arXiv:2611.23336v1 Announce Type: new Abstract: When a C or C++ program crashes on a crafted input, the line that crashes is often not the line that is wrong. Tools and models that repair or locate vulnerabilities need examples showing both, with evidence for each, which existing datasets rarely provide. RootSink provides 3341 records from 354 open-source projects. Most give the crash site a memory-error detector reported and a candidate location for its root cause, and label each with a weakness type and its evidence. For the 1954 records in the Reproduced tier, we re-ran the crash ourselves and confirmed that the fixed version runs cleanly. In 1275 of these, a single hunk of the developer's fix stopped the crash on its own. That marks a tested repair site, though not necessarily the defect, and 1273 records use it as the root. In a blind audit of an earlier version, two co-author raters called 68% and 92% of the tested repair sites they saw the defect, but only 37% and 51% of that version's located Reproduced-tier roots. RootSink ships with tasks, a patch scorer and run logs.

## MLIR-MRacle: Memory-Model-Aware Metamorphic Fuzzing of Concurrent MLIR

DevFeed: [MLIR-MRacle: Memory-Model-Aware Metamorphic Fuzzing of Concurrent MLIR](<https://devfeed.tech/articles/mlir-mracle-memory-model-aware-metamorphic-fuzzing-of-concurrent-mlir-142218.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24804>)

Author: Aaron Gabayoyo, Aidan Dakhama, Ajitha Rajan

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [execution](<https://devfeed.tech/tags/execution.md>), [extension](<https://devfeed.tech/tags/extension.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [memory-model](<https://devfeed.tech/tags/memory-model.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [openmp](<https://devfeed.tech/tags/openmp.md>), [optimisation](<https://devfeed.tech/tags/optimisation.md>), [oracles](<https://devfeed.tech/tags/oracles.md>)

### AI overview

MLIR-MRacle tests concurrent MLIR compiler lowerings by applying metamorphic transformations gated by the target memory model, keeping both program variants well defined. It runs each repeatedly and uses one of two statistical oracles to compare outcome sets or distributions, with a libafl coverage-guided driver for continuous fuzzing. In an Armv8 case study, it ran more than 145,000 trials across four configurations, reached up to 93,600 compiler coverage edges, and found an OpenMP dialect verifier bug that has since been fixed upstream. The abstract says transformations, memory models, oracles, and execution backends are extensible.

### Source excerpt

arXiv:2611.24804v1 Announce Type: new Abstract: Multi-level compilers built on MLIR lower concurrent programs through many stages towards targets with potentially drastically different memory models, where an optimisation which appears reasonable, can silently change program behaviour. Testing these lowerings is hard: a concurrent program often has no single expected outcome, and existing MLIR fuzzers often assume determinism. We present MLIR-MRacle, a memory-model-aware metamorphic fuzzer for concurrent MLIR programs. MLIR-MRacle applies metamorphic relations gated by the target memory model, so that both the original and transformed programs remain well defined - executing both repeatedly, and comparing their outcome sets or distributions withone of two statistical oracles. A coverage guided campaign driver built on libafl is used to perform continuous fuzzing. MRs, memory models, oracles, and execution backends all provide extension points for future researchers and compiler engineers to build off this package. In a case study on Armv8 hardware, MLIR-MRacle ran over 145k trials across four configurations, reaching up to 93.6k compiler coverage edges, and found a bug in the OpenMP dialect verifier that has since been fixed upstream. Video: https://youtu.be/lKtGk0H97Ts?si=dWLUHl2CJ24ep6JY

## Re-Testing LLM-Based C-to-Rust Translations Against Their Original C

DevFeed: [Re-Testing LLM-Based C-to-Rust Translations Against Their Original C](<https://devfeed.tech/articles/re-testing-llm-based-c-to-rust-translations-against-their-original-c-142198.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23839>)

Author: Muhammad Hassnain

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-to-rust](<https://devfeed.tech/tags/c-to-rust.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [defects](<https://devfeed.tech/tags/defects.md>), [errors](<https://devfeed.tech/tags/errors.md>), [input](<https://devfeed.tech/tags/input.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>), [translations](<https://devfeed.tech/tags/translations.md>)

### AI overview

The authors re-tested 11 LLM-based C-to-Rust translators that release runnable C and Rust programs. They ran both versions on generated inputs and compared every output, counting divergences only when the C had no undefined behavior. All 11 had defective translations, with 160 defects, including 93 errors on ordinary inputs; the translators' own checks accepted 86 defective translations. In 81 cases, the released check never tested an input exposing the defect, and in three of the other five it compared only part of the output. The authors recommend testing on inputs unseen by the repair loop, comparing all outputs, checking that verifiers reach their assertions, releasing the exact code the check accepted, and reporting how the check was tested.

### Source excerpt

arXiv:2611.23839v1 Announce Type: new Abstract: Most C-to-Rust translators use large language models (LLMs), and each reports a success rate from its own correctness check. We survey 34 C-to-Rust translators that use LLMs. Only one reports testing its check, and eleven release the original C and their Rust in runnable form. We re-test all eleven. We run the C and the Rust on generated inputs, compare every output, and count a divergence only where the C has no undefined behavior. All eleven release defective translations: we find 160 defects, 93 of them outright errors on ordinary inputs. Their own checks accepted 86 defective translations. For 81 of them, the released check never compared the programs on an input that exposes the defect. For three of the other five, it ran one but compared only part of the output. A success rate is only as good as its check. Before counting a translation as a success, authors should compare every output with the C's on inputs the repair loop never saw, check that a verifier reaches its assertion, release exactly what the check accepted, and report how they tested the check.

## Adaptive Budget Allocation for Smart-Contract Fuzzing: Why Online Feedback Fails to Improve Vulnerability Triage

DevFeed: [Adaptive Budget Allocation for Smart-Contract Fuzzing: Why Online Feedback Fails to Improve Vulnerability Triage](<https://devfeed.tech/articles/adaptive-budget-allocation-for-smart-contract-fuzzing-why-online-feedback-fails-to-improve-vulnerability-triage-139606.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22430>)

Author: Yanzi Liu, Jiachi Tong

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [smart contract](<https://devfeed.tech/topics/smart-contract.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [budget](<https://devfeed.tech/tags/budget.md>), [bug](<https://devfeed.tech/tags/bug.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [detection](<https://devfeed.tech/tags/detection.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [online](<https://devfeed.tech/tags/online.md>), [smart-contract](<https://devfeed.tech/tags/smart-contract.md>), [triage](<https://devfeed.tech/tags/triage.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>), [vulnerability-triage](<https://devfeed.tech/tags/vulnerability-triage.md>)

### AI overview

Trace replay on 143 annotated and 350 bug-injected smart contracts found that, at a mean budget of 100 executions per contract, uniform allocation reached 72% and 70% of the respective clairvoyant optima. All eight online allocation policies performed worse than uniform on aggregate triage; five online signals ranked imminent reports poorly, with AUCs of 0.32-0.51. Synthetic-oracle experiments indicate that accurate estimates of detection cost recover more of the performance gap than detectability rankings. The proposed offline allocator predicts first-report probabilities across budgets and allocates executions by predicted gain. In a frozen evaluation using four fresh seeds per corpus, it improved detection-budget AUC over uniform by 5.38% and 4.81% on the two source corpora and 1.99-6.54% on three additional public benchmark subsets.

### Source excerpt

arXiv:2611.22430v1 Announce Type: new Abstract: Smart-contract fuzzing campaigns share a finite budget and vary widely in the execution cost of a first correct-class vulnerability report. Using trace replay on 143 annotated and 350 bug-injected contracts, we test whether online feedback improves triage. At a mean budget of 100 executions per contract, uniform allocation reaches 72% and 70% of the respective clairvoyant optima. All eight online policies trail uniform on aggregate triage, as do the seven repeated on the bug-injected corpus. Five online signals yield ranking AUCs of 0.32-0.51 for imminent reports. Synthetic-oracle experiments show that sufficiently accurate detection-cost estimates recover more of the gap than detectability rankings. This motivates an offline probability-curve allocator that predicts first-report probabilities across budgets and allocates by predicted gain per execution. In a frozen evaluation on four fresh seeds per corpus, detection-budget AUC improves over uniform by 5.38% and 4.81% on the two source corpora and by 1.99-6.54% on three additional public benchmark subsets.

## From Ideal to Real: Integrating Language Models into Smart Home for Human-Centric IoT Safety and Security Fuzzing

DevFeed: [From Ideal to Real: Integrating Language Models into Smart Home for Human-Centric IoT Safety and Security Fuzzing](<https://devfeed.tech/articles/from-ideal-to-real-integrating-language-models-into-smart-home-for-human-centric-iot-safety-and-security-fuzzing-140032.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22457>)

Author: Lin Li, Xinbo Ban, Chao Chen, Lei Pan, Ming Ding, Kok-Leong Ong, Jun Zhang

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Internet of things](<https://devfeed.tech/topics/iot.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [iot](<https://devfeed.tech/tags/iot.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [safety](<https://devfeed.tech/tags/safety.md>), [security](<https://devfeed.tech/tags/security.md>), [smart-home](<https://devfeed.tech/tags/smart-home.md>)

### AI overview

The work extends IoT Fuzz for smart homes by using large language models to emulate human decision-making during fuzz testing. It aims to expose inter-rule vulnerabilities that simulated tests assuming ideal human choices may miss, including risks to privacy, data, and physical safety. The abstract says this adds realism and unpredictability to testing, but provides no evaluation results or implementation details.

### Source excerpt

arXiv:2611.22457v1 Announce Type: new Abstract: Integrating IoT devices into household systems offers enhanced control over living environments. However, as these devices become pervasive in critical sectors such as healthcare, transportation, and home automation, they expose inter-rule vulnerabilities that may lead to privacy breaches, data theft, and physical harm. Traditional fuzz testing methods, which often operate in simulated environments assuming ideal human decisions, fail to account for the complexities of human interactions that can influence device operations in smart homes, potentially leading to unforeseen consequences. To reveal the impact of real human decisions and discover unexpected inter-rule vulnerabilities, we introduce an enhanced version of IoT Fuzz for smart homes by integrating large language models to emulate human decision-making processes. Our novel approach adds a layer of realism and unpredictability to the testing environment, more accurately capturing the diverse and dynamic nature of human interactions in smart home settings.

## Revisiting Re-executability: Coverage-Guided Symbolic Feedback to Improve Decompilation

DevFeed: [Revisiting Re-executability: Coverage-Guided Symbolic Feedback to Improve Decompilation](<https://devfeed.tech/articles/revisiting-re-executability-coverage-guided-symbolic-feedback-to-improve-decompilation-137973.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18892>)

Author: Yuxin Hu, Xiaohan Wang, Kevin Leach

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Reverse Engineering](<https://devfeed.tech/topics/reverse-engineering.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [test](<https://devfeed.tech/topics/test.md>)

Tags: [behavior](<https://devfeed.tech/tags/behavior.md>), [branch](<https://devfeed.tech/tags/branch.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [decompilation](<https://devfeed.tech/tags/decompilation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-assisted](<https://devfeed.tech/tags/llm-assisted.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [reference](<https://devfeed.tech/tags/reference.md>), [repair](<https://devfeed.tech/tags/repair.md>), [symbolic-execution](<https://devfeed.tech/tags/symbolic-execution.md>)

### AI overview

SymDec uses coverage-guided symbolic execution to find inputs that distinguish an original binary from its recompiled decompilation. It replays those inputs on both programs to confirm behavioral differences, then sends structured feedback to an LLM for repair. Across 960 tasks covering x86-64 and ARM64 binaries at optimization levels O0-O3, symbolic comparison found replay-confirmed differences in 4.5% of candidates that passed all supplied tests, showing that test-suite success alone can miss discrepancies. With the same input-generation budget, symbolic execution achieved higher mean line and branch coverage than black-box fuzzing. Symbolic feedback also raised the mean single-step test-pass rate from 90.1% to 93.3%. More than half of tasks produced candidates that passed the supplied tests and had no differences detected by symbolic comparison; this indicates evidence of consistency, not proof of full behavioral equivalence.

### Source excerpt

arXiv:2611.18892v1 Announce Type: new Abstract: When source code is unavailable, decompilation provides a source-level representation of a binary. However, code recovered by conventional or LLM-assisted decompilation may not preserve the original behavior of the binary. Recent approaches evaluate re-executability using fixed test suites, but passing these suites does not ensure behavioral preservation. We present SymDec, an LLM-assisted decompiled-code repair system that uses the original binary as a behavioral reference. SymDec uses coverage-guided symbolic execution to explore the I/O-level behavior of the original and recompiled binaries, and symbolic comparison to identify inputs that expose behavioral differences. These inputs are replayed on both binaries to confirm the differences, which are returned as structured feedback to guide subsequent LLM revisions. We evaluate SymDec on 120 functions from ExeBench and DecompileBench, compiled for x86-64 and ARM64 at optimization levels O0-O3, yielding 960 binary decompilation tasks. More than half of the tasks yield candidates that pass the supplied test suite and complete symbolic comparison without detected behavioral differences. Among candidates that pass all supplied tests, symbolic comparison exposes replay-confirmed behavioral differences in 4.5% of cases, showing that test-suite re-executability can miss behavioral discrepancies. Under the same input-generation budget, symbolic execution achieves higher mean line and branch coverage than black-box fuzzing. Symbolic feedback also improves the conventional metric, increasing the mean single-step test-pass rate from 90.1% to 93.3%. These results show that symbolic comparison provides stronger evidence of behavioral consistency than test-suite re-executability alone and supplies effective feedback for repairing decompiled code.

## AI uncovers flaws in discontinued devices with no vendor left to patch them

DevFeed: [AI uncovers flaws in discontinued devices with no vendor left to patch them](<https://devfeed.tech/articles/ai-uncovers-flaws-in-discontinued-devices-with-no-vendor-left-to-patch-them-134759.md>)

Original publisher: [Read original article](<https://www.helpnetsecurity.com/2026/11/16/forescout-ai-models-vulnerability-research/>)

Author: Anamarija Pogorelec

Published: 2026-11-16T05:00:22Z

Content type: news

Language: en

Sources: [Help Net Security](<https://devfeed.tech/sources/help-net-security.md>)

Topics: [Security research](<https://devfeed.tech/topics/security-research.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Embedded Systems](<https://devfeed.tech/topics/embedded-systems.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-models](<https://devfeed.tech/tags/ai-models.md>), [approach](<https://devfeed.tech/tags/approach.md>), [budget](<https://devfeed.tech/tags/budget.md>), [code](<https://devfeed.tech/tags/code.md>), [components](<https://devfeed.tech/tags/components.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [devices](<https://devfeed.tech/tags/devices.md>), [discontinued](<https://devfeed.tech/tags/discontinued.md>), [forescout](<https://devfeed.tech/tags/forescout.md>), [ip](<https://devfeed.tech/tags/ip.md>), [models](<https://devfeed.tech/tags/models.md>), [networks](<https://devfeed.tech/tags/networks.md>), [news](<https://devfeed.tech/tags/news.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [open-source-code](<https://devfeed.tech/tags/open-source-code.md>), [patch](<https://devfeed.tech/tags/patch.md>), [report](<https://devfeed.tech/tags/report.md>), [research](<https://devfeed.tech/tags/research.md>), [security](<https://devfeed.tech/tags/security.md>), [software](<https://devfeed.tech/tags/software.md>), [source](<https://devfeed.tech/tags/source.md>), [source-code](<https://devfeed.tech/tags/source-code.md>), [tcp](<https://devfeed.tech/tags/tcp.md>), [vulnerability-disclosure](<https://devfeed.tech/tags/vulnerability-disclosure.md>)

### AI overview

Forescout's AI-assisted system confirmed 99 vulnerabilities across 10 TCP/IP stacks, including 66 previously unknown; 52% of the new flaws were rated high or critical. The process combined code scanners, Claude-based agents assessing reachability and exploitability, and attempts to run software and trigger flaws, with researcher guidance. It generated 362 initial findings, but testing and review confirmed 99. Automated analysis took about 10 hours and validation about 80, compared with roughly nine months of manual code analysis in an earlier project; building the system required additional work. Compiled software without source code took roughly twice as long and cost about six times more to inspect than source code, with reconstruction causing possible inaccuracies and false alarms. The system was better at detecting network-related memory errors than logic or design flaws. Some affected products are discontinued, leaving no vendor to provide patches; Forescout's CEO said containment may be the priority where devices cannot easily be patched or taken offline.

### Source excerpt

Forescout researchers built a tool to test if generally available AI models could find security flaws on a limited budget. They examined both open-source code and compiled software whose source code was unavailable, testing an approach attackers could also use. The team confirmed 99 vulnerabilities across 10 TCP/IP stacks, the software components that allow devices to communicate over networks. Sixty-six were previously unknown, and 52% of those newly discovered vulnerabilities were rated as high or ... More -> The post AI uncovers flaws in discontinued devices with no vendor left to patch them appeared first on Help Net Security.

## Evaluating Feedback-Driven Black-Box Processes via Stochastic Modeling and Simulation

DevFeed: [Evaluating Feedback-Driven Black-Box Processes via Stochastic Modeling and Simulation](<https://devfeed.tech/articles/evaluating-feedback-driven-black-box-processes-via-stochastic-modeling-and-simulation-135908.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18477>)

Author: Mengfan Xu, Zirui Liu, Juan Zhai, Shiqing Ma, Barry Nelson

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Simulation](<https://devfeed.tech/topics/simulation.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [black-box](<https://devfeed.tech/tags/black-box.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [case-studies](<https://devfeed.tech/tags/case-studies.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [develop](<https://devfeed.tech/tags/develop.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [markov](<https://devfeed.tech/tags/markov.md>), [markov-chain](<https://devfeed.tech/tags/markov-chain.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [processes](<https://devfeed.tech/tags/processes.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The paper proposes a Markov-chain and simulation framework for evaluating sequential black-box policies that use system feedback to choose later inputs, even when the underlying system's structure is unknown. For mutation-based fuzzing, it models transitions through the mutation strategy and feedback through program execution. The authors describe new performance measures, sound estimators, and evaluation procedures with provable guarantees, then apply them to 9 fuzzers across 18 benchmarks and report case studies in 4 non-fuzzing domains. The supplied abstract does not give comparative results or details of those case studies.

### Source excerpt

arXiv:2611.18477v1 Announce Type: cross Abstract: We study feedback-driven black-box processes across software engineering and machine learning. These processes are inherently sequential: policies generate inputs, observe outputs/feedback from systems, and use the feedback to guide the design of subsequent inputs. While many policies are developed under structural assumptions on the underlying systems, many real-world systems operate without such knowledge, necessitating black-box policies that lack a unified evaluation framework. We introduce a stochastic framework that models and evaluates such policies using Markov chains and simulation, thereby connecting empirical practice with theory. We instantiate the framework in mutation-based fuzzing (widely used for discovering software bugs via sequential input mutation), by a novel Markov chain model of fuzzing whose transitions are governed by the mutation strategy and whose feedback is given by program execution. We develop a rigorous evaluation paradigm with new performance measures, sound estimators, and evaluation procedures with provable guarantees. Guided by the theory, we evaluate 9 fuzzers on 18 widely used fuzzing benchmarks and conduct case studies in 4 non-fuzzing domains. These results show that the framework provides a principled basis for evaluation while connecting to practice, with implications beyond fuzzing.

## Catch Go bugs that fuzzing misses with Gemini and a constraint solver

DevFeed: [Catch Go bugs that fuzzing misses with Gemini and a constraint solver](<https://devfeed.tech/articles/catch-go-bugs-that-fuzzing-misses-with-gemini-and-a-constraint-solver-131279.md>)

Original publisher: [Read original article](<https://developers.googleblog.com/catch-go-bugs-that-fuzzing-misses-with-gemini-and-a-constraint-solver/>)

Author: Karl Weinmeister

Published: 2026-11-13T06:38:11.586756Z

Content type: article

Language: en

Sources: [Google Developers Blog](<https://devfeed.tech/sources/google-developers-blog.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [argon](<https://devfeed.tech/tags/argon.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-4](<https://devfeed.tech/tags/gemini-4.md>), [gemini-4-argon](<https://devfeed.tech/tags/gemini-4-argon.md>), [go](<https://devfeed.tech/tags/go.md>), [go-test](<https://devfeed.tech/tags/go-test.md>), [pairing](<https://devfeed.tech/tags/pairing.md>), [slice](<https://devfeed.tech/tags/slice.md>), [surviving](<https://devfeed.tech/tags/surviving.md>), [test](<https://devfeed.tech/tags/test.md>), [z3](<https://devfeed.tech/tags/z3.md>)

### AI overview

The article describes a Go bug-finding workflow that compiles functions for RISC-V, identifies bounds-check traps left after compiler optimization, and has Gemini 4 Argon translate their paths into Z3 constraints. Z3 can generate concrete crashing inputs, which `go test` replays against the real code; a `sat` result was reliable in the reported cases, while `unsat` is only suggestive, not a correctness proof. The approach found three planted parser bugs and three latent `skill-lint` bugs. It also exposed why ordinary Go fuzzing missed two panics: slice expressions check capacity, and fuzz inputs often have spare capacity. Clipping fuzz input capacity to length made the fuzzer find both bugs quickly. The solver is best suited to pure functions and helpers; fuzzing and race detection remain useful for broader behavior, and the described single-threaded models do not detect races or deadlocks.

### Source excerpt

How pairing Go's surviving compiler bounds-check traps with Gemini 4 Argon and the Z3 constraint solver catches latent out-of-bounds panics in Go code and uncovers a slice-capacity blind spot in go test -fuzz.

## One Fuzzer, Many Reasoners: Adaptive Neuro-Symbolic Fuzzing with Reliability-Calibrated and Context-Gated Guidance

DevFeed: [One Fuzzer, Many Reasoners: Adaptive Neuro-Symbolic Fuzzing with Reliability-Calibrated and Context-Gated Guidance](<https://devfeed.tech/articles/one-fuzzer-many-reasoners-adaptive-neuro-symbolic-fuzzing-with-reliability-calibrated-and-context-gated-guidance-132208.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.16211>)

Author: Jinghao Wen, Xianglong Yu, Shaohuang Wang, Xun Jiao

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [effective](<https://devfeed.tech/tags/effective.md>), [failure](<https://devfeed.tech/tags/failure.md>), [framework](<https://devfeed.tech/tags/framework.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [grounding](<https://devfeed.tech/tags/grounding.md>), [guidance](<https://devfeed.tech/tags/guidance.md>), [model](<https://devfeed.tech/tags/model.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [neural](<https://devfeed.tech/tags/neural.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [risk](<https://devfeed.tech/tags/risk.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [signal](<https://devfeed.tech/tags/signal.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

NSAI-Fuzz uses a shared, semantics-aware risk interface to guide fuzzing across heterogeneous neural-symbolic AI systems. It combines five availability-aware signals--boundary pressure, grounding uncertainty, representation drift, constraint violation, and archive novelty--with task-specific valid mutation. Reliability-Calibrated Weighting (RCW) assigns dataset-model-level signal weights using calibrated reliability, while Contextual Signal Gating (CSG) adapts weights to the current candidate pool. In the reported evaluation across four systems and four reasoning tasks, fixed five-signal guidance beat Random and Uniform in every compatible cell, and RCW and CSG improved over Fixed in all nine cells. With matched mutation and query budgets, they found 16.17% and 16.06% aggregate failures, versus 6.06% for the strongest neural-fuzzing baseline. TensorFuzz used 1.11 times RCW's runtime while delivering 0.45 times its failure throughput.

### Source excerpt

arXiv:2611.16211v1 Announce Type: new Abstract: Neural-symbolic AI (NSAI) combines learned perception with programs, constraints, and compositional reasoning, but remains difficult to test because small semantics-preserving changes can alter grounded symbols and trigger discontinuous reasoning failures. Existing neural fuzzers mainly rely on neural coverage or representation-space feedback and do not provide a common testing interface for heterogeneous NSAI systems. We introduce NSAI-Fuzz, a unified semantics-aware fuzzing framework that separates task-specific valid mutation from architecture-neutral guided search and represents each candidate using five availability-aware, rank-normalized risk signals: boundary pressure, grounding uncertainty, representation drift, constraint violation, and archive novelty. We further propose Reliability-Calibrated Weighting (RCW), which learns dataset-model-level signal allocations from calibrated reliability, and Contextual Signal Gating (CSG), which adapts signal weights to the current candidate pool. We evaluate four NSAI systems across four reasoning tasks, nine compatible dataset-model cells, 20 policies, and 1,800 on-policy runs. Fixed five-signal guidance outperforms Random and Uniform in every cell, while RCW and CSG further improve over Fixed in all nine cells. Under matched mutation and query budgets, RCW and CSG achieve 16.17% and 16.06% aggregate failure discovery, compared with 6.06% for the strongest neural-fuzzing baseline. Wall-clock evaluation further shows that TensorFuzz requires 1.11x the runtime of RCW while achieving only 0.45x its failure throughput. These results show that effective and efficient fuzzing of heterogeneous NSAI systems benefits from a common neural-symbolic risk interface with adaptive signal allocation.

## In the Hole

DevFeed: [In the Hole](<https://devfeed.tech/articles/in-the-hole-129684.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/in-the-hole>)

Author: Remy Porter

Published: 2026-11-11T06:30:00Z

Content type: article

Language: en

Sources: [The Daily WTF](<https://devfeed.tech/sources/the-daily-wtf.md>)

Topics: [Error Handling](<https://devfeed.tech/topics/error-handling.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [hosting](<https://devfeed.tech/topics/hosting.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [alpine](<https://devfeed.tech/tags/alpine.md>), [container](<https://devfeed.tech/tags/container.md>), [exploited](<https://devfeed.tech/tags/exploited.md>), [feature-articles](<https://devfeed.tech/tags/feature-articles.md>), [glibc](<https://devfeed.tech/tags/glibc.md>), [libc](<https://devfeed.tech/tags/libc.md>), [linux](<https://devfeed.tech/tags/linux.md>), [musl](<https://devfeed.tech/tags/musl.md>), [security](<https://devfeed.tech/tags/security.md>), [ssh](<https://devfeed.tech/tags/ssh.md>), [sshole](<https://devfeed.tech/tags/sshole.md>)

### AI overview

The excerpt describes an SSH authentication flaw on some Linux systems: passwords longer than 256 characters can trigger a failed hash that lets a passwordless account authenticate. The account check compares the returned hash with the stored value. In glibc, `crypt` reports invalid input with `NULL`; in musl, it returns `*`, the same value commonly used in `/etc/shadow` or `/etc/passwd` to disable password access. The text says this affects musl-based systems such as Alpine, including containers, and reports that the flaw is being exploited. It attributes the failure to the interaction between musl's error return, the stored marker, and a password-length cap. The supplied excerpt ends before the article's full discussion.

### Source excerpt

Look, I don't want to keep talking about security issues. Blame AI. Just another thing it ruined. At this point, you've probably heard about *sshole. If you haven't, the quick summary: on some Linux systems, SSH will log you in to an account with no password if you supply a password greater than 256 characters long. Frequently, you might make accounts like root nominally inaccessible by giving it no password, so this is a big deal. Worse, it impacts varieties of Linux that use the musl implementation of libc, like Alpine- the kinds of varieties that run inside a container hosting a web app somewhere. The impact is broad, and is definitely being exploited. The root cause, however, is interesting, because it's a sum of very simple choices that lead to a wildly undesirable result. The core function in question is crypt, a stardard part of the C library. crypt is already not the best name, as it's a hashing function, but its behavior is pretty clear. Pass it a string and a salt, and it gives you a hashed version of the password suitable for storing in your /etc/shadow file. Now, the man page has the answer to the important question: what happens when I hand the function invalid inputs, like a bad salt? In the glibc implementation, it returns a NULL. That's a pretty standard C-style method of handling errors: I failed to do the thing, so I'm going to return a NULL value. This puts the onus on the callers to correctly handle the NULL (which also handles the error). glibc isn't the only implementation of libc, though. There are many others, each tuned to different types of runtime environments. For example, uClibC is a minimal implementation specifically designed to make lightweight executables that can run in resource constained environments. It makes tradeoffs that make it less desirable for a desktop or server environment. musl attempts to do both: be lightweight and suitable for embedded environments and also suitable for server environments. This makes musl a great ch

## Loop Engineering: 9 Ways to Automate Your AI Agents

DevFeed: [Loop Engineering: 9 Ways to Automate Your AI Agents](<https://devfeed.tech/articles/loop-engineering-9-ways-to-automate-your-ai-agents-126817.md>)

Original publisher: [Read original article](<https://craftbettersoftware.com/p/loop-engineering-9-ways-to-automate>)

Author: Daniel Moka

Published: 2026-11-10T06:09:49Z

Content type: tutorial

Language: en

Sources: [Craft Better Software](<https://devfeed.tech/sources/craft-better-software.md>)

Topics: [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [actions](<https://devfeed.tech/tags/actions.md>), [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agentic-engineering](<https://devfeed.tech/tags/agentic-engineering.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-assistant](<https://devfeed.tech/tags/ai-assistant.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [alert](<https://devfeed.tech/tags/alert.md>), [all](<https://devfeed.tech/tags/all.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [automate](<https://devfeed.tech/tags/automate.md>), [engineering](<https://devfeed.tech/tags/engineering.md>)

### AI overview

The article presents nine ways to automate recurring coding and maintenance work with agent loops: bug reports, production error spikes, issue triage, CI repair, dependency upgrades, CVE fixes, CI speed improvements, fuzz crashes, and inbox organization. Each loop uses a trigger to start an agent, a check to guide retries or stop, and human review of the resulting pull request or item. Examples use Claude Code scheduled tasks and GitHub triggers or Actions; inbox triage instead uses an always-on agent such as OpenClaw or Hermes with Discord and Markdown files. Several code-fixing loops stop after three failed attempts and send logs, tests, or crash inputs for review. The article also warns that emailed bug reports can carry prompt injection, recommending minimally scoped secrets, no merge rights, and review of every pull request.

### Source excerpt

Stop babysitting your AI agents. Put them on autopilot.

## From Formal Methods to Fuzzing and Back

DevFeed: [From Formal Methods to Fuzzing and Back](<https://devfeed.tech/articles/from-formal-methods-to-fuzzing-and-back-127266.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.12338>)

Author: Alastair F. Donaldson

Published: 2026-11-10T05:00:00Z

Content type: opinion

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal methods](<https://devfeed.tech/topics/formal-methods.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [keystone](<https://devfeed.tech/tags/keystone.md>), [scale](<https://devfeed.tech/tags/scale.md>), [software](<https://devfeed.tech/tags/software.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The author's experience suggests fuzzing can find real bugs in very large systems where formal methods have been difficult to scale, while formal methods remain useful for targeted work. The account traces this shift through GPUVerify, which verifies GPU kernels, and GraphicsFuzz, which uses randomized testing on GPU compilers. It presents the oracle problem as a link between the approaches, describes work at their boundary, and considers whether generative AI could help formal methods scale. The author plans to explore that question through the Keystone project; the abstract states this as an aim, not a demonstrated result.

### Source excerpt

arXiv:2611.12338v1 Announce Type: new Abstract: For the first twelve years of my career in computer science I mainly worked on formal methods. I had been drawn to the field as an undergraduate by its promise of a way to build software with strong, mathematically based correctness guarantees. But after many years of struggling to make formal methods scale, I was seduced by randomised testing---also known as fuzzing. Fuzzing is much less principled than formal methods, but it just works: it can be readily applied to very large systems, and it is extremely effective at finding real bugs that developers care about and fix. In this personal account I trace my path from formal methods to fuzzing, by way of the GPUVerify project on verifying GPU kernels and the GraphicsFuzz project on randomised testing of GPU compilers. I argue that the oracle problem provides an intellectual link between fuzzing and formal methods, describe my continuing, targeted uses of formal methods in the domain of GPU programming language design, and discuss work at the boundary between formal methods and fuzzing. Finally, I reflect on whether generative AI might be the missing ingredient that allows formal methods to scale, and set out my plans for large-scale formal methods via the Keystone project, through which my collaborators and I aim to find out how much of that promise can be realised in practice.

## Wake 5: A Python Framework for Solidity Testing, Fuzzing, and Static Analysis

DevFeed: [Wake 5: A Python Framework for Solidity Testing, Fuzzing, and Static Analysis](<https://devfeed.tech/articles/wake-5-a-python-framework-for-solidity-testing-fuzzing-and-static-analysis-124030.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.09307>)

Author: Josef Gattermayer, Michal P\\v{r}evr\\'atil

Published: 2026-11-09T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Solidity](<https://devfeed.tech/topics/solidity.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [ablation](<https://devfeed.tech/tags/ablation.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [audit](<https://devfeed.tech/tags/audit.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [comparisons](<https://devfeed.tech/tags/comparisons.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [evm](<https://devfeed.tech/tags/evm.md>), [execution](<https://devfeed.tech/tags/execution.md>), [foundry](<https://devfeed.tech/tags/foundry.md>), [framework](<https://devfeed.tech/tags/framework.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [generator](<https://devfeed.tech/tags/generator.md>), [go](<https://devfeed.tech/tags/go.md>), [harness](<https://devfeed.tech/tags/harness.md>), [python](<https://devfeed.tech/tags/python.md>), [solidity](<https://devfeed.tech/tags/solidity.md>), [static-analysis](<https://devfeed.tech/tags/static-analysis.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Wake 5 is a Python framework for Solidity testing, fuzzing, and static analysis that uses an in-process revm EVM and exposes static analysis to language-model agents through MCP. On the Daedaluzz benchmark, its throughput (29,931 transactions per second) was close to Foundry's and 11.5 times Echidna's, yet all three tools plateaued at similar assertion counts in eight-hour campaigns. The authors attribute this limit to input-generation bias after shallow assertions are exhausted: an agent-written harness using a constraint solver reached all 153 assertions in five Wake campaigns, taking 33-79 minutes each. In a separate production Go audit ablation, static analysis raised precision for all three models but improved recall for none and increased model cost by up to 12.7%. The abstract also flags correlated oracles and non-deterministic completion as limitations.

### Source excerpt

arXiv:2611.09307v1 Announce Type: new Abstract: Smart-contract fuzzers differ by an order of magnitude in throughput and by design in how they construct inputs, yet published comparisons rarely separate the two. We present Wake 5, an open-source Python framework for Solidity testing, fuzzing and static analysis, and use it to locate the binding constraint of stateful smart-contract fuzzing. Wake 5 replaces the JSON-RPC connection to an external node with an in-process EVM (revm) and exposes its static analysis to language-model agents through a Model Context Protocol (MCP) server. On the Daedaluzz maze benchmark (153 reachable assertions, guard constants below 2^32), Wake 5 executes 29,931 transactions per second, on par with Foundry (30,186) and 11.5x faster than Echidna (2,600). In eight-hour campaigns, however, the three tools plateau at medians of 75, 71 and 70 assertions, and their union reaches 93. We show that Wake's integer generator places 51% of its probability mass below 2^32 and that, once shallow assertions are exhausted, the generator prior rather than throughput bounds every tool. A harness written by a language-model agent, which derives inputs with a constraint solver, reached all 153 assertions in each of five campaigns executed by Wake, in 33 to 79 minutes. A complementary ablation in an agentic audit of a production Go codebase found that static-analysis tools improved recall for none of three models, raised precision for all three, and increased language-model cost by up to 12.7%. We discuss correlated oracles and non-deterministic completion, and argue that the fuzzer's role is shifting from search to execution.

## Gemini 4 Carbon Is Locked: Here's What It Means for Your Budget and Your Patch Window

DevFeed: [Gemini 4 Carbon Is Locked: Here's What It Means for Your Budget and Your Patch Window](<https://devfeed.tech/articles/gemini-4-carbon-is-locked-here-s-what-it-means-for-your-budget-and-your-patch-window-121759.md>)

Original publisher: [Read original article](<https://hackernoon.com/gemini-4-carbon-is-locked-heres-what-it-means-for-your-budget-and-your-patch-window?source=rss>)

Author: Ifeoluwa Tech (PhD)

Published: 2026-11-06T21:37:36Z

Content type: opinion

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [snyk-security-intel](<https://devfeed.tech/topics/snyk-security-intel.md>), [Claude](<https://devfeed.tech/topics/claude.md>)

Tags: [2018](<https://devfeed.tech/tags/2018.md>), [2019](<https://devfeed.tech/tags/2019.md>), [2023](<https://devfeed.tech/tags/2023.md>), [2026](<https://devfeed.tech/tags/2026.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-tasks](<https://devfeed.tech/tags/agent-tasks.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-regulation](<https://devfeed.tech/tags/ai-regulation.md>), [ai-safety](<https://devfeed.tech/tags/ai-safety.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [budget](<https://devfeed.tech/tags/budget.md>), [carbon](<https://devfeed.tech/tags/carbon.md>), [costs](<https://devfeed.tech/tags/costs.md>), [cyber](<https://devfeed.tech/tags/cyber.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [developers](<https://devfeed.tech/tags/developers.md>), [frontier-ai](<https://devfeed.tech/tags/frontier-ai.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-4-carbon](<https://devfeed.tech/tags/gemini-4-carbon.md>), [google](<https://devfeed.tech/tags/google.md>), [google-deepmind](<https://devfeed.tech/tags/google-deepmind.md>), [leaderboard](<https://devfeed.tech/tags/leaderboard.md>), [patch](<https://devfeed.tech/tags/patch.md>), [window](<https://devfeed.tech/tags/window.md>)

### AI overview

Gemini 4 Carbon is currently restricted to a small group of cyber defenders through Google's Fairwind Program while it undergoes US government pre-release testing; Google has not announced general availability. The excerpt reports a $7.76 cost on Artificial Analysis's full Intelligence Index, compared with $10.04 for Claude Opus 5.5 and $6.25 for GPT-6 Astra at highest settings. These are evaluation-suite comparisons, not workload quotes; Google's launch pricing is temporarily half rate. Carbon performs strongly but trails Opus 5.5 on the cited coding-agent tests, and its hallucination rate is reported at 11%, up from 4% for Google's previous model. The article links restricted access to tests showing substantial vulnerability-finding and exploit-generation capability. For teams without access, it recommends using available tools such as Gemini 4 Argon and CodeMender, prioritizing known exploited vulnerabilities and easy-to-use flaws, and preparing for short patch windows with automated dependency updates, fuzzing, and network segmentation.

### Source excerpt

Gemini 4 Carbon tops the AI leaderboard but is locked to cyber defenders. What it costs per task, and why developers must patch faster now.

## Unified Hallucination Fuzzing for Multimodal Large Language Models

DevFeed: [Unified Hallucination Fuzzing for Multimodal Large Language Models](<https://devfeed.tech/articles/unified-hallucination-fuzzing-for-multimodal-large-language-models-120071.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.07525>)

Author: Pengfei Zhou, Jiajun Song, Zhiwei Tang, Yixing Ma, Donghui Si, Yuhang Xu, Huiqi Song, Yiyuan Miao, Yichen Qian, Weihua Chen, Wangbo Zhao, Bohan Zhuang, Jiasheng Tang, Yang You

Published: 2026-11-06T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Hallucination detection](<https://devfeed.tech/topics/hallucination-detection.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [rlhf](<https://devfeed.tech/topics/rlhf.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [grounding](<https://devfeed.tech/tags/grounding.md>), [hallucinations](<https://devfeed.tech/tags/hallucinations.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [metric](<https://devfeed.tech/tags/metric.md>), [model](<https://devfeed.tech/tags/model.md>), [model-robustness](<https://devfeed.tech/tags/model-robustness.md>), [multimodal](<https://devfeed.tech/tags/multimodal.md>), [mutation](<https://devfeed.tech/tags/mutation.md>)

### AI overview

The paper presents UniHall, a fine-grained MLLM hallucination dataset organized around Object, Instruction, and Knowledge, and SAMF, a self-adaptive fuzzing framework that uses evolutionary mutations and multimodal-oracle metrics to probe changing inputs. The authors report that leading MLLMs perform significantly worse under fuzzing than in conventional evaluations, suggesting a gap between reasoning ability and factual grounding. They also report that reinforcement-learning alignment can worsen sycophancy in instruction-following tasks, revealing a helpfulness-hallucination trade-off. The evidence here is the abstract, so details of methods and experiments are not available.

### Source excerpt

arXiv:2608.07525v2 Announce Type: replace-cross Abstract: Hallucination remains a persistent challenge for Multimodal Large Language Models (MLLMs), severely limiting their reliability in high-stakes applications. Existing evaluations, predominantly based on static benchmarks, suffer from narrow taxonomical coverage and rapid performance saturation, failing to reflect model robustness in evolving real-world scenarios. To bridge this gap, we present a systematic evaluation framework integrating a comprehensive benchmark with self-evolving stress testing. First, we introduce UniHall, a fine-grained dataset grounded in a unified taxonomy spanning Object, Instruction, and Knowledge dimensions. Second, to address benchmark saturation, we propose Self-Adaptive Multimodal Fuzzing (SAMF), a self-adaptive framework that employs evolutionary mutation strategies to explore the boundaries of model hallucinations. Crucially, to ensure reliable assessment of dynamic inputs, SAMF incorporates a structured metric suite driven by an ensemble of multi-modal oracles. Our extensive experiments reveal that state-of-the-art MLLMs exhibit significant performance degradation under fuzzing compared to conventional settings, exposing a dissociation between reasoning capabilities and factual grounding. Furthermore, we identify a helpfulness-hallucination trade-off, where reinforcement learning alignment inadvertently exacerbates sycophancy in instruction-following tasks. The framework, code and benchmark are available at https://github.com/LanceZPF/EvalHall.

## Uncovering Systematic Blind Spots in Graph Database Testing through Integration and Process-Level Analysis

DevFeed: [Uncovering Systematic Blind Spots in Graph Database Testing through Integration and Process-Level Analysis](<https://devfeed.tech/articles/uncovering-systematic-blind-spots-in-graph-database-testing-through-integration-and-process-level-analysis-120822.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.07754>)

Author: Tinghan Li, Aoyang Fang, Longbin Lai, Zifan Xie, Hongbo Zhao, Yu Shao, Ying Zhang, Pinjia He

Published: 2026-11-06T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [graph-database](<https://devfeed.tech/topics/graph-database.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Data analysis](<https://devfeed.tech/topics/data-analysis.md>)

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [database](<https://devfeed.tech/tags/database.md>), [defect](<https://devfeed.tech/tags/defect.md>), [defects](<https://devfeed.tech/tags/defects.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [graph-database](<https://devfeed.tech/tags/graph-database.md>), [integration](<https://devfeed.tech/tags/integration.md>), [process](<https://devfeed.tech/tags/process.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Integrating eight graph database testing methods exposed two practical blind spots: 12 hours of testing generated thousands of reports, mostly false positives from dialect or pattern-matching differences, with many remaining reports duplicated; and optimization made many equivalence-based metamorphic test cases unable to detect defects. GraphWeave addresses these issues with rules for filtering and adapting reports, plus plan-aware triage that skips metamorphic pairs sharing a plan on the same graph state. Applied to NeuG, it found 19 previously unknown bugs, all confirmed, with modest manual effort.

### Source excerpt

arXiv:2611.07754v1 Announce Type: new Abstract: Graph databases are becoming foundational infrastructure for connected data, and a growing body of automated testing techniques has uncovered many bugs across mature graph database systems. Each technique checks a different aspect of correctness and exposes a different class of defect. Combining them is the natural next step, but each technique is judged by the real bugs it finds, not by useless reports or tests that can never fail, and that is what decides whether a developer can afford to fix the problems. To identify the remaining gaps, we integrated test capabilities from 8 testing methods and conducted an empirical study of their behavior, during which we found two blind spots. First, 12 hours of testing produce thousands of bug reports, far more than the number of genuine defects a mature database is likely to contain. Most reports are false positives caused by dialect or pattern-matching differences, and many of the remaining reports are duplicates. Second, analysis of process-level data reveals that many equivalence-based metamorphic test cases lose their ability to detect defects because of the optimization mechanism. Based on these findings, we summarize and realize these guidelines in GraphWeave, an integrated testing platform for graph databases. This includes a multi-agent system that analyzes the flood of bug reports to produce gating rules for issue filtering and adapter rules for dialect adaptation, and a plan-aware triage routes metamorphic pairs by plan, skipping those that share a plan on the same graph state and therefore cannot detect defects. We apply GraphWeave to NeuG, a recently open-sourced industrial graph database that has not been covered by prior graph database testing work. With modest manual effort, GraphWeave uncovers 19 previously unknown bugs, all of which have since been confirmed.

## Bug2Scenario: Root-Cause-Preserving Test Scenario Amplification for Autonomous Driving Software

DevFeed: [Bug2Scenario: Root-Cause-Preserving Test Scenario Amplification for Autonomous Driving Software](<https://devfeed.tech/articles/bug2scenario-root-cause-preserving-test-scenario-amplification-for-autonomous-driving-software-118070.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06229>)

Author: Yuchen Cao, Zhenyu Mao, Jacky Wai Keung, Yifei Wang, Yihan Liao, Jingyu Zhang

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [autonomous vehicles](<https://devfeed.tech/topics/autonomous-vehicles.md>)

Tags: [actor](<https://devfeed.tech/tags/actor.md>), [autonomous-driving](<https://devfeed.tech/tags/autonomous-driving.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [llm](<https://devfeed.tech/tags/llm.md>), [manual-review](<https://devfeed.tech/tags/manual-review.md>), [root](<https://devfeed.tech/tags/root.md>), [route](<https://devfeed.tech/tags/route.md>), [simulator](<https://devfeed.tech/tags/simulator.md>), [software](<https://devfeed.tech/tags/software.md>), [test](<https://devfeed.tech/tags/test.md>), [weather](<https://devfeed.tech/tags/weather.md>)

### AI overview

Bug2Scenario turns autonomous-driving software failures found by simulation fuzzing into candidate regression scenarios designed to preserve the original root cause. It extracts a causal pattern from scenario data, execution traces, and oracle evidence; an LLM proposes semantic variations across actors, missions, routes, and weather; deterministic rules generate DriveFuzz-compatible scenarios; and execution evidence plus manual review assess whether the cause persists. In matched evaluations across six LLM backbones, strict preservation increased by 6.7 percentage points, a result that was not statistically significant (p=0.104); boundary-inclusive preservation increased by 10.6 points (p=0.011). Feedback helped some initially unsuccessful seeds produce a strictly preserved candidate, and seed-level stopping reduced further API calls and simulator runs. Failures remained due to actor-placement constraints, simulator instability, and incomplete or conflicting causal evidence.

### Source excerpt

arXiv:2611.06229v1 Announce Type: new Abstract: Simulation-based fuzzing exposes autonomous driving system (ADS) failures by repeatedly mutating and executing scenarios, but converting one failure into reusable regression scenarios remains difficult. Such variants test whether the mechanism persists after software changes, for example by varying weather or actor placement while retaining a collision's actor-route conflict. We present Bug2Scenario, a root-cause-guided post-fuzzing framework. From scenario data, traces, and oracle evidence, it extracts a root-cause pattern. An LLM proposes semantic variations over actors, missions, routes, and weather. Deterministic rules construct DriveFuzz-compatible scenarios. Execution evidence and manual review assess preservation. Separating these responsibilities prevents fluency, syntax, or recurring labels from masquerading as causal evidence. Under matched seeds, six LLM backbones, candidate budget, and execution pipeline, Bug2Scenario improves strict preservation by 6.7 percentage points (p=0.104; not significant) and boundary-inclusive preservation by 10.6 points (p=0.011). Feedback helps some initially unsuccessful seeds yield a strictly preserved candidate. Seed-level stopping then avoids further API calls and simulator runs. Remaining failures reflect actor-placement constraints, simulator instability, and incomplete or conflicting causal evidence. Bug2Scenario thus produces reliable ADS regression assets. Our implementation is available at https://github.com/YgcCoder/Bug2Sce.

## Keeping Fuzzers on Duty: Repairing Fuzzing Build Breakages in Continuous Open-Source Fuzzing

DevFeed: [Keeping Fuzzers on Duty: Repairing Fuzzing Build Breakages in Continuous Open-Source Fuzzing](<https://devfeed.tech/articles/keeping-fuzzers-on-duty-repairing-fuzzing-build-breakages-in-continuous-open-source-fuzzing-118075.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06358>)

Author: Zhuang Zhao, Jiongchi Yu, Yao Zhang, Dongge Liu, Qiang Hu, Xiaohong Li, Yang Liu

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [patches](<https://devfeed.tech/topics/patches.md>), [builds](<https://devfeed.tech/topics/builds.md>), [open source maintenance](<https://devfeed.tech/topics/open-source-maintenance.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [build](<https://devfeed.tech/tags/build.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [repair](<https://devfeed.tech/tags/repair.md>), [security-testing](<https://devfeed.tech/tags/security-testing.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

FuzzMedic repairs OSS-Fuzz build breakages through evidence-guided diagnosis across project and fuzzing-infrastructure artifacts. It tracks workspace changes and build feedback in a repair-state graph, using branching and rollback to recover from unproductive repair paths. Candidate patches must restore executable fuzz targets, not just silence build failures. On 128 reproducible failures drawn from 1,820 real-world failures, it achieved a 48.44% repair rate and outperformed three program-repair baselines. In real-world use, 29 patches were merged upstream or into OSS-Fuzz, including fixes for three failures unresolved for over a year and two that had never built successfully.

### Source excerpt

arXiv:2611.06358v1 Announce Type: new Abstract: Continuous fuzzing platforms such as OSS-Fuzz provide sustained security testing for open-source projects, but long-term build breakages reduce security coverage and waste infrastructure resources. In OSS-Fuzz, around 20% of integrated projects remain in build-failure states, leaving their fuzzers off duty. These failures expose a maintenance gap between platform maintainers, who lack project-specific context, and project maintainers, who often lack fuzzing and infrastructure expertise. Existing program-repair techniques cannot be directly applied because fuzz build breakages span evolving project and infrastructure artifacts and require repeated infrastructure-aware diagnosis. We present FuzzMedic, an automated agent for fuzz build repair. FuzzMedic performs evidence-guided diagnosis across project and fuzzing-infrastructure artifacts. It explores repairs over a repair-state graph (RSG) that records the evolving workspace and build feedback. Branching and rollback enable FuzzMedic to recover from unproductive repair paths during long-horizon debugging. Candidate patches are validated to restore executable fuzz targets rather than merely suppress build failures. We evaluate FuzzMedic on 128 reproducible OSS-Fuzz build failures extracted from 1,820 real-world failures. FuzzMedic achieves a 48.44% repair rate and outperforms three representative program-repair baselines. In real-world use, it produces 29 patches merged into upstream or OSS-Fuzz main branches, including repairs for three failures that had remained unresolved for more than one year and two cases that had never built successfully.

## A thousand fewer paths to root

DevFeed: [A thousand fewer paths to root](<https://devfeed.tech/articles/a-thousand-fewer-paths-to-root-118572.md>)

Original publisher: [Read original article](<https://openai.com/index/a-thousand-fewer-paths-to-root>)

Published: 2026-11-04T08:00:00Z

Content type: news

Language: en

Sources: [OpenAI News](<https://devfeed.tech/sources/openai-news.md>)

Topics: [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>)

Tags: [0-day](<https://devfeed.tech/tags/0-day.md>), [1-5](<https://devfeed.tech/tags/1-5.md>), [2026](<https://devfeed.tech/tags/2026.md>), [about](<https://devfeed.tech/tags/about.md>), [account](<https://devfeed.tech/tags/account.md>), [accounting](<https://devfeed.tech/tags/accounting.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [fewer](<https://devfeed.tech/tags/fewer.md>), [found](<https://devfeed.tech/tags/found.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-kernel](<https://devfeed.tech/tags/linux-kernel.md>), [local](<https://devfeed.tech/tags/local.md>), [local-privilege-escalation](<https://devfeed.tech/tags/local-privilege-escalation.md>), [openai](<https://devfeed.tech/tags/openai.md>), [patches](<https://devfeed.tech/tags/patches.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [privilege-escalation](<https://devfeed.tech/tags/privilege-escalation.md>), [root](<https://devfeed.tech/tags/root.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

An autonomous pipeline found and validated Linux kernel flaws, assessed exploitability, generated candidate patches, and sent results for human review. In its mid-October 2026 run, it reproduced 1,724 of 2,308 candidate findings and produced 948 distinct local privilege escalation exploits, at an API cost of about $1.21 million. The workflow narrowed review to reachable, security-relevant code, reproduced candidates in isolated virtual machines, then tested exploits with standard Linux protections enabled. Human review caught cases where successful exploits used a different vulnerability than the assigned one, prompting an independent check of each exploit path. Patch quality also required iteration to address completeness, coding conventions, and potential performance effects. The authors report that rapid upstream patching made revalidation against current code important. In a separate hardened kernelCTF environment, the pipeline generated 21 LPE exploits at roughly $32,936; potential bounty comparisons are hypothetical and depend on acceptance. The authors present costs as specific to this evaluation and possibly reducible through harness improvements.

### Source excerpt

OpenAI built an autonomous pipeline that found, validated, and generated patches for 948 local privilege-escalation vulnerabilities in the Linux kernel.

## EMBERS: Empirically Motivated Robustness Testing of Deep Research Systems via Defect-Guided Fuzzing

DevFeed: [EMBERS: Empirically Motivated Robustness Testing of Deep Research Systems via Defect-Guided Fuzzing](<https://devfeed.tech/articles/embers-empirically-motivated-robustness-testing-of-deep-research-systems-via-defect-guided-fuzzing-116832.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.03723>)

Author: Shuochuan Li, Zan Wang, Dong Wang, Yuhang Jiang, Huajin Cui, Chen Zhang, Gang Wang, Junjie Chen

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [autonomous-agents](<https://devfeed.tech/tags/autonomous-agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [deep-research](<https://devfeed.tech/tags/deep-research.md>), [diversity](<https://devfeed.tech/tags/diversity.md>), [dr](<https://devfeed.tech/tags/dr.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [framework](<https://devfeed.tech/tags/framework.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-assisted](<https://devfeed.tech/tags/llm-assisted.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [performance](<https://devfeed.tech/tags/performance.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

EMBERS tests robustness weaknesses within Deep Research systems by fuzzing their multi-stage execution. An empirical study of 1,932 trajectories from three systems identified nine recurring defects in subquestion formulation, web search, and final reasoning. Starting from correctly answered questions, EMBERS applies defect-guided mutations, web-search-assisted fidelity checks, and diversity-aware seed maintenance to generate stage-targeted tests. Across 16 framework-model-dataset settings, it found failures at 3.21 times the throughput of the strongest baseline under equal testing budgets. Human and LLM-assisted evaluations found that most generated inputs retained the original information need and constraints; fine-tuning experiments also showed improved consistent-answer performance.

### Source excerpt

arXiv:2611.03723v1 Announce Type: cross Abstract: Deep Research (DR) systems extend large language models into autonomous agents that decompose complex information needs, iteratively search the web, and synthesize evidence to answer challenging questions. However, their multi-stage execution may introduce robustness risks, as variations in user questions or intermediate search inputs may propagate across research stages and lead to incorrect answers. Existing evaluations focus on task-solving capabilities or robustness against external evidence disturbances, leaving intrinsic weaknesses in DR execution insufficiently explored. Thus, we conduct an empirical study of 1,932 execution trajectories from three representative DR systems and identify nine recurring defect categories across subquestion formulation, online search, and final reasoning. Guided by these findings, we propose EMBERS, an empirically motivated, defect-guided fuzzing framework for robustness testing of DR systems. Starting from correctly answered seed questions, EMBERS generates stage-targeted test inputs using defect-guided mutation, web-search-assisted fidelity assurance, and diversity-aware seed maintenance. Experiments across 16 framework--model--dataset settings show that EMBERS achieves 3.21 times the failure-discovery throughput of the strongest baseline under identical testing budgets. Human and LLM-assisted evaluations demonstrate that most generated inputs preserve the original information need and necessary contextual constraints. Moreover, model fine-tuning experiments show consistent-answer performance improvement, highlighting their value for robustness testing and model improvement.

## Towards Effective Fuzzing of EDK2 Components

DevFeed: [Towards Effective Fuzzing of EDK2 Components](<https://devfeed.tech/articles/towards-effective-fuzzing-of-edk2-components-116135.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.03854>)

Author: Datta Manikanta Sri Hari Danduri, Connor Everett Glosner, Aravind Machiry

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Mocking](<https://devfeed.tech/topics/mocking.md>)

Tags: [bootloader](<https://devfeed.tech/tags/bootloader.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [drivers](<https://devfeed.tech/tags/drivers.md>), [firmware](<https://devfeed.tech/tags/firmware.md>), [framework](<https://devfeed.tech/tags/framework.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [large-language-model](<https://devfeed.tech/tags/large-language-model.md>), [llm](<https://devfeed.tech/tags/llm.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [static-analysis](<https://devfeed.tech/tags/static-analysis.md>), [tianocore](<https://devfeed.tech/tags/tianocore.md>), [uefi](<https://devfeed.tech/tags/uefi.md>), [user](<https://devfeed.tech/tags/user.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Metis fuzzes edk2 boot-time protocols by rehosting them as user-space applications and injecting inputs through both protocol interfaces and their dependencies. It uses Direct-dependency Component Rehosting to create semantically meaningful dependency mocks, with static analysis and LLM-guided synthesis to generate and refine harnesses. Implemented on HBFA, it was evaluated on 60 drivers covering 162 protocols, achieving 73.1% coverage--about 1.7 times FuzzUEr's--and finding 137 previously unknown bugs. The authors report 26 to vendors, including 12 remotely triggerable bugs; vendors acknowledged all 26 reported vulnerabilities.

### Source excerpt

arXiv:2611.03854v1 Announce Type: new Abstract: Securing bootloaders is critical to establishing the trusted computing base of modern systems. TianoCore's edk2, the de facto UEFI-based bootloader, is widely deployed but has recently been shown to contain numerous high-severity vulnerabilities. Existing approaches either focus on post-boot interfaces or rely on heavyweight simulation, limiting their scalability, throughput, and coverage of boot-time components. We present Metis, an automated technique for fuzzing edk2 protocols (i.e., boot-time interfaces) by rehosting them as user-space applications. Our key insight is that effective fuzzing must exercise not only protocol interfaces but also their dependency interactions, which serve as additional input channels. Metis employs a Direct-dependency Component Rehosting (DCR)-based strategy to construct semantically meaningful mocks for dependencies, enabling controlled input injection across all channels. It further leverages a hybrid approach combining static analysis and Large Language Model (LLM)-guided synthesis to generate and refine fuzzing harnesses. We implement Metis on the Host Based Firmware Analyzer (HBFA) framework and evaluate it on 60 drivers covering 162 protocols. Metis achieves 73.1% coverage, approximately 1.7 times higher than FuzzUEr, the state-of-the-art edk2 fuzzing technique, and discovers 137 previously unknown bugs. We have already reported 26 of them, including 12 that are remotely triggerable, and all reported vulnerabilities have been acknowledged by the vendors.

[Next page](<https://devfeed.tech/topics/fuzzing.md?cursor=WyIyMDI2LTExLTA0VDA1OjAwOjAwKzAwOjAwIiwgIjc3ODRjZTdlLWIwYmMtNDdlZS1hN2M1LTEyNWIyYjcyYmQxYiJd>)