rpi: Rust Coding-Agent Runtime

Build, run, and extend coding agents with an embeddable Rust runtime and a terminal CLI.

Stars
★ 116
Last updated
today
License
MIT
Primary language
Rust

At a glance

How it runs
CLILibrary / SDKFramework
Works with
Universal · cross-platformOpenAI API · Claude API
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
Rust 1.78+ for installation from crates.io or building from sourceAnthropic or OpenAI-compatible API credentials for real model useShell / CLINetwork accessLocal filesystem
Typical use
Rust developers embedding an agent in an application and handling its events and output can build on rpi-agent and rpi-ai.
Not a fit if
  • Users who need a desktop app instead of a terminal interface
  • Teams that require local-model operation without configuring an API
Source review
64/100 · Some gaps

What does this agent do, and when should you use it?

rpi is a Rust coding-agent runtime offered as an embeddable SDK and a terminal CLI built on the same implementation. Its nine crates cover Anthropic and OpenAI-compatible providers, the agent loop, tools, session persistence, a terminal UI, and a plugin ABI. The CLI provides an interactive TUI, one-shot prompts, JSON event output, and a headless TCP server mode. Sessions persist as JSONL and can resume after a crash from the last committed frame. It fits Rust developers who want to embed an agent in their own process or customize its tools and plugins; installing the CLI from crates.io or building from source requires Rust 1.78+, while real model calls need the relevant API credentials.

The CLI accepts prompts in an interactive terminal session, runs one-shot tasks with -p, or emits a machine-readable event stream with --mode json. rpi-agent configures the model, system prompt, and stream function through AgentBuilder, then runs an agent loop that invokes AgentTools. rpi-tools supplies read, write, edit, bash, and other tools through the ExecutionEnv seam. rpi-ai supports Anthropic, OpenAI-compatible, and deterministic faux providers. rpi-harness persists sessions as JSONL and handles recovery. Extensions can register tools, providers, commands, and event handlers through the stable C ABI in rpi-plugin-sdk. A TCP server can also run the agent for a remote TUI client.

  1. Rust developers embedding an agent in an application and handling its events and output can build on rpi-agent and rpi-ai.
  2. Developers who want an interactive terminal agent or prompt-driven one-shot tasks can run the rpi CLI.
  3. Teams that need resumable agent sessions can use JSONL persistence and crash recovery.
  4. Extension authors building distributable Rust plugins can register tools, providers, or event handlers through rpi-plugin-sdk.
  5. Users who want the agent on a remote host and only a terminal client locally can start --server and connect with --connect.

How do you install or deploy this agent?

Install a prebuilt binary without a Rust toolchain; the installer verifies its SHA-256 checksum. Alternatively, install from crates.io with Rust 1.78+.

How do you use this agent?

Real model calls require an Anthropic or OpenAI API key; compatible gateways can also be configured in ~/.rpi/agent/models.json.

What are this agent's strengths and limitations?

Pros
  • The Rust SDK and CLI share the same agent and tools, so you can embed the runtime or run the command directly.
  • The faux provider and in-memory execution environment enable deterministic examples and test paths without an API key or network.
  • JSONL session persistence records frame-level progress and supports recovery from the last committed frame after a crash.
  • Rust cdylib extensions use a #[repr(C)] ABI with version negotiation and panic containment.
Limitations
  • Real Anthropic or OpenAI-compatible model calls require API credentials and network access.
  • The SDK and source builds require Rust 1.78+; plugins also need a Rust cdylib build workflow.
  • The primary interface is a terminal TUI; the README does not describe a graphical desktop app.
  • TCP remote mode requires deploying a server and managing its authentication token.

How does this agent compare with similar options?

