rivet-dev/rivet
Rivet
Rivet is a distributed infrastructure for managing the lifecycle, addressing, and persistence of stateful actors and durable execution engines. It provides a distributed process sandbox that executes application logic within lightweight isolates, ensuring resource isolation and fast cold starts. The system is designed to coordinate multi-step operations using persistent queues and timers to guarantee reliable task completion across distributed environments.
The platform specifically enables the orchestration of stateful AI agents that maintain persistent memory and state across long-running interactions and complex workflows. It distinguishes itself with a WebSocket state synchronization framework that binds frontend user interface components to remote stateful processes via real-time bidirectional communication.
The system covers a broad range of capabilities including hierarchical actor addressing, a hibernate-on-idle runtime for resource optimization, and a pluggable persistence layer for modular storage backends. It also includes tools for active session debugging, real-time execution state monitoring, and automated deployment options for edge, cloud, or private infrastructure.
The project is implemented in Rust and supports multi-language actor development.
Features
- Durable Task Orchestrators - Provides a durable orchestration substrate with state persistence and revision tracking for long-running multi-step workflows.
- Stateful Distributed Actors - Maintains application state within isolated processes that automatically persist to durable storage.
- Stateful Agent Orchestration - Provides a framework for building autonomous AI agents with persistent memory across complex multi-step workflows.
- Durable Message Processing - Uses persistent queues to process asynchronous messages reliably, guaranteeing task completion and recovery.
- Automatic State Persistence - Manages long-lived processes with in-memory state that is automatically synchronized to a database for high-performance access.
- Pluggable Storage Backends - Implements a modular persistence layer allowing the system to switch between relational databases, file systems, and key-value stores.
- AI Agent Orchestrators - Deploys isolated and secure stateful environments specifically to power autonomous AI agents and long-running workflows.
- Actor Lifecycle Management - Coordinates the activation and deactivation of actor state based on request demand and inactivity.
- Distributed Workflow Orchestrators - Coordinates complex sequences of distributed tasks while managing their persistent execution state.
- Hibernating - Serializes inactive process memory to storage to minimize resources and allow rapid resumption.
- Distributed State Management - Manages the lifecycle and addressing of stateful processes across distributed systems to ensure data durability.
- Real-time Data Subscriptions - Enables clients to listen for real-time updates from backend actors to reflect state changes in the UI.
- State Synchronization - Uses hooks to automatically synchronize user interface elements with stateful backend instances.
- Isolated Execution Sandboxes - Provides secure, resource-constrained sandboxes to execute application logic within lightweight isolates.
- Sandboxed Execution Environments - Executes application logic within secure, lightweight isolates to provide resource isolation and fast cold starts.
- Agent Execution Environments - Provides isolated runtimes specifically configured for the execution and resource management of autonomous AI agents.
- Component State Bindings - Connects user interface components to remote stateful processes to manage long-running workflows.
- Hierarchical Key Addressing - Organizes distributed stateful instances using path-based namespaces for secure communication and discovery.
- Durable Workflow Execution Engines - Coordinates multi-step operations using persistent queues and timers to guarantee reliable task completion.
- Actor State Persistence - Ensures durability of long-running processes by persisting their internal state to local or remote storage providers.
- Durable Entity Definitions - Enables the creation of durable entities with internal state and actions that trigger real-time event broadcasts.
- Real-Time State Synchronization - Integrates real-time stateful backend logic with client-side interfaces for seamless application state synchronization.
- Public API Exposure - Exposes internal stateful actor processes as secure backend endpoints for external client interaction.
- Bidirectional Streams - Establishes persistent bidirectional communication channels between clients and backend processes for live data updates.
- WebSocket State Synchronization - Establishes bidirectional WebSocket channels to synchronize frontend UI components with remote stateful backend processes in real-time.
- Actor State Querying - Allows real-time browsing and querying of the internal state databases associated with active processes and sessions.
- Workflow Progress Monitoring - Provides real-time inspection of workflow progress and state transitions for durable multi-step executions.
- Application Cloud Deployments - Automates the deployment of persistent actor-based applications by connecting source repositories to managed cloud infrastructure.
- Cloud Infrastructure Cost Optimization - Reduces operational costs and latency through idle-time suspension and strategic geographic distribution of instances.
- Distributed Edge Compute Platforms - Provides a platform for deploying resource-constrained, isolated code execution across a global network of edge nodes.
- Edge Runtime Deployment - Allows running orchestration logic on serverless edge functions to minimize latency by distributing execution closer to users.
- Air-Gapped Deployments - Provides configurations to operate the orchestration infrastructure within restricted, air-gapped network environments.
- Multi-Environment Deployments - Supports running orchestration logic across diverse environments including serverless platforms and dedicated edge functions.
- Private Infrastructure Hosting - Allows hosting the entire orchestration stack on private infrastructure for maximum control over security and data.
- Websocket Connection Managers - Maintains long-lived WebSocket communication channels using proxy configurations for stable data exchange.
- Low-Level API Interfaces - Provides direct HTTP and WebSocket access to remote processes implementing specific request-handling logic.
- Real-Time State Broadcasting - Broadcasts bidirectional data to connected clients via WebSockets for live collaborative interactions.
- HTTP Endpoint Mappings - Links backend process registries to HTTP endpoints to support standard REST methods for remote communication.
- Actor Access Control - Provides authentication and authorization mechanisms specifically for validating identities and origins when accessing stateful actor instances.
- Stateful Actor Runtimes - Enables the development of stateful actor logic using multiple programming languages to meet different performance needs.
- Recurring Task Schedulers - Supports the execution and validation of delayed or recurring operations using timers and cron jobs within a controlled environment.
- Remote Function Invocation - Invokes functions on distributed processes via client connections for stateful and stateless requests.
- Stateless Request Processing - Performs one-off requests or utility calls to backend processes without maintaining a persistent connection.
- System Activity Monitoring - Provides a centralized dashboard for tracking state changes, workflow progress, and agent events.
- Interactive State REPLs - Enables direct interaction with running code by calling actions and subscribing to events through a REPL.
- Direct Process Invocations - Provides mechanisms to invoke low-level network interfaces directly on remote actor processes.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
