
Niko Matsakis used a QCon AI talk to make a broad case for Rust in an AI-heavy development world, arguing that the language’s safety and tooling fit the way coding agents are increasingly being used. He also introduced Symposium, an open-source, agent-oriented toolchain under the Rust Foundation’s Innovation Lab, and outlined the Agent Client Protocol (ACP) as a way to make agent workflows more portable and extensible across tools.
Why Matsakis thinks Rust and AI fit together
Matsakis, one of the lead designers of Rust and a senior principal engineer at Amazon, framed his talk around a shift in how software gets written. In his view, AI changes the economics of language choice: if an agent is doing more of the coding, teams can spend less time worrying about the learning curve that once made Rust a tougher sell.
He described Rust as a language that spans a wide range of use cases, from low-level systems work to application development. He also pointed to the compiler’s guardrails as a major advantage for agent-generated code, especially when the goal is to produce software that is more likely to compile correctly and avoid classes of bugs before they reach production.
From “eat your spinach” to agent guardrails
Matsakis revisited a familiar criticism of Rust: that it can require real investment to learn and adopt. Traditionally, that meant some teams opted for languages with faster onboarding, even if they sacrificed some safety or performance. His argument was that AI changes that calculus because agents already “know” much of Rust from training, which lets human teams skip over some of the upfront pain.
He even cited a line attributed to OpenAI co-founder and president Greg Brockman: Rust is a “perfect language for agents, given that if it compiles, it’s approximately correct.” Matsakis used that sentiment to reinforce his broader point that static checks and compiler feedback become more valuable when code generation accelerates.
The case for Rust is getting stronger, not weaker
During the presentation, Matsakis said Rust is gaining traction not only because of AI-assisted development, but also because of long-running concerns around memory safety and operational efficiency. He noted that Rust is already used in performance-sensitive and systems-level environments, including parts of the Linux kernel and Microsoft’s kernel work, and that the language’s footprint has expanded steadily across infrastructure and application code.
He also argued that the rise of AI does not reduce the importance of reliability. If anything, he said, it raises the stakes because attackers can use AI to search for vulnerabilities faster, especially in codebases written in memory-unsafe languages or languages with heavy dynamic behavior.
Security pressure is part of the story
Matsakis said the industry has long repeated the idea that roughly 70% of vulnerabilities are related to memory safety, and that this pattern has not changed despite static analysis tools and other defenses. In his view, moving to a language that rules out many memory-safety bugs at compile time is a more systematic fix than relying on patching alone.
He also referenced Android’s migration work from C++ to Rust and linked it to a simple pattern: more memory-unsafe code tends to correlate with more memory-safety vulnerabilities. For him, that strengthens the case for Rust in systems that need both speed and a higher baseline of correctness.
Symposium aims to make Rust friendlier to AI agents
The centerpiece of the talk was Symposium, which Matsakis described as an agent-oriented toolchain. It is intended to sit alongside the Rust ecosystem and give agents more structured guidance when they work with Rust projects. He said the goal is to make the experience less dependent on each model’s default behavior and more dependent on explicit, reusable instructions from the ecosystem itself.
At the simplest level, Symposium can guide agents toward current Rust practices. Matsakis said that includes steering them toward Rust 2024 rather than Rust 2021, encouraging the use of cargo add to pick up current crate versions, and running cargo fmt consistently. He presented these as small but important examples of rules that agents do not always follow on their own.
Crate authors can ship guidance with their libraries
Matsakis said a major part of Symposium is giving crate authors a way to package “skills” that help agents use their libraries correctly. He used Toasty, a Rust object-relational mapper created by Carl Lerche, as an example. According to Matsakis, an agent that does not know Toasty well may find a working solution only after wasting time on web searches, outdated versions, or guesswork.
Under Symposium, a crate author can provide agent-facing instructions that are tied to the library itself. Matsakis said this can reduce the risk of agents discovering stale documentation or using old crate versions, because the guidance comes from the package source or a maintained central registry rather than an ad hoc web search.
- skills to explain how to use a crate
- MCP servers to expose auxiliary functionality
- hooks to influence the agent lifecycle
- battery packs, a separate concept for curated library sets and best practices
He said Symposium can also install and configure MCP servers and hooks, and can keep those assets in sync with the dependencies in a project. His broader point was that the Rust ecosystem should help agents do the right thing by default instead of leaving them to improvise.
Battery packs and the push toward opinionated workflows
Beyond per-crate extensions, Matsakis discussed “battery packs,” which he described as curated bundles of libraries and practices for a particular kind of software. These packs can include documentation, skills, MCP servers, and other extensions, all organized around a domain such as network services.
He said this is part of an effort to make it easier for teams to find reliable combinations of tools, especially when there are too many library choices and not enough guidance on how they fit together. He also linked the idea to industry support: if large organizations can surface the libraries they actually use in production, then maintainers and foundation programs can better focus resources and support.
ACP is about portability across agents and interfaces
Matsakis spent a large part of the talk on the Agent Client Protocol, or ACP, which he described as a way to separate the front end the user sees from the agent behind it. The idea is that a user can choose a CLI or GUI, while the actual agent connection happens over a JSON-RPC protocol rather than through a tightly coupled custom integration.
He said ACP was designed to help editors and other client applications work with multiple agents more easily. That, in turn, makes it possible for agents to focus on the model while clients focus on the interface, reducing duplicate work and increasing interoperability.
From editors to newer kinds of clients
According to Matsakis, ACP support is showing up in tools such as Zed, various IntelliJ-family editors, Emacs, Obsidian, and several CLI front ends. He also pointed to newer uses beyond code editing, including systems that connect agents to messaging or backend workflows. His point was that once the interface layer is standardized, more kinds of applications can emerge around it.
He said ACP could also enable “agent mods,” a middleware-like layer that can inspect prompts, augment context, add tools, or even branch off sub-agents. That makes the protocol more than a transport mechanism; it becomes a place where workflow logic can be inserted in a way that is harder to do with today’s more fragmented agent integrations.
What Matsakis wants teams to take away
His recap was simple: use Rust for the next project, especially if AI is part of the workflow; consider Symposium to make agent use more structured; and expect portability to improve, even if it is still messy today. He also acknowledged that there is no perfect answer yet for getting agents to use skills deterministically or for measuring whether a given extension actually helps.
In the Q&A, Matsakis said he is increasingly interested in telemetry and better measurement so teams can evaluate whether agent guidance is really improving outcomes. He also advised teams new to Rust to learn from LLMs by questioning their choices, and to hire Rust experience when possible.
Source: Original report
Was this helpful?
Explore more: Software Development More Software Development Tech News
Last Modified: November 19, 2026 at 10:34 pm
0 views