The README compares rpi structurally with Claude Code, Codex CLI, opencode, and aider, positioning rpi as a Rust runtime with an embeddable library, plugin ABI, and multi-provider gateways. It notes that information about the other products is current as of 2026-09 and may change.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
rpi: Rust Coding-Agent Runtime This agent 64 · Some gaps CLIFree + model costs ★ 116 today Rust OpenAI API · Claude API
Aster 77 · Good CLIFree + model costs ★ 129 today Rust OpenAI API
zerostack 57 · Major gaps CLIFree + model costs ★ 1.7k 5d ago Rust OpenAI API · Claude API
Devo Desktop Coding Agent 58 · Major gaps Desktop appFree + model costs ★ 338 3d ago Rust OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
64/ 100 5-point scale 3.2 / 5
This review covers the source as of Oct 17, 2026. The project has shipped 2 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 13/29
Reliability 6/14
Adaptability 14/18
Convention 14/18
Effectiveness 12/13
Verifiability 5/8
Why each dimension lost points
Trust13 / 29 · 2.2/5

The security policy states that tools run with the invoking user's privileges, bash/PowerShell can run arbitrary commands, file tools can read and write paths, and plugins are trusted native code without a sandbox. This describes the boundary but does not show general least-privilege isolation, so least_privilege is 1. The policy mentions project trust prompts and gating settings, and installers provide dry-run, but the supplied material does not establish the exact scope or defaults of operation confirmations, so user_confirmation is 1. README and the policy describe remote TCP, tokens, credential files, plugin loading, and tool behavior, giving reasonably useful data-flow visibility without covering every path; data_flow_transparency is 2. Unix auth.json permissions of 0600, advice against shared session directories, and terminal-output sanitization are documented; the full credential lifecycle is not shown, so sensitive_data_handling is 2. Cargo.toml lists dependencies and some pinned versions, but the supplied material shows no vulnerability audit or dependency update policy, so dependency_security is 1. Tools can run arbitrary commands, extensions can execute build scripts, and remote service use has external effects; warnings exist but fine-grained effect controls are not shown, so external_effects is 1. Session crash recovery and installer dry-run are documented, but no general undo mechanism for file edits, commands, or installed extensions is shown, so rollback is 1. README, Cargo.toml author metadata, MIT copyright notices, and security reporting instructions provide attribution and contact clues; publisher registry verification is absent and is not treated as adverse evidence, so source_attribution is 2.

Reliability6 / 14 · 2.1/5

README, Cargo.toml, and CI descriptions of the nine crates, version, MSRV, and test command are broadly consistent. The documentation-index sentence is duplicated and the crate dependency narrative is somewhat elaborate, so self_consistency is 2. CI uses locked workspace tests and dependencies are declared, with some exact pins, but the materials show no offline cache or supply-chain availability plan, so dependency_availability is 1. The policy says provider error bodies and model output are sanitized, and CI scripts include some failure messages; there is no catalog or coverage evidence for CLI/API error messages, so failure_messages is 1.

Adaptability14 / 18 · 3.9/5

The project addresses CLI users, embedded SDK developers, and plugin authors with separate starting points, examples, and documentation, so audience_and_scenarios is 3. The policy clearly describes the lack of plugin sandboxing, tool privileges, and remote-mode boundaries; README explains provider features and client/server responsibilities, though the full capability boundary is not enumerated, so capability_boundaries is 2. CLI examples, extension search order, remote mode, and use cases are clear, while guidance on choosing modes and precise triggers is limited, so trigger_precision is 2. README lists Linux/macOS/Windows, binary targets, MSRV, installation paths, and a current Homebrew limitation. CI evidence explicitly covers Linux Rust checks and Windows installer tests, leaving other environment coverage unclear, so environment_fit is 2.

Convention14 / 18 · 3.9/5

