JetBrains Unveils Symposium: Smarter Rust Coding Agents

Nico Matsakis began exploring AI to understand the hype around it, quickly realizing its potential as a powerful educational tool.

AI agents can effectively gauge a user's current knowledge level, making them valuable for learning new concepts.

The inherent complexity and steep learning curve of Rust present a unique opportunity for AI assistance, as it can help developers build things they previously couldn't.

Traditional computers are known for their speed, precision, and efficiency in mathematical operations.

Large Language Models (LLMs), however, are inefficient, slow, and frequently make calculation errors.

Conversely, LLMs excel at tasks previously considered impossible for computers, such as summarizing, assessing, and making nuanced judgments.

The team observed that strategies effective in helping humans code also prove successful in assisting LLMs with coding tasks.

Rust is often perceived as a difficult language because it exposes many complex implementation details to developers.

Developers frequently encounter scenarios where multiple valid choices exist, such as deciding between Arc and Rc, or enum and trait.

Compiler messages struggle to provide sufficient help without overwhelming users with excessive information.

The development team prioritizes tailored guidance over exhaustive documentation to avoid user overload.

There is significant frustration with current AI coding tools that are built as 'all-in-one' integrated monoliths.

The core objective is to decouple front-end UI, context injection, and caching strategies for greater flexibility.

Symposium aims to open up the agent workflow, allowing customization rather than dictating the entire development experience.

The project has evolved into a lightweight, modular approach designed to integrate seamlessly with existing agent environments.

Symposium evaluates a project's `Cargo.toml` file to identify and propose relevant plugin installations based on established dependencies.

This capability allows crate authors to directly improve the user experience for those coding against their dependencies.

Users gain more autonomy over their toolsets by reducing the necessity for AI agent vendors to curate specific integrations.

The system creates a direct link between the broader library ecosystems and coding agent assistance, streamlining development.

Symposium is evolving from a crate-aware system to a dependency-aware one, supporting diverse project types such as Python and npm.

Crate authors and third-party contributors can utilize a recommendations repository to suggest useful plugins for specific dependencies.

The system automatically identifies optimal coding patterns by analyzing project dependencies.

An example project, air-formality, was mentioned in the demonstration of this capability.

The initial focus on building agents based on crate examples proved less important as model capabilities advanced.

A critical factor identified for agents is their significantly improved performance when given a specific path to version-matched source code.

Misalignments between an agent's understanding and the actual source code versions frequently lead to errors.

The Rust Token Killer (RTK) is envisioned as a global plugin designed to automatically reduce token usage in AI agent interactions.

Symposium's architecture supports both workspace-specific and global environment optimizations, enhancing flexibility for developers.

Developers recognize that token efficiency and output compression are crucial for optimizing AI agent performance.

The concept of a recommendations repository is compared to TypeScript's '@types' packages, which add type definitions to existing JavaScript projects.

This repository can host plugins for popular crates like Serde, even if these crates do not natively provide Symposium skills.

It allows the community to define and share useful patterns for crates that do not ship their own AI-compatible plugins.

This approach enables broader integration and customization of AI agent assistance across the Rust ecosystem.

Symposium explicitly instructs AI agents, such as Claude, to use `cargo add` for dependency management, ensuring up-to-date packages.

Traditional LLM training data often leads to suggestions of outdated or incorrect dependencies.

Automated hooks within Symposium ensure that the AI adheres to project-specific rules, including proper macro notations in projects like 'formality-core'.

Users are prompted to confirm the installation of skills once for each new package, streamlining the process.

After initial approval, subsequent installations for that package are automated across the entire workspace.

Symposium developers acknowledge the significant supply chain attack surface created by allowing arbitrary code execution via installed skills.

The team is actively collaborating with the Rust Foundation's Innovation Lab to scan packages on crates.io for potential vulnerabilities.

Future defense layers will include advanced scanning capabilities to detect malicious behavior within agent skills.

Symposium automatically mirrors these skills to tool-specific paths, such as `.claude/skills`, ensuring agent access.

Shipping skills directly within a crate's source code ensures they remain easily discoverable for project users.

The existing 'Rust best practices' skill is currently minimal, prompting ongoing development efforts.

Work is underway to create async-specific plugins that utilize custom predicates for activation.

The goal is to offer targeted guidance on modern Rust features, addressing issues like blocking code and the use of unsafe blocks.

Symposium employs an 'LLM as judge' methodology for benchmarking the effectiveness of its skills.

Task evaluation involves comparing model performance with and without specific plugins enabled.

This evaluation tool has demonstrated a 66% improvement in specific scenarios.

The `eval.json` file convention provides a structured way to define tasks and judge their completion quality.

While initially focused on Rust, Symposium employs a predicate-based design to support various ecosystems, including Python and npm, with plans to standardize plugin management across languages.

The system utilizes a predicate-based approach to manage dependencies and complex integrations across different languages.

It supports hooks and MCP servers, providing specialized advice for interacting with multiple crates or tools.

The team plans to develop plugin managers for various languages to standardize this behavior across the industry.

Even with hypothetically 'infinitely good' AI models, they cannot inherently know a team's specific stylistic or project setup preferences.

Symposium empowers users to embed their own opinions and organizational standards directly into the agent's workflow.

The project facilitates loading global or project-specific skills that standardized AI models might otherwise overlook.

Its success is measured by its ability to steer AI agents towards better conventions, even if the platform is eventually superseded by industry standards.

The community aims to standardize the extraction and exposure of existing information rather than enforcing specific styles via skills.

Integrating such specialized skills will likely be limited to a select subset of crates that possess unique idiomatic or complex style requirements.

The team is focused on enhancing tools like Clippy or Cargo to identify common 'foot guns' in asynchronous Rust code.

AI agents have the potential to filter out high-noise programmatic lints, allowing developers to focus on critical issues.

There is potential to use agents to drive formal proofs of correctness for core libraries.

The ultimate goal is to transition from human-managed debugging to more efficient, machine-assisted verification processes.

They help new users navigate the complexity of the vast crates.io ecosystem.

As AI agents increasingly select project dependencies, these curated packs ensure the adoption of higher-quality defaults.

Battery packs facilitate faster ecosystem evolution by amplifying new and recommended tools, guiding AI-assisted coding decisions.