Rig v0.45.0 released!

[gold-silver-copper]

Rig v0.45.0 released!

RIG IS NOW A CODING AGENT !!!!!! 🥳 🥳 🥳

Rig is no longer just a library, now you can do cargo install rig to install the Rig coding agent to your computer!!!

Even cooler: The Rig coding agent is built on top of Bevy! A whole game engine. Oh and also it can reload and recompile itself! It actually has full access to the whole Bevy stack, so you can even make plugins that are full GUI applications! The possibilities are endless. And Every Rig Plugin, is just a Bevy Plugin, it's very seamless. We are super excited to be releasing this.

As for the library, this release had multiple performance passes over the full codebase. Many exponential functions are now linear, and speed ups range from 2x to 20x. So expect a much faster rig this release.

The API itself has been simplified a lot, with only one common way to represent things, with hopefully almost no functionality lost!

Much of this release was dedicated to the new Rig coding agent, which means that there are many more useful features inside the rig library now for building your own harnesses, so feel free to go wild!

The Rig coding agent is still very much a WIP, and many things are on it's roadmap. We have already gotten feedback from early users that is being actively worked on right now for the next release. Please help us test it and let us know what you think!

0.45 highlights:

• A terminal coding agent. cargo install rig gives you tools, streaming answers, saved sessions, model switching, context compaction and ChatGPT sign-in.
• Everything is a plugin. Tools, commands, sessions, sign-in and the terminal view are Bevy plugins. Add your own, replace a default, or remove what you do not need.
• It rebuilds itself. Change a plugin, reload, and continue in the same session. A failed build keeps the old agent running.
• Scriptable over pipes. Use rig -p for one prompt or rig --json for a versioned JSON-lines interface.
• Less copying, faster runs. Shared messages and tool definitions, incremental effect logs, and an inline handler table replace repeated cloning and the old message bus.
• Runs that survive a restart. Resume in-flight model requests and partially answered tool batches without losing the results already collected.
• Catalog facts that follow the model. Overrides now reach encoding, option validation and pricing, rather than being attached separately to an agent.
• More provider capabilities. Claude through Vertex AI, Gemini image and speech generation, MiniMax image generation and voice cloning, richer transcription, and owned MCP connections.

Less Copying, More Work

A large part of this cycle went into measuring the library and removing work it did not need to do.

Messages, tool definitions, requests and completion answers are shared through Arc. The classic agent dispatches effects through an inline Handlers table instead of a separate message-bus driver. Effect logs append new conversation data instead of repeatedly writing the whole history.

In the measured benchmarks:

• The agent turn loop used 92% fewer instructions at 400 turns.
• Request encoding was 20–62% faster, with 67–86% fewer allocations.
• Decoding was 37–89% faster on the measured cases.
• Effect-log writing was 26× faster at 3,000 messages.

These are benchmark results, not a promise that every application gets the same speedup. The underlying improvement is broadly useful: long conversations should not keep paying to copy everything that came before them.

Meet the Rig Coding Agent

cargo install rig
export OPENAI_API_KEY=...   # or another supported provider's key
rig

Or start Rig and use /login chatgpt to sign in with a ChatGPT plan.

/model picks the model, /effort changes its reasoning setting, and /help lists the commands. The agent reads project instructions, works with files, runs commands and saves the session as it goes.

The terminal shows the whole transcript: tool arguments and results, highlighted code, word-level diffs, token usage, cost and context use. Type while it works to steer the current turn or queue a follow-up. Esc stops the turn.

rig -p "Find the failing test and fix the cause"
rig --resume <session-id>

The agent needs Rust 1.97.1 or newer and runs on Linux and macOS. Windows is not supported yet.

The agent guide covers installation, models, sessions, tools and configuration.

Your Agent Is a Rust Program

The coding agent is a Bevy app, built from plugins listed in plugins.toml.

Its terminal view is a plugin. So are its coding tools, model picker, sessions, compaction and sign-in. You can remove or replace them rather than working around a fixed application.

The pieces are published separately:

• rig-ecs is the Bevy kernel: agents, turns and tool calls are entities.
• rig-harness supplies the coding-agent extension points.
• rig-tools provides reusable file and shell tools.
• rig-basics contains the default behavior plugins.
• rig-tui supplies the terminal view.

Subagents, approvals, previews, checkpoints, search and helpers are optional plugins, not requirements of the kernel.

Use rig plugin new to start a plugin, rig plugin check --build to check it, and /reload to rebuild and restart in the same session. If compilation fails, the existing build keeps running.

The plugin guide shows how to write tools, commands, panels and other extensions.

Built for Pipes and Remote Work

The terminal is one front end, not the only way to drive the agent.

# One prompt, plain output.
rig -p "Explain this repository"

# One prompt, structured events.
rig -p --json "Review the latest changes"

