Rust is rewriting the Python stack. Deliverd now speaks Rust too.

Deliverd has a Rust SDK. The crate is deliverd on crates.io, and it does what our TypeScript and Python SDKs do: an agent asks a person, waits for the answer and acts on it.

use deliverd::{ApprovalRequest, Deliverd};

let deliverd = Deliverd::from_env()?;
let decision = deliverd
    .approve(ApprovalRequest::new("Deploy to production"))
    .await?;

if decision.approved {
    deploy().await;
}

Before we get to the crate, it is worth saying why we built it now, because the reason is bigger than us.

Rust is taking over the parts of Python that have to be fast

You will read that Rust is replacing Python. That is not quite what is happening, and the difference matters. Python is still where people write the code. Rust is increasingly what runs underneath it.

Look at the tools a Python developer touches every day:

• Installing packages. uv, Astral's package and project manager, is written in Rust and is "10-100x faster than pip".
• Linting and formatting. Ruff, from the same team, is written in Rust and is "10-100x faster than existing linters (like Flake8) and formatters (like Black)".
• Validating data. Pydantic V2 moved its core into Rust as pydantic-core. Its authors measured V2 at "between 4x and 50x faster" than V1.9.1, and about 17x faster on a model with a range of common fields.
• DataFrames. Polars "is written in Rust which gives it C/C++ performance", and you drive it from Python.
• Tokenising text for models. Hugging Face's tokenizers library has a Rust core, with Python as one of its bindings.

The pattern is the same each time. The interface stays in Python, where it is pleasant to use, and the hot path moves to Rust, where it is fast and memory-safe without a garbage collector. Libraries such as PyO3 make that split cheap, which is why it keeps happening.

It is now reaching Python itself. At the Python Language Summit 2026, core developers discussed adding Rust to CPython, starting with an optional Rust backend for the zlib module in Python 3.16. It is a proposal, not a decision, and a PEP is still to be written. But it is being talked about seriously, by the people who maintain the language.

None of this means Python is shrinking. In the Stack Overflow Developer Survey 2025, Python's usage rose 7 percentage points, and Rust was again the most admired language, at 72%. Both things are true at once: more people write Python, and more of what their Python calls is Rust.

Why that matters for agents

The same split is showing up in AI agents. The prompts, the evals and the notebooks are Python. The services that run agents in production, the gateways, the workers and the tools that touch real systems, are where teams reach for Rust, for the same reasons uv and Ruff did: speed, predictable memory and a compiler that catches whole classes of bugs before they ship.

Those services are exactly where an agent does something consequential: it moves money, deploys code or emails a customer. That is the moment a person should be asked first. Until now, a team writing that service in Rust had to call our REST API by hand and write the waiting, the retries and the webhook checks themselves. Now they do not.

What the crate does

The crate has the same six primitives as the other SDKs:

deliverd.gate(GateRequest::new(action, external_id, input)).await?;   // may I? — your organisation answers
deliverd.approve(ApprovalRequest::new(title)).await?;                  // ask permission, and wait
deliverd.review(ReviewRequest::new(title).reviewer(who)).await?;       // ask whether it is right
deliverd.collect(CollectionRequest::new(title).question(q)).await?;    // ask for what you lack
deliverd.confirm(ApprovalRequest::new(title)).await?;                  // a yes or no → bool
deliverd.publish(PublishRequest::new(title, html)).await?;             // get the work to people

Async, on tokio. HTTP is reqwest with rustls, so nothing links against the system's OpenSSL.

The same behaviour as TypeScript and Python. Retries, idempotency keys, webhook signatures, durations and gating are held to the other two SDKs by one shared conformance table, which the crate's own tests read. A fix to how one SDK waits or retries is a fix the other two have to match.

Nothing to set up before you try it. Deliverd::development() needs no key and no network. It prints what the approver would have seen and answers at once, approved, rejected, timed out or with a question, so you can test every way a real request can end.

Rust 1.89 and up.

Get it

cargo add deliverd

Set DELIVERD_API_KEY and you are done. The SDK docs cover all three languages side by side, and the Rust SDK is on the Integrations page with everything else Deliverd works with (more on that page).

Deliverd is human-in-the-loop infrastructure for AI agents: an agent asks a person for approval, a review, an answer or a decision, and carries on when they respond.