What problem it solves

Agentic systems often need to run slow tools without blocking while waiting for their results. Infinity provides a runtime and tool protocol in which agents yield during idle periods and resume when work or events arrive.

Key features

• Concurrent agent runtime — Build agent systems in which tool calls run concurrently and waiting agents yield instead of blocking. The runtime supports the same agent code in resident processes and serverless environments.

  Source: README, crates/infinity-agent-core

• Hibernating agent state — Represent an idle agent as conversation data without a task, stack, or open connection. Agents can then wait for the next message before resuming execution.

  Source: README, crates/infinity-agent-core

• Reactive Agent Protocol — Expose tools over the network without keeping connections open. Results and subscription events are delivered when ready, including to agents that do not currently have a running process.

  Source: README, crates/rap-protocol, crates/rap-client

• MCP compatibility and bridges — Connect existing MCP servers through a compatibility layer and provide bridge crates for integrating the project’s reactive protocols with other agent tooling.

  Source: README, crates/infinity-mcp-bridge, crates/infinity-rap-bridge

• Concurrent coding agent — Run builds and tests in the background while their output streams in, edit files in parallel threads with stacked sandboxes, and receive results as diffs for review.

  Source: README, crates/sandbox-core, crates/sandbox-remote

Quick start

Copied verbatim from the project's README.

let system = AgentSystemBuilder::new_local(
    InMemoryConversationStore::new(),
    InMemoryStateStore::new(),
    StaticModel::new(provider, "global.anthropic.claude-sonnet-4-6").await?,
)
.start();

let mut thread = system.thread_builder().launch().await;
thread.send_user_text("Write a haiku about Rust").await?;

while let Some(event) = thread.recv().await {
    println!("{event:?}");
}

Who it may suit

Inference: this project may suit Rust developers building agent systems that need concurrent tool execution, resumable agents, networked tools, or serverless deployment.

Topics to discuss

• What runtime patterns are needed to coordinate large numbers of concurrent agents effectively?

• How should the Reactive Agent Protocol handle retries, delivery guarantees, and long-running subscriptions?

• Which integrations and deployment scenarios should receive priority in future development?

Written by ReadmeX AI from the project's README, source and public GitHub data; it may contain mistakes.

Read the original README https://github.com/hydro-project/infinity#readme

ReadmeX opened this community for a trending project; it is not run by the project. Maintainers can claim it from the community page.