Documentation is grouped by feature, with crate tables and architecture, user, remote, and extension-authoring guides, so information_architecture is 3. Prebuilt, Cargo, package-manager, and source installation instructions include commands and platform notes, checksum verification, and dry-run, so install_notes is 3. Crate names and directories consistently use the rpi- prefix and workspace versions align; some Pi/rpi terminology and dependency-graph phrasing are less consistent, so naming_stability is 2. README provides SDK, tools, plugin, and offline examples and links to guides; the supplied material has no FAQ and does not cover common troubleshooting in depth, so examples_and_faq is 2. The security policy covers threat model and scope, and README notes several platform and benchmark limits; a comprehensive known-issues list is not shown, so known_limitations is 2. LICENSE includes full MIT terms and copyright attribution, consistent with Cargo metadata, so license is 3. Version, release status, roadmap, and changelog entry points are present, but changelog contents and versioning policy details are not supplied, so versioning_changelog is 2. Author metadata, vulnerability reporting, contribution guidance, and support information indicate maintenance and contact paths; curated registry verification is absent, so maintenance_responsibility is 2.

Effectiveness12 / 13 · 4.6/5

The product offers an interactive terminal, one-shot prompts, JSON event stream, persistent sessions, and SDK events, with clear entry points for machine consumption and embedding, so output_usability is 3. The library-first design, provider-independent tools, plugin ABI, and crash recovery provide concrete value beyond a standalone CLI, supported by architectural descriptions and examples, so marginal_value is 3. A single Rust binary, offline faux provider, and crate-level composition reduce some deployment and test costs; remote, plugin, and multi-platform support add complexity, and performance comparisons are repository claims, so cost_benefit is 2.

Verifiability5 / 8 · 3.1/5

README links installation, examples, benchmarks, and architecture claims to scripts, a tape, docs, or CI, but some performance and product-comparison claims remain primarily README assertions, so claim_traceability is 2. README, Cargo.toml, security policy, and CI corroborate some version, feature, and security-boundary claims; independent third-party evidence is not supplied, so cross_source_corroboration is 2. README limits benchmark interpretation and lists unmeasured areas, while the policy distinguishes threat model and scope; evidence status is not equally clear for every performance and comparison statement, so fact_inference_separation is 2.

Risks and how to mitigate them
  • This is a low-confidence static source review; the project was not run, and performance, release, and test claims were not independently verified.
  • bash/PowerShell and file tools use the invoking user's privileges; plugins are unsandboxed native code, and the remote TCP protocol has no transport encryption of its own. Use only trusted repositories and extensions, and protect tokens and credentials as the security policy advises.
Evidence confidence: Low Reviewed Oct 17, 2026 Reviewed revision 1409907e8bb7 New commits since this review; the score may not cover them
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.6.0 rpi v0.6.0
    Release notes excerpt
    What's Changed * chore(release): sync 0.5.1 install channels and site data by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/57 * feat: add BTW side chat and fix Anthropic tool images by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/60 * chore(release): prepare 0.6.0 by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/61 Full Changelog: https://github.com/bigfish1913/pi-rust/compare/v0.5.1...v0.6.0
    View on GitHub ↗
  2. v0.5.1 rpi v0.5.1
    Release notes excerpt
    What's Changed * chore(release): align channels and website with 0.5.0 by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/53 * fix: unify tool panel theme spacing and enforce warning-free CI by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/55 * chore(release): prepare 0.5.1 by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/56 Full Changelog: https://github.com/bigfish1913/pi-rust/compare/v0.5.0...v0.5.1
    View on GitHub ↗
  3. v0.5.0 rpi v0.5.0
    Release notes excerpt
    What's Changed * feat(extensions): add plugin-owned child agent lifecycle by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/51 * chore(release): prepare 0.5.0 by @bigfish1913 in https://github.com/bigfish1913/pi-rust/pull/52 Full Changelog: https://github.com/bigfish1913/pi-rust/compare/v0.4.1...v0.5.0
    View on GitHub ↗

FAQ

Can I try it without an API key?
Yes. The README includes offline examples using the deterministic faux provider; real Anthropic or OpenAI-compatible model calls require credentials.
Which model providers are supported?
The README lists Anthropic, OpenAI-compatible gateways, and the faux provider for offline use.
Will a tool run again after an interrupted session?
Sessions store frame-level progress as JSONL. The README says crash recovery resumes from the last committed frame instead of replaying the turn.
What can plugins add?
Rust cdylib plugins can register tools, providers, slash commands, event handlers, Markdown renderers, and discovered resources.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents