Crate infernum_legion 

Legion - Holographic Agent Swarm

“We are Legion, for we are many. We think as one, but we see from all perspectives.”

Legion enables collective intelligence through holographic agent coordination, where every agent sees the WHOLE task but emphasizes different frequency bands. This is not task decomposition - it’s multiple perspectives on the same reality.

Core Principles

1. Holographic Distribution: Each agent receives the FULL task but emphasizes their frequency band using spectral filtering. Any subset can produce an answer.

2. Wave Interference Consensus: Agent contributions superimpose in the Legion Field. Constructive interference = agreement. Destructive interference = conflict.

3. Graceful Degradation: Quality scales with agent count, but never fails. First fragment = 60% quality. More agents = progressive refinement.

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                         ORCHESTRATOR                            │
│  Distributes holographic task fragments, gathers contributions  │
└───────────────────────────┬─────────────────────────────────────┘
                            │
    ┌───────────┬───────────┼───────────┬───────────┐
    │           │           │           │           │
    ▼           ▼           ▼           ▼           ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Anima   │ │Strategic│ │Tactical │ │Operative│ │Reflectv │
│ DC (∿)  │ │ (⟁)     │ │ (⟀)     │ │ (⊕)     │ │ (◉)     │
│ Core ID │ │Planning │ │ Steps   │ │ Work    │ │ Meta    │
└─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘
    │           │           │           │           │
    └───────────┴───────────┴───────────┴───────────┘
                            │
                            ▼
           ┌────────────────────────────────┐
           │       LEGION FIELD (∿)         │
           │  Contributions superimpose     │
           │  Interference → Consensus      │
           └────────────────────────────────┘

Frequency Bands

• Anima: Core identity (DC component) - never filtered out
• Strategic: High-level planning (ultra-low freq, 0.0-0.1)
• Tactical: Step-by-step execution (low freq, 0.1-0.3)
• Operational: The actual work (mid freq, 0.3-0.6)
• Verification: Quality checking (high freq, 0.6-0.9)
• Reflective: Meta-cognition (ultra-high freq, 0.9-1.0)

Example

use legion::{Legion, LegionConfig, FrequencyBand};

let legion = Legion::builder()
    .with_agent_count(6)
    .with_quality_target(0.9)
    .build()?;

// Fast response from strategic agents
let quick = legion.query("What is 2+2?", FrequencyBand::Strategic).await?;

// High quality from reflective agents (full context)
let quality = legion.query("Analyze this codebase", FrequencyBand::Reflective).await?;

Re-exports

pub use agent::AgentConfig;

pub use agent::AgentState;

pub use agent::LegionAgent;

pub use consensus::AgentContribution as ConsensusContribution;

pub use consensus::ConsensusResult;

pub use consensus::ConsensusStrategy;

pub use consensus::InterferenceConfig;

pub use consensus::InterferenceConsensus;

pub use consensus::InterferenceResult;

pub use context::ContextFragment;

pub use context::FragmentId;

pub use context::SharedContext;

pub use fault::AgentHealth;

pub use fault::DegradationCause;

pub use fault::DegradationEvent;

pub use fault::DegradationManager;

pub use fault::FailureReason;

pub use fault::FaultConfig;

pub use fault::HealthCheckResult;

pub use fault::HealthMonitor;

pub use fault::HealthStats;

pub use fault::HealthStatusChange;

pub use fault::RecoveryManager;

pub use fault::RecoveryOperation;

pub use fault::RecoveryStats;

pub use fault::RecoveryType;

pub use fault::RespawnRequest;

pub use field::DetailCoefficients;

pub use field::EssentialCoefficients;

pub use field::FieldConfig;

pub use field::LegionField;

pub use field::LegionPattern;

pub use field::Resonance;

pub use orchestrator::Orchestrator;

pub use orchestrator::TaskRouting;

pub use quality::FrequencyBand;

pub use quality::QualityCurve;

pub use quality::QualityMetrics;

pub use quality::QualityTarget;

pub use quality::SpectralFilter;

pub use spectral_merge::BlendComponent;

pub use spectral_merge::BlendStats;

pub use spectral_merge::BlendedModel;

pub use spectral_merge::DynamicBlendController;

pub use spectral_merge::LayerDecomposition;

pub use spectral_merge::LayerType;

pub use spectral_merge::LayerWeights;

pub use spectral_merge::SpectralBlend;

pub use spectral_merge::SpectralDecomposition;

pub use spectral_merge::SpectralMergeError;

pub use speculative::DraftGenerator;

pub use speculative::DraftGeneratorConfig;

pub use speculative::DraftPool;

pub use speculative::DraftSequence;

pub use speculative::QualityCurve as SpeculativeQualityCurve;

pub use speculative::RankedPath;

pub use speculative::SpeculativeLegion;

pub use speculative::SpeculativeLegionConfig;

pub use speculative::SpeculativeStats;

pub use speculative::TokenId;

pub use speculative::VerificationResult;

pub use speculative::VerificationStats;

Modules

agent

Legion agent implementation.

consensus

Consensus strategies for merging agent outputs.

context

Shared context management for Legion.

fault

Fault Tolerance: Graceful Degradation in the Collective

field

Legion Field - The collective memory substrate.

orchestrator

Task orchestration for Legion.

quality

Quality management for Legion agents.

spectral_merge

Spectral Model Merging - Runtime model blending via spectral coefficient superposition.

speculative

Speculative Legion Decoding

Structs

Legion

The main Legion swarm coordinator.

LegionConfig

Configuration for a Legion instance.

LegionConfigBuilder

Builder for LegionConfig.

Enums

LegionError

Errors from Legion operations.

Type Aliases

Result

Result type for Legion operations.