[dependencies]
# Core DAA Framework
daa-orchestrator = "0.2.0"  # Core orchestration engine (coming soon)
daa-rules = "0.2.1"         # Rules and governance
daa-economy = "0.2.1"       # Economic management
daa-ai = "0.2.1"            # AI integration
daa-chain = "0.2.0"         # Blockchain abstraction (coming soon)
daa-compute = "0.2.0"       # Distributed compute (coming soon)
daa-swarm = "0.2.0"         # Swarm coordination (coming soon)

# Prime Distributed ML Framework
daa-prime-core = "0.2.1"        # Core ML types and protocols
daa-prime-dht = "0.2.1"         # Distributed hash table
daa-prime-trainer = "0.2.1"     # Distributed training nodes
daa-prime-coordinator = "0.2.1" # ML coordination layer
daa-prime-cli = "0.2.1"         # Command-line tools

use daa_orchestrator::{DaaOrchestrator, OrchestratorConfig};
use daa_rules::Rule;
use daa_economy::TokenManager;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Configure your agent
    let config = OrchestratorConfig {
        agent_name: "TreasuryBot".to_string(),
        autonomy_interval: Duration::from_secs(60),
        ..Default::default()
    };
    
    // 2. Create orchestrator with built-in capabilities
    let mut agent = DaaOrchestrator::new(config).await?;
    
    // 3. Add governance rules
    agent.rules_engine()
        .add_rule("max_daily_spend", 10_000)?
        .add_rule("risk_threshold", 0.2)?;
    
    // 4. Start autonomous operation
    println!("🚀 Starting autonomous treasury agent...");
    agent.run_autonomy_loop().await?;
    
    Ok(())
}

use daa_prime_trainer::{TrainerNode, TrainingConfig};
use daa_prime_coordinator::{CoordinatorNode, CoordinatorConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Start a coordinator node
    let coordinator = CoordinatorNode::new(
        "coordinator-001".to_string(),
        CoordinatorConfig::default()
    ).await?;
    
    // Start trainer nodes
    let trainer = TrainerNode::new("trainer-001".to_string()).await?;
    
    // Begin distributed training
    trainer.start_training().await?;
    
    Ok(())
}

// Agents can manage their own economics
let mut economy = TokenManager::new("rUv").await?;
economy.allocate_budget("operations", 50_000)?;
economy.set_auto_rebalancing(true)?;

// Reward ML training contributions
economy.reward_gradient_quality(node_id, quality_score).await?;

// Claude AI integration for intelligent decisions
let decision = agent.ai()
    .analyze_situation("Market volatility detected")
    .with_context(&market_data)
    .get_recommendation().await?;
    
// AI-guided distributed training
let training_plan = agent.ai()
    .optimize_training_strategy(&model_metrics)
    .await?;

// Define custom governance rules
agent.rules()
    .add_rule("training_hours", |ctx| {
        ctx.current_time().hour() >= 9 && ctx.current_time().hour() <= 17
    })?
    .add_rule("max_gradient_norm", |ctx| {
        ctx.gradient_norm() <= 10.0  // Prevent gradient explosion
    })?;

📦 DAA SDK Complete Architecture
├── 🎛️  daa-orchestrator     # Core coordination & autonomy loop
├── ⛓️  daa-chain           # Blockchain abstraction layer  
├── 💰 daa-economy          # Economic engine & token management
├── ⚖️  daa-rules           # Rule engine & governance system
├── 🧠 daa-ai               # AI integration & MCP client
├── 💻 daa-compute          # Distributed compute infrastructure
├── 🐝 daa-swarm            # Swarm coordination protocols
├── 🖥️  daa-cli             # Command-line interface & tools
│
└── 🚀 Prime ML Framework
    ├── 📋 daa-prime-core        # Core types & protocols
    ├── 🗄️  daa-prime-dht         # Distributed hash table
    ├── 🏋️  daa-prime-trainer     # Training nodes
    ├── 🎯 daa-prime-coordinator # Coordination layer
    └── 🔧 daa-prime-cli         # CLI tools

use daa_orchestrator::prelude::*;

let treasury_agent = DaaOrchestrator::builder()
    .with_role("treasury_manager")
    .with_rules([
        "max_daily_spend: 100000",
        "diversification_min: 0.1", 
        "risk_score_max: 0.3"
    ])
    .with_ai_advisor("claude-3-sonnet")
    .build().await?;

