AutoAgents Rust Framework Adds Python Bindings for Prototyping

AutoAgents, a Rust-based multi-agent framework, has added Python bindings that let developers prototype in Python while keeping the underlying Rust core runtime intact. The approach maintains the same provider interfaces, pipeline composition model, agent builder structure, and runtime concepts used by the Rust crates.

Key Details

The Python bindings are designed for rapid experimentation in domains like robotics and other use cases requiring local AI, with the ability to transition to the Rust core without architectural changes. The framework supports local models without external system dependencies.

Here's a drop-in example from the source showing how to use the bindings:

from autoagents_llamacpp_cuda import LlamaCppBuilder, backend_build_info

async def main() -> None:
    print("Build info:", backend_build_info())
    
    llm = await (
        LlamaCppBuilder()
        .repo_id("unsloth/Qwen3.5-9B-GGUF")
        .hf_filename("Qwen3.5-9B-Q4_0.gguf")
        .max_tokens(256)
        .temperature(0.7)
        .build()
    )
    
    agent_def = ReActAgent("local_llama_cuda", "You are an helpful assistant").max_turns(10)
    
    handle = await (
        AgentBuilder(agent_def)
        .llm(llm)
        .memory(SlidingWindowMemory(window_size=20))
        .build()
    )
    
    result = await handle.run(Task(prompt="Write one short sentence about Rust."))
    print(result["response"])
    
    print("\n=== Streaming ===")
    async for chunk in handle.run_stream(Task(prompt="What is 10 + 32?")):
        print(chunk)

The example demonstrates several key components:

• LlamaCppBuilder for configuring local LLMs with parameters like repo_id, hf_filename, max_tokens, and temperature
• ReActAgent for defining agent behavior with turn limits
• AgentBuilder for assembling agents with LLM and memory components
• SlidingWindowMemory with configurable window size
• Both synchronous (run) and streaming (run_stream) execution modes
• Task objects for encapsulating prompts

The maintainers are seeking feedback on several aspects:

• Whether developers would use Python bindings like this for prototyping
• API ergonomics and naming conventions
• Missing features that would make iteration easier (debugging helpers, visualization, example recipes)
• Concerns around safety, streaming, or memory semantics

The framework is particularly relevant for developers who prototype in Python but deploy in Rust, offering a path from experimentation to production without changing the underlying architecture.