What Happened
Microsoft FORGE Lab researchers have published findings showing that memory safety issues exist in Rust's core and standard library. The research, led by Yechan Bae and the FORGE Lab team, used advanced agentic tools to identify cases where code that the Rust compiler deems safe can still cause undefined behavior. The study was conducted using Hyenas, a frontier research version of the lab's codename MDASH, and focused on three patterns of misplaced trust in unsafe code.
The work was published on 2026-11-09 and represents a continuation of FORGE Lab's efforts to push the boundaries of Rust's safety guarantees through systematic, AI-assisted security analysis.
How the Research Was Done
Agentic Tools and Hyenas
The team employed agentic tools, AI systems capable of taking autonomous actions, to probe Rust's codebase. Specifically, they used Hyenas, a frontier research tool versioned as MDASH. These tools were designed to explore complex code patterns and identify potential vulnerabilities that traditional static analysis might miss.
Hyenas operate by combining large language models with program execution capabilities, allowing them to reason about code behavior across multiple iterations. In this context, the tool was used to simulate the execution of Rust code and detect when safe constructs (those marked as `unsafe` or relying on unsafe assumptions) actually produce undefined behavior.
Investigating Misplaced Trust
ForGE Lab focused on three key patterns where trust is misplaced in unsafe code:
- Over-optimistic safety assumptions, situations where developers assume a particular memory access pattern is safe, but the underlying implementation violates Rust's guarantees.
- Incomplete abstraction boundaries, cases where higher-level abstractions in Rust's standard library do not fully preserve the safety invariants of their inner components.
- Concurrency and aliasing edge cases, scenarios involving multiple threads or mutable references that the compiler cannot prove are safe, yet the code appears safe to the programmer.
By systematically testing these patterns with Hyenas, the researchers were able to surface memory safety bugs that were previously difficult to detect.
The Findings
Memory Safety Bugs in Rust Core and std
The research uncovered memory safety issues in both the core of Rust (the foundational language implementation) and the standard library (the set of pre-compiled modules that form the backbone of most Rust programs). These bugs include cases where safe Rust code can trigger undefined behavior, a condition that violates Rust's core safety guarantees and can lead to security vulnerabilities or program crashes.
Why This Matters
Rust was designed to provide memory safety without a garbage collector, making it a popular choice for systems programming, embedded development, and security-critical applications. However, the language's safety guarantees are based on the assumption that all `unsafe` code is written correctly and that the compiler's type system catches most errors.
The FORGE Lab findings suggest that even well-intentioned safe code can slip through these assumptions. This has implications for:
- Developer trust, developers relying on Rust's safety guarantees may need to adopt additional verification steps.
- Tooling development, static analyzers and linters may need to be enhanced to catch these edge cases.
- Language design, the results could inform future improvements to Rust's type system or the way `unsafe` blocks are handled.
The Bigger Picture
What This Signals
The use of agentic tools like Hyenas in security research represents a shift toward more automated and scalable vulnerability discovery. Rather than relying solely on manual code review or traditional static analysis, FORGE Lab is exploring AI-assisted approaches that can explore vast code spaces more efficiently.
However, the findings also underscore that Rust's safety guarantees are not absolute. The three patterns identified, over-optimistic assumptions, incomplete abstraction boundaries, and concurrency edge cases, highlight areas where the current system of guarantees can be stretched beyond its limits. This is not a failure of Rust but a reminder that even the most robust type systems have boundaries.
For the African Tech Community
While this research originates from Microsoft and focuses on global software infrastructure, its relevance to the African tech ecosystem is indirect but meaningful. Many African startups and developers rely on Rust for performance-critical applications, from fintech platforms to IoT systems. The discovery of memory safety issues in Rust's core and std libraries underscores the importance of maintaining rigorous testing and verification practices across the global software supply chain. As more developers adopt Rust, understanding these edge cases becomes increasingly important for building secure, reliable systems.
What Remains Unclear
- The exact number and severity of the bugs identified (the source does not provide specific metrics).
- Whether the bugs are isolated to specific versions of Rust or affect the broader ecosystem.
- The long-term impact on Rust's adoption in safety-critical domains.
- How the agentic toolchain (Hyenas/MDASH) will be integrated into future Rust development workflows.
VANTIX Takeaway
FORGE Lab's work demonstrates that even language-level safety guarantees can have real-world cracks when complex systems are built on top of them. The use of agentic tools to systematically probe for these cracks is a promising direction for the future of software security. For developers and organizations relying on Rust, the takeaway is clear: continuous verification and the adoption of AI-assisted analysis may be necessary to maintain trust in Rust's safety promises as the language grows in popularity worldwide.
