Our take
Activeregular commits and releases- Activity
- 70
- Community
- 31
- Issues
- 21
- Pull requests
- 42
- Releases more often than 79% of the projects we track
- Slower to merge pull requests than 87% of the projects we track
Infinity is an actively developed Rust agent runtime with frequent releases, but its contributor base is concentrated around one person and the supplied health data shows no issues closed recently; its Apache-2.0 license supports permissive adoption.
Good fit if
- Your team is building Rust-based agents and needs them to yield during slow tool work.
- You want to explore serverless agent execution or asynchronous networked tools through RAP.
- You can evaluate an actively changing project whose recent development is driven mostly by one contributor.
Look elsewhere if
- You need a runtime in a language other than Rust.
- Your adoption process requires demonstrated issue closure activity, which the recent project data does not show.
- You need a project with a broadly distributed contributor base rather than one where most contributions come from a single person.
All health signals
| Last commit | 2026-10-27 (6 days ago) |
|---|---|
| Commits, last 90 days | 51 |
| Releases, last 12 months | 29 (latest sandbox-remote-v0.2.0, 2026-10-22) |
| Contributors | 7 (top contributor: 85% of commits) |
| Issues closed, last 90 days | 0 |
| Pull requests merged, last 90 days | 41 (typically merged in 4 days) |
| Project age | 7 months |
Checked on 2026-11-03 with the GitHub API.
Project history
Daily GitHub snapshots since Nov 3, 2026. History covers stars and forks; health signals are not tracked historically.
Stars
525Forks
55More snapshots will appear as the daily collection continues.
Overview
Infinity is a Rust framework for building massively concurrent agent systems. It addresses the cost of agents waiting on slow tools: turns can yield while work is pending, leaving an idle agent represented by its conversation data rather than a blocked task or open connection.
The same agent code can run in a resident process or on serverless platforms such as AWS Lambda. Infinity also provides the Reactive Agent Protocol (RAP) for delivering tool results and subscription events over the network without keeping a connection open, with a compatibility layer for existing MCP servers.
Key Features
- Runs agent turns concurrently while they wait for tools or other events.
- Hibernates waiting agents as conversation data, then resumes them when a message arrives.
- Supports resident processes and AWS Lambda deployment.
- Includes the Reactive Agent Protocol for asynchronous tool results and subscription events.
- Offers an MCP compatibility layer for existing servers.
- Includes Infinity Code, a coding agent that runs builds and tests in the background and presents results as diffs.
Use Cases
- Build tool-using agents that spend substantial time waiting on external operations, without keeping each turn blocked.
- Deploy agent workloads that need to scale to zero on AWS Lambda while keeping the same agent code as a resident deployment.
- Serve networked tools whose results or subscription updates may arrive after a client has stopped running.
- Run concurrent coding tasks, background builds, and parallel edits with results available for review as diffs.
What you need
Detected in the repository
- Rust (from Cargo.toml)
- Automated checks on GitHub Actions
License in plain words
Apache-2.0permissive
- Commercial use: yes
- Modify and redistribute: yes
- You must keep: the license, the NOTICE file and a note of your changes
- Share your changes: no
- Includes an explicit patent grant from the contributors:
A summary, not legal advice: the LICENSE file is what applies.
Getting Started
Use the Infinity Runtime quickstart to launch an agent. See the README for project links and additional guides.
Alternatives
- graphbit: GraphBit runs multi-agent workflows through a Rust core and Python API, while Infinity focuses on event-driven agent processes that yield and resume.
- rivet: Rivet provides durable Actors across Rust, Node.js, and Bun; Infinity is a Rust runtime centered on agents yielding to tools and resuming on events.
| Project | Language | License | Stars | Status |
|---|---|---|---|---|
| infinity | Rust | Apache-2.0 | 518 | Active |
| graphbit | Rust | Apache-2.0 | 585 | Quiet |
| rivet | Rust | Apache-2.0 | 6.5k | Active |
Considerations
- Rust is required, and the project’s runtime, RAP, and deployment approach may require evaluation against your existing agent architecture.
- The project is young, though recent commits and releases indicate active development. Contributor activity is concentrated, and the provided data reports no issues closed in the last 90 days.
- The repository metadata does not report tests, so teams should verify the testing and validation coverage they need before adoption.
Found this useful?
Share it with someone who would like infinity.