treasury_agent.start().await?;

use daa_prime_coordinator::*;
use daa_prime_trainer::*;

// Start coordinator
let coordinator = CoordinatorNode::new(
    "main-coordinator".to_string(),
    CoordinatorConfig {
        min_nodes_for_round: 5,
        consensus_threshold: 0.66,
        ..Default::default()
    }
).await?;

// Launch trainer swarm
for i in 0..10 {
    let trainer = TrainerNode::new(format!("trainer-{}", i)).await?;
    trainer.join_training_round().await?;
}

let yield_optimizer = DaaOrchestrator::builder()
    .with_role("yield_farmer")
    .with_ml_models(["yield_predictor", "risk_assessor"])
    .with_strategies(["aave", "compound", "uniswap_v3"])
    .with_rebalance_frequency(Duration::from_hours(4))
    .build().await?;

let dao_agent = DaaOrchestrator::builder()
    .with_role("dao_voter")
    .with_ml_advisor("governance_impact_model")
    .with_governance_rules("community_benefit_score > 0.7")
    .with_voting_power(1000)
    .build().await?;

let security_agent = DaaOrchestrator::builder()
    .with_role("security_monitor")
    .with_ml_models(["anomaly_detector", "threat_classifier"])
    .with_monitors(["smart_contracts", "treasury", "governance"])
    .with_emergency_actions(["pause_operations", "alert_team"])
    .build().await?;

use daa_swarm::*;

let swarm = SwarmCoordinator::builder()
    .with_strategy(SwarmStrategy::CollectiveIntelligence)
    .with_agents(50)
    .with_consensus(ConsensusType::Byzantine)
    .with_task("optimize_portfolio")
    .build().await?;

swarm.execute().await?;

# Install CLI globally
cargo install daa-cli daa-prime-cli

# Create new agent project
daa-cli init my-agent --template treasury

# Create new ML project
daa-prime-cli init my-ml-project --template federated

# Configure settings
daa-cli config set agent.name "MyTreasuryBot"
daa-cli config set economy.initial_balance 100000
daa-cli config set ai.model "claude-3-sonnet"

# Start agent with monitoring
daa-cli start --watch

# Check agent status
daa-cli status --detailed

# View live logs
daa-cli logs --follow --level info

# Emergency stop
daa-cli stop --emergency

# Start coordinator node
prime coordinator --id main-coord

# Start trainer nodes
prime trainer --id gpu-trainer-001

# Monitor training progress
prime status

# View training metrics
daa-cli ml metrics --live

# Performance dashboard
daa-cli dashboard

# Economic metrics
daa-cli economy stats

# ML training analytics
daa-cli ml analytics --round 42

# Rule execution history
daa-cli rules audit --since "1 day ago"

# AI decision analysis
daa-cli ai decisions --explain

# Deploy to production
daa-cli deploy --env production --verify

# Backup agent state
daa-cli backup create --encrypted

# Update agent rules
daa-cli rules update risk_threshold 0.15

# Network diagnostics
daa-cli network diagnose --peers

# Start swarm operation
daa-cli swarm start --agents 10 --task "distributed_training"

# Run all tests
cargo test --workspace

# Integration tests with real network
cargo test --features integration

# ML-specific tests
cargo test -p daa-prime-trainer --features gpu

# Benchmark performance
cargo bench

# Coverage report
cargo tarpaulin --out html

# Enable detailed logging
RUST_LOG=daa=debug cargo run

# Profile memory usage
cargo run --features profiling

# Trace autonomy loop execution
DAA_TRACE=true cargo run

# Debug ML training
RUST_LOG=daa_prime=trace cargo run

// Connect to QuDAG network
let network = QuDAGNetwork::connect(".dark").await?;
agent.join_network(network).await?;

// Anonymous peer discovery
let peers = agent.discover_peers("treasury.agents.dark").await?;

// Secure gradient sharing
let secure_channel = network.create_quantum_channel(peer).await?;

// Native integration with rUv tokens
let economy = agent.economy();
economy.mint_reward(agent_id, 1000).await?;
economy.transfer("alice.dark", 500).await?;

// ML training rewards
economy.reward_training_contribution(trainer_id, quality_score).await?;

🌟 Star us on GitHub if you find DAA useful!

Built with ❤️ by the DAA community