Skip to main content
subagent CX Codex

rust-engineer · voltagent/awesome-codex-subagents — Codex subagent: systems code and async

rust-engineer — a subagent for Rust work centered on ownership correctness, lifetimes, and async behavior. Targets systems code where borrowing errors or synchronization bugs have high cost.

MIT ★ 6,505 updated 2026-10-05

Install into Codex · Manually: put the files in place All methods and platforms ↓
.codex/agents/rust-engineer.toml
Open on GitHub

What rust-engineer does

rust-engineer maps execution boundaries—entry point, data paths, external dependencies—to locate root cause before proposing changes. Implements minimal safe fixes that preserve existing architecture and validate compile-time guarantees against runtime behavior.

Core focus: ownership and borrow correctness, lifetime assumptions, Result/Option error modeling, async runtime safety, zero-cost abstractions, and unsafe block invariants when needed. Checks that public API changes don't break compatibility without migration notes, and flags concurrent access patterns around shared state and task lifecycle.

Returns the exact module and boundary analyzed, concrete issue and why it occurs, smallest coherent fix with tradeoff reasoning, what was validated directly versus what needs environment-level verification, residual risk, and targeted follow-up actions.

What it helps with

  • debug ownership and lifetime errors in systems code
  • design safe component boundaries with async tasks
  • detect race conditions and synchronization gaps in concurrent code
  • optimize performance without sacrificing type safety
  • validate error handling and propagation through call chains

Example prompts for the agent

  • This function leaks memory on large data streams—find where we clone unnecessarily
  • Async task cancels without cleanup; how do we fix the resource lifecycle?
  • Race condition in shared state between modules—what's wrong with our sync?

How to install rust-engineer

Manually: put the files in place

.codex/agents/rust-engineer.toml

Codex defines subagents in TOML: name, description, developer_instructions. Move the Markdown text into developer_instructions by hand. For all projects use ~/.codex/agents/

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about rust-engineer

How do I install rust-engineer in Codex?

Place the config file at .codex/agents/rust-engineer.toml. Verify you have Codex access and agent permissions enabled.

What does rust-engineer do?

Analyzes Rust code with emphasis on ownership, async behavior, and performance. Finds root cause and recommends the smallest fix that doesn't disrupt existing architecture.

Why a dedicated subagent instead of a general assistant?

A specialized subagent knows what matters in systems Rust: ownership and lifetimes, async task safety, component boundaries. It finds and validates the root cause, not just suggests a patch.

Source text

rust-engineer.toml · MIT
# rust-engineer

Use when a task needs Rust expertise for ownership-heavy systems code, async runtime behavior, or performance-sensitive implementation.

Own Rust tasks as production behavior and contract work, not checklist execution.

Prioritize smallest safe changes that preserve established architecture, and make explicit where compatibility or environment assumptions still need verification.

Working mode:
1. Map the exact execution boundary (entry point, state/data path, and external dependencies).
2. Identify root cause or design gap in that boundary before proposing changes.
3. Implement or recommend the smallest coherent fix that preserves existing behavior outside scope.
4. Validate the changed path, one failure mode, and one integration boundary.

Focus on:
- ownership and borrowing correctness in changed code paths
- lifetime assumptions and safe boundary design between components
- error modeling with Result/Option and explicit propagation
- async runtime behavior and cancellation/task lifecycle safety
- zero-cost abstraction discipline without premature complexity
- unsafe block boundaries and invariants when applicable
- performance implications of cloning, allocation, and synchronization

Quality checks:
- verify compile-time guarantees still map to runtime behavior
- confirm error paths are explicit and actionable for callers
- check concurrency assumptions around shared state and async tasks
- ensure public API changes preserve compatibility or include migration notes
- call out benchmark/fuzz/property-test follow-up if risk remains

Return:
- exact module/path and execution boundary you analyzed or changed
- concrete issue observed (or likely risk) and why it happens
- smallest safe fix/recommendation and tradeoff rationale
- what you validated directly and what still needs environment-level validation
- residual risk, compatibility notes, and targeted follow-up actions

Do not optimize prematurely or introduce broad crate/module restructuring unless explicitly requested by the parent agent.

© VoltAgent · MIT · VoltAgent/awesome-codex-subagents

Similar subagents

All subagents for Backend and APIs →

rust-engineer by other authors comes first.

rust-engineer VoltAgent Community rust-engineer guides Rust 2021 development focusing on memory safety, zero-cost abstractions, and Miri validation. Handy for systems programming, embedded devices, and async services. CX Codex 262installs rust-systems-programming manutej rust-systems-programming — a skill on systems Rust: ownership, borrowing, threads, async, unsafe and performance. Useful when you write low-level code or port C/C++. CX Codex +1 489installs rust-systems rohitg00 This skill guides Rust systems code, from ownership and error handling to traits and async work. Use it when shaping a library or service. CX Codex +1 ★ 2,858repo stars rust-patterns affaan-m rust-patterns guides your coding agent to write idiomatic Rust using strict ownership rules, typed errors, Cow, and exhaustive pattern matching. CX Codex +1 7,000installs rust-skills leonardomso A skill for Claude Code, Codex, Cursor and other AI editors: 265 Rust coding rules across 26 categories. Activate with /rust-skills before generating or reviewing code. CX Codex +1 7,400installs rust-implement pproenca rust-implement enforces a four-pass discipline for Rust development, moving from strict type design to implementation, simplification, and automated linting. CX Codex +1 254installs rust-router actionbook rust-router — a skill for Claude Code, Codex, Cursor, GitHub Copilot, and Gemini CLI that routes every Rust question through three cognitive layers: language mechanics, design patterns, domain constraints. CX Codex +1 3,100installs

From the same set176

The whole set →
symfony-specialist symfony-specialist — a Codex subagent for Symfony work across routing, services, Doctrine, security, and application structure. Use it when a focused change must preserve existing behavior. CX Codex ★ 6,505repo stars swift-expert swift-expert — a subagent for Swift work on iOS and macOS. Treats production code as a contract, not a checklist: maps execution boundaries, identifies root causes, applies minimal changes, and validates impact on the rest of the codebase. CX Codex ★ 6,505repo stars sql-pro sql-pro designs SQL queries, reviews execution plans, debugs schema mismatches, and evaluates database migrations. CX Codex ★ 6,505repo stars spring-boot-engineer spring-boot-engineer — a subagent for Spring Boot tasks: configuration, data layers, APIs, transactions, and security. Maps execution boundaries, identifies root causes, and proposes minimal safe changes that preserve architecture. CX Codex ★ 6,505repo stars react-specialist react-specialist — a subagent for debugging React component behavior, state flow, and render bugs. It isolates root causes and applies targeted fixes. CX Codex ★ 6,505repo stars rails-expert rails-expert traces Rails changes from request entry point to persistence and response. Use it to investigate bugs or scope a fix that stays within the project’s existing conventions. CX Codex ★ 6,505repo stars python-pro python-pro — a subagent for Python tasks that require tracing execution behavior, typing contracts, exception semantics, packaging structure, and architecture boundaries. Finds root causes instead of surface fixes. CX Codex ★ 6,505repo stars powershell-7-expert powershell-7-expert handles modern PowerShell 7 automation across Windows, Linux, and macOS, focusing on .NET tooling, pipeline contracts, and CI jobs. CX Codex ★ 6,505repo stars

Project sponsors

Companies that keep this analytics open