Infinity
The open-source ecosystem for agents with principled concurrency.
Infinity Runtime
The first serverless-native agent runtime
The Infinity Runtime is built around a yielding architecture: each turn runs as a short slice that loads state, runs the model, dispatches tool calls, and yields, releasing all compute and memory in between. Because a slice never blocks waiting for a tool result or an event, the runtime is the first agent runtime that runs natively on serverless platforms. On AWS Lambda, an agent waiting on a three-day CI pipeline costs the same as one that was never created.
State lives in durable storage rather than process memory, so agents survive restarts, redeploys, and cold starts. The core is a Rust library that you can embed directly in your own process (the local Infinity Code daemon does exactly this) or deploy to Lambda with the included CDK constructs.
Learn more →Reactive Agent Protocol
Unified semantics for async work
The runtime's yielding model rests on the Reactive Agent Protocol (RAP), a successor to MCP that makes tool calls asynchronous. RAP servers deliver results whenever they are ready, without any long-lived connections. RAP also makes subscriptions a first-class concept, so a single call can stream an ongoing series of events to the agent, which reacts to each webhook, schedule, or alert as it arrives. Existing MCP servers run unchanged through a compatibility layer.
Agent work is full of things that don't finish right away: a build runs for twenty minutes, a webhook fires hours later, a human approves tomorrow, a child thread reports when it's done. RAP expresses all of them with one set of semantics, so long-running calls, real-world events, and concurrency are one mechanism instead of three subsystems.
Specification →Infinity Code
Highly concurrent coding agents
Infinity Code leverages RAP and the Infinity Runtime to put the whole stack to work on your codebase. It spawns child threads to handle independent work in parallel, and streams logs from long-running commands back through subscriptions instead of blocking on them. It hibernates while that work runs, then merges each result into a sandboxed diff you review.
Sessions persist in the local daemon, so you can detach from a busy agent and reconnect later, from the terminal or the desktop UI, with full context intact.
Get started →A composable, open stack
Infinity is a stack you can enter at any layer. Embed the runtime through its Rust API, build on RAP with your own runtime, or take Infinity Code as a finished coding agent. Everything is open source and MCP-compatible, so your existing tools keep working while you gain async execution.