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.

asynkron/protoactor-go

5,469View on GitHub

protoactor-go is a framework for building concurrent and distributed systems in Go using the actor model. It provides a distributed actor system that enables isolated entities to communicate via asynchronous messaging and share state across a cluster. The framework implements a multi-language actor protocol, allowing interoperability between actors written in Go, C#, and Java. It further supports a virtual actor implementation, where actors are automatically instantiated across a network based on a unique identity. The system includes a supervision model for managing actor lifecycles and fau

maiot-io/zenml

5,452View on GitHub

ZenML is an extensible machine learning orchestration framework designed to manage the end-to-end lifecycle of data pipelines and AI agent workflows. It functions as a durable orchestrator that executes machine learning tasks as directed acyclic graphs, ensuring that every step is containerized for consistent performance across local, cloud, and hybrid infrastructure. By decoupling pipeline code from underlying compute and storage backends, the platform allows developers to define infrastructure-agnostic stacks that remain portable across diverse environments. The project distinguishes itself

dotnet/orleans

10,789View on GitHub

Orleans is a .NET distributed actor framework designed for building scalable, cloud-native applications. It implements a virtual actor model where entities with stable identities manage their own state and lifecycle across a cluster of servers. The framework provides a distributed state management system with ACID transaction support and a distributed pub/sub streaming engine for real-time data processing. It distinguishes itself through location-transparent routing, automatic actor activation and deactivation, and elastic cluster scaling that redistributes workloads during node failures. Th

RightNow-AI/openfang

17,834View on GitHub

OpenFang is an operating system for LLM agents designed to orchestrate autonomous agents with built-in task scheduling, tool sandboxing, and multi-model routing. It provides a secure AI execution environment that integrates prompt injection scanning, cryptographic audit trails, and resource metering to ensure controlled processing. The platform distinguishes itself through a comprehensive security architecture, featuring fuel-metered tool sandboxing and an immutable activity audit trail based on cryptographic hash-chains. It implements high-assurance identity verification via signed manifests

rivet-devrivet

Features