Production-Ready AI Agents for Blockchain

riglr provides the architectural patterns—like the strict separation of ApplicationContext and SignerContext—that turn AI prototypes into secure, scalable, and maintainable production systems.

Get Started in 60 Seconds Read the Docs

The riglr Difference: From Prototype to Production

While other frameworks connect an LLM to tools, riglr provides the battle-tested architecture to run them securely at scale.

Zero Boilerplate Developer Experience

The #[tool] macro: from 30 lines to 1.

❌ Without riglr

pub struct GetSolBalance;
#[async_trait]
impl Tool for GetSolBalance {
    fn name(&self) -> &str { "..." }
    fn description(&self) -> &str { "..." }
    fn parameters(&self) -> Value { /* ... */ }
    async fn call(&self, params: Value) 
        -> Result {
        // Manual everything...
    }
}

✅ With riglr

/// Get the SOL balance.
#[tool]
async fn get_sol_balance(
    address: String,
    context: &ApplicationContext,
) -> Result {
    // ... logic ...
}

Clean Architecture & Uncompromising Security

The strict separation of read-only and write-only contexts.

ApplicationContext

For Shared, Read-Only Dependencies
Holds RPC clients, API keys, configs
Enables testability & modularity
Passed explicitly to tools

SignerContext

For Secure, Isolated Write Operations
Holds cryptographic signers
Ensures multi-tenant security
Accessed implicitly via task-local

#[tool]
async fn transfer_sol(
    context: &ApplicationContext, // Passed explicitly for READS
    to: String,
    amount: f64,
) -> Result {
    // Accessed implicitly and securely for WRITES
    let signer = SignerContext::current_as_solana().await?;
    let rpc_client = context.solana_client()?;
    
    // Keys are never exposed to the LLM reasoning loop.
    // ... sign and send transaction ...
}

Full-Stack Systems, Not Just a Framework

Go beyond simple tool-calling with built-in production infrastructure.

Multi-Agent Coordination

Build "swarms" of specialized agents (Research, Risk, Execution) that collaborate on complex workflows using a capability-based dispatcher and a distributed agent registry.

Real-Time Event Streaming

Make agents proactive. Ingest and process >10,000 events/sec from Solana Geyser, EVM WebSockets, and CEX APIs with a resilient, composable streaming engine.

Production-Grade Indexing

Give agents historical context. A high-performance pipeline ingests, processes, and stores on-chain data in PostgreSQL with Redis caching for real-time analytics.

Get Started in 60 Seconds

Use our official CLI to scaffold a production-ready riglr agent instantly.

Install the Generator

Get the official project generator with a single command.

cargo install create-riglr-app

Create Your Agent

The interactive CLI guides you through creating a new agent.

create-riglr-app my-trading-bot

Configure & Run

Add your API keys and launch your agent.

cd my-trading-bot
cp .env.example .env
# Edit .env with your API keys
cargo run -- --interactive