Presentation: RIIIR: Rewrite It In Idiomatic Rust (with AI)
Rust co-designer Nicholas Matsakis introduced Symposium and the Agent Client Protocol to standardize AI coding agents across enterprise development stacks.
By Dillip Chowdary • Nov 19, 2026 • Source: InfoQ

At a glance
- Speaker
- Nicholas Matsakis
- Platform
- Symposium
- Protocol
- Agent Client Protocol
- Host organization
- Rust Foundation
- Benchmark scale
- 1,000,000 lines of code
In this post
Nicholas Matsakis, a lead designer of the Rust programming language and senior principal engineer at Amazon, presented a new framework for pairing artificial intelligence coding agents with Rust at QCon AI. In InfoQ's report on the address, Matsakis detailed Symposium, an open-source toolchain backed by the Rust Foundation, alongside the Agent Client Protocol designed to standardize agent-to-tool integrations.
The presentation examines how automated coding agents neutralize the traditional learning curve of Rust by using strict compiler checks as operational guardrails. It addresses software architects, systems engineers, and technical leads evaluating language transitions for high-throughput enterprise infrastructure, automated legacy rewrites, and interoperable developer tooling.
01Compiler type guardrails for artificial intelligence
Engineers historically avoided Rust due to steep onboarding periods that typically demanded six to twelve weeks to master the ownership system. Autonomous artificial intelligence agents bypass this human adoption barrier because models absorb Rust syntax and borrow rules during pre-training and reinforcement learning. Organizations can immediately deploy agents into production codebases without waiting for engineering teams to climb that initial curve.
The language enforces rigorous static verification that prevents common runtime defects before code executes. OpenAI co-founder and president Greg Brockman highlighted that Rust serves as a natural fit for artificial intelligence generation because code that passes the compiler is approximately correct. Strong typing provides automated agents with tight boundaries, catching invalid memory accesses and incorrect assumptions at build time.
This dynamic fundamentally shifts how engineering managers evaluate language selection for mission-critical services. Instead of choosing dynamic languages like TypeScript solely for faster hiring cycles, teams can rely on artificial intelligence agents to generate high-performance systems code. The compiler transforms into an automated supervisor that guarantees consistency across machine-generated pull requests.
02Kernel execution and cloud service infrastructure
Rust operates across a wide functional spectrum, scaling from operating system kernels to terminal-based user interfaces. It stands alongside C as the only language permitted in the Linux kernel and has secured implementation within Microsoft Windows kernel components. At the application layer, libraries such as Ratatui demonstrate that the ecosystem supports responsive text consoles alongside hardware oscilloscopes.
Infrastructure operators increasingly migrate high-load services to eliminate garbage collection overhead and lower hosting costs. Developers recently ported codex-rs from TypeScript over to Rust to capture efficiency and reduce memory footprint. Amazon initially deployed the language across compute bottlenecks in Amazon S3, Amazon EC2, and AWS Lambda before expanding adoption across broader architectures.
Database systems highlight the progression from localized performance patches to end-to-end implementation. Amazon Aurora DSQL, a distributed serverless database, initially evaluated the language for performance-critical bottlenecks before writing its data plane, control plane, and PostgreSQL bindings entirely in Rust. This end-to-end integration reduced execution overhead while ensuring consistent memory safety across all layers.
| Language | Target environment | Memory model |
|---|---|---|
| C | Linux kernel, Microsoft kernel | Manual allocation |
| C++ | Enterprise applications | Manual allocation |
| TypeScript | Web tools, original codex-rs | Garbage collected |
| Rust | Linux kernel, AWS DSQL, Ratatui | Compile-time ownership |
Advertisement
Tech Pulse Daily
Get tomorrow's pulse first
Join engineers who read Tech Pulse before stand-up. Free, weekday mornings.
03Large codebase rewrites across enterprise systems
Automated translation allows enterprises to undertake mass language migrations that previously required decades of manual engineering. Microsoft launched research initiatives evaluating single-engineer migrations covering one million lines of code using artificial intelligence agents. Meanwhile, the Bun runtime project executed a production migration converting one million lines of code from Zig directly to Rust.
Accelerated modernization removes systemic vulnerabilities found in legacy codebases without compromising delivery velocity. Memory-unsafe languages like C and C++, along with runtime environments that depend on dynamic reflection, introduce attack surfaces that organizations face increasing pressure to eliminate. Automated code agents complete conversions within weeks or months, delivering memory safety across systems that resisted manual refactoring.
Note: Amazon and peer technology companies have launched internal migration experiments with notable success rates, though Matsakis was not cleared to share specific proprietary program metrics. These internal initiatives reflect industry-wide momentum where major engineering organizations test automated rewrites across complex production codebases.
04Extensible toolchains over closed vendor silos
Current artificial intelligence development workflows suffer from fragmented, closed platforms. Artificial intelligence vendors such as Anthropic and OpenAI build monolithic software suites that attempt to resolve every engineering task internally. This walled-garden design prevents outside developers from easily plugging custom tools, linters, or verification pipelines into standard agent workflows.
Modern software engineering requires collaborative ecosystems where third-party extensions interoperate cleanly across different model runtimes. Rather than relying on a single provider to supply every diagnostic and transformation utility, development teams need modular hooks. An extensible foundation enables specialized domain tools to interact directly with code-generation models across varied corporate environments.
Standardizing these communication boundaries mirrors the evolution of earlier development protocols that decoupled code analysis from specific text editors. By opening the integration layer, development organizations can combine proprietary testing engines with diverse agent providers. This modular architecture allows engineering teams to tailor toolchains without vendor lock-in.
05Open agent mods on Agent Client Protocol
The Rust Foundation introduced Symposium to establish an open-source platform for modular agent extensions. Created by Matsakis, the project targets existing friction points in developer environments by giving teams standardized infrastructure for running agent modifications. The architecture establishes a vendor-neutral foundation where automated tools coordinate tasks across local repositories and remote services.
Symposium relies on the Agent Client Protocol to standardize communication between artificial intelligence agents and external developer utilities. The protocol defines uniform interfaces, allowing diverse development environments to attach tools without custom integrations for each vendor. This specification ensures enterprise teams can connect repository analyzers, compilers, and specialized linters into agent workflows.
Standardized client protocols enable community developers to build reusable extensions that function across any compliant agent platform. By decoupling the interface from individual artificial intelligence providers, the standard fosters an open marketplace of development utilities. Engineering teams gain the flexibility to integrate custom verification checks into daily development cycles.
Frequently asked questions
Why is Rust considered effective for artificial intelligence coding agents?
AI agents learn Rust syntax and safety rules during training, skipping the human learning curve. Compiler checks provide strict guardrails that catch invalid memory references and runtime flaws before code runs.
What is Symposium and who developed it?
Symposium is an open-source platform for agent modifications developed by Nicholas Matsakis and backed by the Rust Foundation. It enables developers to build and share modular extensions for automated programming agents.
What role does the Agent Client Protocol play in development workflows?
The Agent Client Protocol standardizes communication between artificial intelligence agents and external development utilities. It replaces monolithic vendor toolchains with an open interface that lets third-party tools connect to diverse agent models.
Which companies are testing large automated codebase migrations to Rust?
Microsoft evaluated single-engineer migrations covering one million lines of code with AI, while Bun migrated one million lines from Zig to Rust. Amazon and other technology companies are running similar automated migration experiments across production systems.
Sources
Author
Dillip Chowdary
Writes Tech Bytes coverage of AI, engineering, and the tools that actually ship. Editor of Tech Pulse Daily.
Related on Tech Bytes
Advertisement