liquidos-ai/AutoAgents

A multi-agent framework written in Rust that enables you to build, deploy, and coordinate multiple intelligent agents

What it solves

AutoAgents provides a robust, high-performance framework for building intelligent, multi-agent systems. It addresses the complexity of managing agent lifecycles, tool integration, memory, and LLM orchestration, specifically targeting developers who need production-grade reliability and performance in Rust.

How it works

It uses a modular, type-safe architecture where agents are built using Rust's ownership and type system. The framework provides a unified interface for various LLM backends (both cloud-based and local), handles tool execution via a sandboxed WASM runtime, and manages agent communication through typed pub/sub mechanisms. It includes built-in support for ReAct patterns, memory management, and guardrails to ensure safe and predictable agent behavior.

Who it’s for

This project is for software engineers and AI developers who want to build scalable, performant agentic applications in Rust. It is also suitable for those who need to deploy agents on edge devices or require tight integration with local inference engines like llama.cpp or Mistral-rs.

Highlights

  • Multi-Backend Support: Unified interface for major cloud LLMs (OpenAI, Anthropic, DeepSeek, etc.) and local models.
  • Performance-Oriented: Built in Rust with full async/await support for high concurrency and memory efficiency.
  • Tooling & Safety: Includes a sandboxed WASM runtime for executing tools and configurable guardrails for input/output validation.
  • Extensible Architecture: Features modular components for memory, observability (OpenTelemetry), and multi-agent orchestration.
  • Language Bindings: Provides Python bindings, allowing developers to leverage the Rust core while writing agent logic in Python.

Related

  • Project
    yologdev/yoagent

    yoagent is a Rust crate that implements the reusable agent loop — streaming from any of 7 LLM protocols, running tools, and looping until done — so developers don't hand-write error-prone agent orchestration.

  • Project
    agentscope-ai/agentscope

    A production-ready agent framework that provides an SDK and a FastAPI backend to build multi-tenant, multi-session agentic applications leveraging LLM reasoning and tool use.

  • Project
    librefang/librefang

    An open-source Agent Operating System built in Rust that enables the deployment of autonomous, scheduled AI agents that work independently of manual prompts.

  • Project
    oxbshw/LLM-Agents-Ecosystem-Handbook

    A production-oriented handbook and toolkit for building LLM agent systems, featuring a multi-provider router, design templates, and comprehensive guides on memory, skills, and safety.

  • Project
    Abraxas-365/langchain-rust

    langchain-rust is a Rust implementation of LangChain, providing a framework for building LLM-powered applications with composable chains, agents, memory, document loaders, and integrations with many LLMs, embedding models, and vector stores.