# Rivet: Orchestrate AI Agents Using S3 as Your Data Plane

> Published 2026-11-05 · https://www.promptzone.com/isabela_rahimi/rivet-orchestrate-ai-agents-using-s3-as-your-data-plane-5c0c

Rivet, a Y Combinator-backed open-source framework, launched this week to scale and orchestrate AI agents using a novel approach: treating **Amazon S3 as the primary data plane**. The project [surfaced on Hacker News](https://github.com/rivet-dev/rivet) with a launch thread discussing its architecture for cost-effective, durable agent workflows.

> **Tool:** Rivet | **Core Tech:** S3 State Backend | **License:** MIT
> **Language:** TypeScript/Node.js | **Available:** GitHub, Cloud

## How S3 Becomes an Agent Orchestrator

Traditional agent frameworks like LangChain or LangGraph manage workflow state in memory or a dedicated database, which scales expensively. Rivet’s core innovation is **persisting every agent state transition directly to S3**. Each step in a chain or graph is a discrete object stored in the cloud storage service.

This turns S3 into a durable, auditable log. The framework handles the complexity of reading, writing, and coordinating these states, allowing developers to define agent graphs in code while Rivet manages execution and persistence.


![Rivet: Orchestrate AI Agents Using S3 as Your Data Plane](https://promptzone-community.s3.amazonaws.com/uploads/articles/0xu5ti8ne8u8kcxdadwg.jpeg)

## The Cost and Scale Proposition

The primary benchmark is cost. Rivet’s documentation claims this architecture can reduce orchestration costs by **over 90%** compared to running stateful orchestration engines in memory on services like AWS Lambda or in containers.

| Feature | Rivet (S3 Backend) | Traditional In-Memory Orchestration |
|---------|---------------------|--------------------------------------|
| **State Durability** | High (persisted to S3) | Volatile (lost on process end) |
| **Cost for Long Workflows** | Very Low (S3 PUT/GET costs) | High (compute runtime charges) |
| **Execution Model** | Stateless, serverless-friendly | Stateful, requires long-running process |
| **Debugging** | Native replay from S3 log | Requires custom logging implementation |

The system is designed for **long-running, asynchronous agents**. A research agent that runs for hours, periodically waking up to process new data, incurs minimal cost when idle, as state is cheaply stored in S3 versus an always-on container.

## How to Try It: Local and Cloud

Implementation is through a TypeScript SDK. The quickest start is local simulation.

```bash
git clone https://github.com/rivet-dev/rivet
cd rivet/examples
npm install
npm run simulate
```

This runs a predefined agent graph locally, but still persists state to a local file simulating S3. For cloud deployment, you configure an S3 bucket and AWS credentials. The Rivet runtime service can be deployed as a **Docker container** on ECS, Kubernetes, or even as a serverless function that processes steps from an S3 event queue.

{% details "Core API Example" %}
Defining a simple two-step agent graph:
```typescript
import { Graph, State } from '@rivet-gg/rivet';
const graph = new Graph();
const llmStep = graph.addStep('llm', { model: 'gpt-4' });
const toolStep = graph.addStep('calculator', { operation: 'add' });
graph.addEdge(llmStep, toolStep);
// Execution is handled by Rivet's runtime
const result = await rivet.run(graph, { input: "What is 123 + 456?" });
```
The runtime serializes each step's state (input, output, metadata) to S3.
{% enddetails %}

## Pros, Cons, and Early Feedback

**Advantages:**
*   **Radical Cost Reduction:** For high-volume or long-duration agents, moving state out of compute is the primary financial benefit.
*   **Built-in Audit Trail:** Every execution is automatically logged to S3 for replay, debugging, and compliance.
*   **Serverless Native:** Fits naturally into event-driven AWS architectures (Lambda, EventBridge).

**Limitations and Concerns:**
*   **Latency Overhead:** Each step incurs S3 read/write latency (~100-200ms). This makes it unsuitable for **real-time synchronous agents** requiring sub-second responses.
*   **Vendor Lock-in:** Deeply tied to AWS S3. While the state abstraction could be adapted, it's currently a single-cloud design.
*   **Early Stage:** As a new open-source project, the ecosystem of integrations and community support is limited compared to established frameworks.

Hacker News commenters noted the cleverness of the approach but questioned complexity: *"This is essentially building a distributed state machine on top of S3. Powerful, but now you have to debug your agents via S3 logs,"* one user observed.

## Alternatives and When to Choose Rivet

The agent orchestration space has clear leaders. Your choice depends on workflow characteristics.

| Tool | Best For | State Management | Cost Model |
|------|----------|------------------|------------|
| **Rivet** | **Async, long-running, cost-sensitive workflows** | S3 (Durable, External) | Very low per-step storage |
| **LangGraph** | **Complex, synchronous reasoning agents** | In-Memory / Redis | High (compute-bound) |
| **CrewAI** | **Collaborative multi-agent tasks** | In-Memory | High (compute-bound) |
| **Temporal** | **Mission-critical, production workflows** | Dedicated Database | Medium (infrastructure overhead) |

**Choose Rivet if:** You are building asynchronous AI agents (e.g., research assistants, content generation pipelines, batch processing bots) where cost and durability are primary concerns, and latency is not critical.

**Avoid Rivet if:** You need low-latency, synchronous agent interactions (e.g., customer support chatbots, real-time gaming NPCs) or are not committed to the AWS ecosystem.

> **Bottom line:** Rivet trades execution latency for dramatic cost savings and durability, making it a niche but powerful tool for specific production agent workloads.

## Who Should Use This Now?

Rivet is immediately practical for **startups and teams already on AWS** deploying non-real-time AI agents at scale. The cost savings are tangible for workflows that run for minutes or hours. It's also a compelling option for **ML engineers tasked with operationalizing research prototypes** into durable, auditable pipelines.

Individual developers prototyping simple agents may find the S3 overhead unnecessary; LangGraph or CrewAI offer faster iteration for local, in-memory graphs. Rivet's value unlocks at the point where **agent compute costs become a line item.**

The framework represents a maturation in agent infrastructure, treating orchestration as a data persistence problem rather than just a compute one. As agents move from demos to production, tools that prioritize cost and auditability alongside capability will define the next stack.

{% details "Getting Started Resources" %}
*   **GitHub Repository:** [rivet-dev/rivet](https://github.com/rivet-dev/rivet) - Source code and examples.
*   **Official Documentation:** **Rivet Docs** - Concepts and API reference.
*   **Launch HN Discussion:** [Hacker News Thread](https://news.ycombinator.com/item?id=40530789) - Community feedback and Q&A.
*   **Comparison Guide:** **LangGraph Documentation** - Understand the dominant alternative.
*   **AWS S3 Pricing:** [Amazon S3 Pricing](https://aws.amazon.com/s3/pricing/) - Calculate potential storage/request costs.
{% enddetails %}

The shift towards externalized, cheap state suggests a future where the most expensive part of an agent—its memory and reasoning trace—becomes its cheapest and most durable asset. Rivet is an early bet on that architecture.