# An ongoing JSON-lines session over stdin/stdout.
rig --json

The JSON interface exposes text, tool calls, tool results, questions and turn completion. rig help-agents documents the protocol. --tools narrows what a run can use, and the optional helper plugin can run child agents independently, in parallel or in a chain.

The coding tools also support remote HOST:PATH files through configured transports. Remote edits check the file’s hash before applying changes, writes are atomic, and reading a whole file lets the next edit avoid fetching it again.

Shell output keeps its beginning, errors and end when it is too long. Stopped commands explain whether they timed out, went quiet or exceeded the output limit, and remote failures distinguish a stopped transport from a remote process that might still be running.

Restart-Safe Runs and Persistent Conversations

The classic agent’s sans-IO run protocol can now resume while waiting for a model response or partway through a tool batch.

A resumed batch retains the answers already collected and offers only the unanswered calls. Cancellation histories keep settled results and close pending calls so the history can be used again.

Tool streams now come from committed history too. Calls answered by recovery, skipped calls and output-tool reprompts get corresponding results instead of leaving a UI waiting forever.

Persistent conversations are available through:

• AgentBuilder::memory(store).conversation(name)
• Per-run memory overrides and .without_memory()
• Local stores or an application-provided AsyncStore

Overlapping saves are refused rather than silently overwriting one another. DirStore locks across processes.

For the coding agent, a tool call that may change something starts only after its recovery mark has been saved. After a crash, an already-started changing call is not blindly executed again.

The Catalog Owns the Model Facts

In 0.44, Rig introduced the model catalog. In 0.45, the connected model carries the facts it was built with.

That means a custom catalog override reaches:

• Request encoding.
• Reasoning, sampling and cache-option validation.
• Model descriptors.
• Usage cost estimates.

Connect directly through the catalog, with credentials from the environment or explicit ConnectOptions. There is no separate AgentBuilder::model_spec to keep synchronized.

Custom catalogs also get strict override validation, programmatic spec builders, and models.dev imports that report skipped rows. Refreshing from models.dev preserves the facts Rig explicitly pins.

Cost estimates are more honest too: if a cache price is unknown, that component stays unknown instead of borrowing the ordinary input price. Cost::is_complete() tells you whether every component was priced.

Providers and Integrations

• Vertex AI: Claude through rawPredict and streamRawPredict, using Google credentials and the shared Anthropic encoder.
• Gemini: Gemini 3 image generation with reference images and explicit sizes, Interactions text-to-speech, current Deep Research options and stream-resume cursors.
• MiniMax: image generation, text-to-speech, voice upload and cloning, plus the M3 model constant.
• Transcription: language, duration, confidence, timed segments and words, and speaker labels where the provider supplies them.
• MCP: rmcp 3.5, owned connections that keep registered tools alive, resources, tool aliases and per-call metadata.
• Authentication: application-supplied token stores for ChatGPT and Copilot, including file and memory implementations.
• Gemini gRPC: larger replies, current thinking levels, REST-compatible embedding widths and grounding metadata.

Upgrading

0.45 is a breaking release. The most common changes:

• Histories and tool definitions use shared Arc values in lower-level APIs.
• rig::bus becomes rig::handlers; AgentBuilder::over_bus becomes over_handlers.
• AgentBuilder no longer has a tool-state type parameter.
• One contextual Tool contract replaces the portable/runtime split.
• The old core memory policies give way to conversation data and rig-memory storage.
• Connect through Catalog::connect or connect_with, rather than the free registry functions.
• ChatGPT and Copilot authenticators take a TokenStore, not credential-file paths.
• Document text uses DocumentData::Text; binary sources use DocumentData::File.
• MCP tools are built from an owned McpConnection.
• Persisted classic runs and effect-log checkpoints have new formats.

Existing rig-ecs users: the 0.45 crate is a new Bevy kernel, not a compatible update of the 0.44 runtime. Plan that migration separately.

Some changes compile but behave differently. Completion outcome hooks now include rejected and retried attempts, usage observations arrive once from the normalized response, in-band provider errors can become retryable, and legacy string documents load as text.

Thank You

Huge thank you to everyone who helped make 0.45 happen 🫡

• @1broseidon
• @aimable100
• @colonnade-ai
• @dafyy321-pixel
• @dgrijalva
• @fversaci
• @geodic
• @georgeatparallel
• @guiwoda
• @isSerge
• @jantristan-hb
• @jazoom
• @mateobelanger
• @matt-cochran
• @shilch
• @sohbit
• @suxiaoshao
• @tidely
• @tripplen23

Thank you as well to everyone testing new releases, sharing reproductions, answering questions and building with Rig.

We build Rig, Rig builds us!

The 0.44 → 0.45 migration guide covers the API changes and silent behavior changes.

Full changelog: v0.44.0...v0.45.0