Xaroic AI - Autonomous Agent Framework

Star Discord

PRODUCTION-GRADE RUST FRAMEWORK

Construct Autonomous Agent Architectures in Rust

Xaroic AI is the premier enterprise-level Rust infrastructure designed for deploying, orchestrating, and scaling decentralized multi-agent intelligent systems.

Get Started View Architecture

12K+

Downloads

850+

Commits

24

Contributors

// agent_swarm.rs
use xaroic_ai::prelude::*;

async fn initialize_swarm() -> Result<()> {
  let oracle = Agent::new("DataOracle")
    .with_memory(MemoryType::Redis)
    .build();

  let executor = Agent::new("TxExecutor")
    .with_tool(SolanaSigner::default())
    .build();

  let swarm = Swarm::new(vec![oracle, executor])
    .deploy().await?;

  Ok(())
}

COMPREHENSIVE ARCHITECTURE

Everything you need for multi-agent systems

Xaroic AI provides a complete toolkit for next-generation algorithmic operations.

Agent Abstractions

Construct sophisticated behavioral models effortlessly. Define personas, distinct objectives, and interaction boundaries using our type-safe Rust traits.

Memory Management

Implement persistent cognitive state. Our framework natively supports vector databases, short-term buffers, and long-term historical context retention.

Tool Integration

Equip your models with actionable utility. Seamlessly integrate smart contract execution, API scraping, and data processing algorithms safely.

Asynchronous Routing

Handle concurrent data streams efficiently. Powered by Tokio, ensuring your agents communicate and process tasks without thread-blocking.

Execution Guardrails

Prevent catastrophic logic failures. Establish strict boundary conditions and automated fallback mechanisms to secure your protocol.

REST API Ready

Expose your intelligence layer to external clients. Built-in routing capabilities allow you to serve agent responses via secure HTTP endpoints.

PRACTICAL APPLICATIONS

Real systems, real Rust

Discover how enterprise teams leverage the Xaroic AI ecosystem in production environments.

DeFi Trading Bots

Deploy autonomous arbitrage and market-making entities. Monitor mempools, calculate slippage, and execute on-chain transactions autonomously.

xaroic-core ethers-rs tokio

Swarm Simulations

Model complex economic behaviors. Utilize distinct agent personas to simulate market dynamics, stress-test protocols, and forecast liquidity crunches.

xaroic-swarm async-trait

Self-Healing DevOps

Infrastructure that repairs itself. Agents that monitor system logs in real-time, diagnose anomalous behavior, and automatically restart failing microservices.

xaroic-tools reqwest

Predictive Analytics

Agents specialized in data ingestion. Continuously scrape off-chain feeds, structure unstructured text via LLMs, and push formatted insights to your database.

xaroic-llm serde pg-rs

SEAMLESS INTEGRATION

Add to your project in seconds

Initialize the ecosystem via Cargo. Our modular design ensures you only compile the dependencies your specific architecture requires.

Modular crate implementation
Built on Tokio's async runtime
Comprehensive documentation
Strictly typed security parameters

View Documentation

Cargo.toml

[dependencies]
xaroic_core = "0.2.4" # Base architecture and memory
xaroic_llm  = "0.2.4" # Model integrations (OpenAI, Anthropic)
xaroic_tools = "0.2.4" # Standard execution toolsets
tokio       = "1.35"  # Required async runtime

MODULAR DESIGN

Polyrepo crate system

Maintained, versioned, and shipped as independent packages for optimal compilation.

xaroic-core v0.2.4

xaroic-memory v0.2.1

xaroic-llm v0.2.4

xaroic-tools v0.1.8

xaroic-swarm v0.1.5

xaroic-macros v0.1.2

View All Crates

OPEN SOURCE & ENTERPRISE READY

Prepared to engineer intelligent agents?

Join the growing ecosystem of Rust developers constructing the next generation of decentralized automation.

Read The Docs View on GitHub