AgnosAI

Rust-native agent orchestration engine. Multi-agent crews with task DAGs, LLM routing, fleet distribution, and sandboxed tool execution.

AgnosAI replaces Python/CrewAI orchestration with a compiled Rust binary -- real concurrency, zero GIL, predictable performance. Use it standalone or as the core engine inside Agnostic.

Why

Architecture

agnosai
├── src/
│   ├── core/             Core types, traits, error handling
│   ├── orchestrator/     Task scheduling, agent scoring, crew execution
│   ├── llm/              LLM provider abstraction (8 providers, native HTTP)
│   ├── fleet/            Distributed fleet coordination, GPU scheduling [feature: fleet]
│   ├── sandbox/          Tool execution isolation (WASM, process, OCI) [feature: sandbox]
│   ├── tools/            Tool registry & execution (native, WASM, Python bridge)
│   ├── learning/         Adaptive learning & reinforcement learning
│   ├── server/           HTTP API server (REST, health probes, SSE)
│   └── definitions/      Preset library, crew assembly, packaging [feature: definitions]
├── benches/              Criterion benchmarks
├── tests/                Integration tests
├── examples/             Usage examples
└── docs/                 Guides, ADRs, architecture docs

See Architecture Overview for detailed design.

Quick Start

# Build
cargo build

# Run the API server
cargo run --bin agnosai-server

# Run tests
cargo test

# Run all CI checks locally
make check

Usage as a Library

Add to your Cargo.toml:

[dependencies]
agnosai = { git = "https://github.com/maccracken/agnosai" }

use agnosai::core::{AgentDefinition, CrewSpec, Task, ProcessMode, TaskPriority};
use agnosai::orchestrator::Orchestrator;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let orchestrator = Orchestrator::new(Default::default()).await?;

    // Define agents
    let analyst = AgentDefinition::from_json(r#"{
        "agent_key": "analyst",
        "name": "Analyst",
        "role": "data analyst",
        "goal": "analyze data",
        "domain": "data-engineering",
        "tools": ["json_transform"],
        "complexity": "high"
    }"#)?;

    // Build a crew with tasks and dependencies
    let mut task_a = Task::new("Gather quarterly revenue data");
    task_a.priority = TaskPriority::High;
    let mut task_b = Task::new("Analyze trends and anomalies");
    task_b.dependencies.push(task_a.id);

    let mut crew = CrewSpec::new("analysis-crew");
    crew.agents = vec![analyst];
    crew.tasks = vec![task_a, task_b];
    crew.process = ProcessMode::Dag;

    let result = orchestrator.run_crew(crew).await?;
    for r in &result.results {
        println!("[{}] {}", r.status, r.output);
    }
    Ok(())
}

Agent Definitions

Agents are defined declaratively in JSON -- same format as Agnostic v1 presets:

{
  "agent_key": "senior-qa-engineer",
  "name": "Senior QA Engineer",
  "role": "Senior QA Engineer",
  "goal": "Ensure comprehensive test coverage and quality standards",
  "domain": "quality",
  "tools": ["code_analysis", "test_generation", "edge_case_analysis"],
  "complexity": "high",
  "llm_model": "capable"
}

LLM Providers

Native HTTP implementations -- no Python SDKs, no litellm:

Task-complexity routing automatically selects the right model tier (Fast / Capable / Premium).

Tool Execution

Tools run in three tiers with increasing isolation:

1. Native Rust -- in-process, zero overhead
2. WASM -- wasmtime sandbox, memory-isolated, capability-controlled
3. Sandboxed Python -- subprocess with seccomp-bpf + Landlock + cgroups + network namespace

Fleet Distribution

First-class multi-node support:

• Node registry with heartbeat + TTL
• 5 placement policies (GPU-affinity, balanced, locality, cost, manual)
• Inter-node relay via Redis pub/sub or gRPC
• Barrier sync and checkpoint-based crew state
• GPU detection and VRAM-aware scheduling
• Multi-cluster federation

Test Suite

$ cargo test
...
test result: ok. 323 passed; 0 failed; 0 ignored

Tests cover core types, orchestration (all 4 process modes), DAG cycle detection, agent scoring, priority scheduling, pub/sub, IPC, LLM provider routing, tool registry, and API routes.

Documentation

See the docs/ directory:

• Getting Started
• Architecture Overview
• Crew Execution Patterns
• API Reference
• Adding LLM Providers
• Adding Native Tools
• Roadmap

Project Status

See docs/development/roadmap.md for the full development plan and current phase.

License

AGPL-3.0-only — see LICENSE for details.