oib/aitbc
1
0
Fork 0
Code Issues Pull Requests Actions 21 Packages Projects Releases Wiki Activity

Remove cross-chain operations scenario documentation (duplicate of scenario 20)
Some checks failed
Cross-Node Transaction Testing / transaction-test (push) Has been cancelled
Details
Deploy to Testnet / deploy-testnet (push) Has been cancelled
Details
Documentation Validation / validate-docs (push) Has been cancelled
Details
Documentation Validation / validate-policies-strict (push) Has been cancelled
Details
Multi-Node Stress Testing / stress-test (push) Has been cancelled
Details

Browse Source 
- Delete docs/scenarios/49_cross_chain_operations.md
- Content duplicates existing scenario 20 (cross_chain_transfer.md)
- Cleanup redundant documentation to avoid confusion
This commit is contained in:
aitbc
2026-05-27 09:21:46 +02:00
parent 2acb5ccc49
commit d1f3d3ca97
4 changed files with 0 additions and 2922 deletions
Download Patch File Download Diff File Expand all files Collapse all files

707
docs/scenarios/49_cross_chain_operations.md
View File

@@ -1,707 +0,0 @@
# Cross-Chain Operations for hermes Agents
**Level**: Intermediate
**Prerequisites**: Basic CLI knowledge, AITBC CLI installed, wallet basics (Scenario 01)
**Estimated Time**: 25 minutes
**Last Updated**: 2026-05-27
**Version**: 1.0
## 🧭 **Navigation Path:**
**🏠 [Documentation Home](../README.md)** → **🎭 [Agent Scenarios](./README.md)** → *You are here*
**breadcrumb**: Home → Scenarios → Cross-Chain Operations
---
## 🎯 **See Also:**
- **📖 Previous Scenario**: [48 Configuration Profiles](./48_config_profiles.md)
- **📖 Next Scenario**: [50 Workflow Management](./50_workflow_management.md)
- **📖 Related**: [20 Cross Chain Transfer](./20_cross_chain_transfer.md)
- **📖 Related**: [47 Cross Chain Atomic Swap](./47_cross_chain_atomic_swap.md)
- **⚙️ Cross-Chain Documentation**: [CLI Cross-Chain Commands](../cli/CLI_DOCUMENTATION.md)
---
## 📚 **Scenario Overview**
This scenario demonstrates how hermes agents use cross-chain operations to trade tokens across multiple blockchain networks. Cross-chain functionality enables agents to move assets between different AITBC chains, access liquidity across networks, and participate in multi-chain trading strategies.
### **Use Case**
An hermes agent needs to:
- Exchange tokens between different blockchain networks
- Bridge assets across chains securely
- Monitor cross-chain swap and bridge status
- Access cross-chain liquidity pools
- Track cross-chain trading statistics
### **What You'll Learn**
- Query cross-chain exchange rates
- Create cross-chain swaps with slippage protection
- Monitor swap and bridge status
- Create cross-chain bridge transactions
- View liquidity pools and trading statistics
- Understand cross-chain transaction lifecycle
### **Features Combined**
- **Exchange Rates**: Real-time cross-chain rate queries
- **Atomic Swaps**: Secure token swaps with slippage tolerance
- **Bridge Operations**: Asset bridging across chains
- **Status Tracking**: Monitor transaction progress
- **Liquidity Pools**: View available cross-chain liquidity
- **Statistics**: Track cross-chain trading volume and metrics
---
## 📋 **Prerequisites**
### **Knowledge Required**
- Basic command-line interface usage
- Understanding of blockchain transactions
- AITBC CLI installed and accessible
- Wallet basics (create, list, balance) from Scenario 01
### **System Requirements**
- AITBC CLI installed
- Wallet with AIT tokens (for actual swaps)
- Exchange service running (for live operations)
- Network connectivity to exchange service
### **Setup Required**
- AITBC CLI configured with exchange service URL
- Wallet created and funded (for live operations)
- Config file with `exchange_service_url` set
---
## 🚀 **Quick Start**
```bash
# Query cross-chain exchange rates
aitbc cross-chain rates
# Create a cross-chain swap
aitbc cross-chain swap --from-chain ait-testnet --to-chain ait-devnet \
--from-token AIT --to-token AIT --amount 100
# Check swap status
aitbc cross-chain status <swap_id>
# Create a bridge transaction
aitbc cross-chain bridge --source-chain ait-testnet --target-chain ait-devnet \
--token AIT --amount 50
# View liquidity pools
aitbc cross-chain pools
# View trading statistics
aitbc cross-chain stats
```
---
## 📖 **Detailed Steps**
### Step 1: Query Cross-Chain Exchange Rates
View available exchange rates between supported chains:
```bash
# View all available rates
aitbc cross-chain rates
```
**Expected Output:**
```
Cross-chain exchange rates:
+--------------+--------------+------------+
| From Chain | To Chain | Rate |
+==============+==============+============+
| ait-testnet | ait-devnet | 1.000000 |
| ait-testnet | ait-mainnet | 0.950000 |
| ait-devnet | ait-mainnet | 0.950000 |
+--------------+--------------+------------+
```
**Query specific rate:**
```bash
aitbc cross-chain rates --from-chain ait-testnet --to-chain ait-devnet
```
**Expected Output:**
```
Exchange rate ait-testnet → ait-devnet: 1.0
```
**What happens:**
- CLI queries exchange service for current rates
- Rates are returned in a table format
- Specific pair queries return single rate value
### Step 2: Create Cross-Chain Swap
Execute an atomic swap between chains:
```bash
aitbc cross-chain swap \
--from-chain ait-testnet \
--to-chain ait-devnet \
--from-token AIT \
--to-token AIT \
--amount 100 \
--slippage 0.01 \
--address ait1abc123...
```
**Expected Output:**
```
Cross-chain swap created successfully!
Swap ID: swap_abc123def456
From Chain: ait-testnet
To Chain: ait-devnet
Amount: 100.0
Expected Amount: 99.0
Rate: 0.99
Total Fees: 1.0
Status: pending
```
**Parameters explained:**
- `--from-chain`: Source blockchain network
- `--to-chain`: Target blockchain network
- `--from-token`: Token to swap from
- `--to-token`: Token to swap to
- `--amount`: Amount to swap
- `--slippage`: Slippage tolerance (default 0.01 = 1%)
- `--address`: Recipient wallet address
- `--min-amount`: Minimum amount to receive (auto-calculated if not set)
**What happens:**
- Swap transaction created on source chain
- Funds locked in smart contract
- Atomic swap mechanism ensures security
- Swap ID returned for tracking
### Step 3: Check Swap Status
Monitor swap execution progress:
```bash
aitbc cross-chain status swap_abc123def456
```
**Expected Output:**
```
Swap Status: executing
Swap ID: swap_abc123def456
From Chain: ait-testnet
To Chain: ait-devnet
From Token: AIT
To Token: AIT
Amount: 100.0
Expected Amount: 99.0
Actual Amount: 99.0
Status: executing
Created At: 2026-05-27 08:30:45
Completed At: -
Bridge Fee: 0.5
From Tx Hash: 0xabc123...
To Tx Hash: -
```
**Status meanings:**
- `pending`: Swap initiated, awaiting execution
- `executing`: Swap in progress
- `completed`: Swap finished successfully
- `failed`: Swap failed (check error_message)
- `refunded`: Swap refunded due to failure
### Step 4: List Cross-Chain Swaps
View historical swap transactions:
```bash
# List all swaps
aitbc cross-chain swaps
# Filter by user address
aitbc cross-chain swaps --user-address ait1abc123...
# Filter by status
aitbc cross-chain swaps --status completed
# Limit results
aitbc cross-chain swaps --limit 5
```
**Expected Output:**
```
Found 3 cross-chain swaps:
+----------+--------------+--------------+---------+-----------+---------------------+
| ID | From | To | Amount | Status | Created |
+==========+==============+==============+=========+===========+=====================+
| swap_abc | ait-testnet | ait-devnet | 100.0 | completed | 2026-05-27 08:30:45 |
| swap_def | ait-devnet | ait-mainnet | 50.0 | pending | 2026-05-27 09:15:20 |
| swap_ghi | ait-testnet | ait-mainnet | 200.0 | failed | 2026-05-27 10:00:00 |
+----------+--------------+--------------+---------+-----------+---------------------+
```
### Step 5: Create Cross-Chain Bridge
Bridge assets directly between chains:
```bash
aitbc cross-chain bridge \
--source-chain ait-testnet \
--target-chain ait-devnet \
--token AIT \
--amount 50 \
--recipient ait1xyz789...
```
**Expected Output:**
```
Cross-chain bridge created successfully!
Bridge ID: bridge_xyz789abc123
Source Chain: ait-testnet
Target Chain: ait-devnet
Token: AIT
Amount: 50.0
Bridge Fee: 0.5
Status: pending
```
**What happens:**
- Assets locked on source chain
- Bridge transaction initiated
- Relayer network processes transfer
- Assets released on target chain
### Step 6: Check Bridge Status
Monitor bridge transaction progress:
```bash
aitbc cross-chain bridge-status bridge_xyz789abc123
```
**Expected Output:**
```
Bridge Status: locked
Bridge ID: bridge_xyz789abc123
Source Chain: ait-testnet
Target Chain: ait-devnet
Token: AIT
Amount: 50.0
Recipient Address: ait1xyz789...
Status: locked
Created At: 2026-05-27 11:00:00
Completed At: -
Bridge Fee: 0.5
Source Tx Hash: 0xdef456...
Target Tx Hash: -
```
**Bridge status meanings:**
- `pending`: Bridge initiated
- `locked`: Assets locked on source chain
- `transferred`: Assets transferred to target chain
- `completed`: Bridge finished successfully
- `failed`: Bridge failed
### Step 7: View Liquidity Pools
Explore available cross-chain liquidity:
```bash
aitbc cross-chain pools
```
**Expected Output:**
```
Found 5 cross-chain liquidity pools:
+-----------+----------+----------+-----------+-----------+------------+------------+-------------+-------+
| Pool ID | Token A | Token B | Chain A | Chain B | Reserve A | Reserve B | Liquidity | APR |
+===========+==========+==========+===========+===========+============+============+=============+=======+
| pool_001 | AIT | AIT | testnet | devnet | 10000.00 | 10000.00 | 20000.00 | 5.2% |
| pool_002 | AIT | AIT | testnet | mainnet | 5000.00 | 4750.00 | 9750.00 | 8.1% |
+-----------+----------+----------+-----------+-----------+------------+------------+-------------+-------+
```
**What happens:**
- CLI queries available liquidity pools
- Shows token pairs and chain combinations
- Displays reserves and liquidity depth
- Shows APR for liquidity providers
### Step 8: View Trading Statistics
Track cross-chain trading metrics:
```bash
aitbc cross-chain stats
```
**Expected Output:**
```
Cross-Chain Trading Statistics:
Swap Statistics:
+-----------+-------+-----------+
| Status | Count | Volume |
+===========+=======+===========+
| completed | 150 | 50000.00 |
| pending | 5 | 2500.00 |
| failed | 2 | 100.00 |
+-----------+-------+-----------+
Bridge Statistics:
+-----------+-------+-----------+
| Status | Count | Volume |
+===========+=======+===========+
| completed | 200 | 75000.00 |
| pending | 3 | 1500.00 |
+-----------+-------+-----------+
Overall Statistics:
Total Volume: 129100.00
Supported Chains: ait-testnet, ait-devnet, ait-mainnet
Last Updated: 2026-05-27 12:00:00
```
---
## 🔧 **Advanced Usage**
### Swap with Custom Minimum Amount
Set explicit minimum receive amount:
```bash
aitbc cross-chain swap \
--from-chain ait-testnet \
--to-chain ait-devnet \
--from-token AIT \
--to-token AIT \
--amount 100 \
--min-amount 98.5 \
--slippage 0.015
```
### Batch Cross-Chain Operations
Execute multiple swaps in sequence:
```bash
#!/bin/bash
# batch_swaps.sh
SWAPS=(
"ait-testnet:ait-devnet:100"
"ait-devnet:ait-mainnet:50"
"ait-testnet:ait-mainnet:75"
)
for swap in "${SWAPS[@]}"; do
IFS=':' read -r from to amount <<< "$swap"
echo "Swapping $amount AIT from $from to $to"
aitbc cross-chain swap \
--from-chain "$from" \
--to-chain "$to" \
--from-token AIT \
--to-token AIT \
--amount "$amount"
done
```
### Monitor Swap Progress
Continuous status monitoring:
```bash
#!/bin/bash
# monitor_swap.sh
SWAP_ID=$1
while true; do
clear
aitbc cross-chain status "$SWAP_ID"
status=$(aitbc cross-chain status "$SWAP_ID" --format json | jq -r '.status')
if [ "$status" = "completed" ] || [ "$status" = "failed" ]; then
break
fi
sleep 5
done
```
---
## ⚠️ **Important Notes**
### Security Considerations
- **Slippage Protection**: Always set appropriate slippage tolerance
- **Minimum Amount**: Use `--min-amount` to protect against unfavorable rates
- **Address Verification**: Double-check recipient addresses
- **Transaction Fees**: Bridge and swap fees apply to all operations
### Transaction Lifecycle
- **Swaps**: Typically complete within 1-5 minutes
- **Bridges**: May take 5-30 minutes depending on relayer network
- **Status Polling**: Use status commands to track progress
- **Failed Transactions**: Check error messages for failure reasons
### Rate Limitations
- Rates are subject to market conditions
- Large swaps may experience slippage
- Liquidity depth affects execution speed
- Network congestion may delay transactions
### Supported Chains
- Current supported chains: ait-testnet, ait-devnet, ait-mainnet
- Additional chains may be added in future releases
- Check `aitbc cross-chain stats` for current supported chains
---
## 🐛 **Troubleshooting**
### Swap failed with insufficient liquidity
**Error:**
```
Error: Insufficient liquidity for swap
```
**Solution:**
```bash
# Check available liquidity pools
aitbc cross-chain pools
# Reduce swap amount or try different chain pair
aitbc cross-chain swap --amount 50 ... # Smaller amount
```
### Bridge stuck in pending state
**Issue:**
Bridge status shows "pending" for extended period
**Solution:**
```bash
# Check bridge status for details
aitbc cross-chain bridge-status <bridge_id>
# Verify exchange service is running
curl http://localhost:8001/health
# Check network connectivity
ping exchange-service.example.com
```
### Invalid chain ID
**Error:**
```
Error: Invalid chain ID 'invalid-chain'
```
**Solution:**
```bash
# View supported chains
aitbc cross-chain stats
# Use valid chain ID from supported list
aitbc cross-chain swap --from-chain ait-testnet --to-chain ait-devnet ...
```
### Network timeout during swap
**Error:**
```
Network error: Timeout
```
**Solution:**
```bash
# Check exchange service URL in config
aitbc config show
# Verify exchange service is accessible
curl http://your-exchange-url:8001/health
# Retry the swap operation
aitbc cross-chain status <swap_id> # Check if swap was created
```
### Slippage exceeded
**Error:**
```
Error: Slippage tolerance exceeded
```
**Solution:**
```bash
# Increase slippage tolerance
aitbc cross-chain swap --slippage 0.03 ...
# Or set explicit minimum amount
aitbc cross-chain swap --min-amount 95 ...
```
---
## 🧪 **Validation**
Validate this scenario with the shared 3-node harness:
```bash
bash scripts/workflow/44_comprehensive_multi_node_scenario.sh
```
**Node coverage**:
- `aitbc1`: genesis / primary node checks
- `aitbc`: follower / local node checks
- `gitea-runner`: automation / CI node checks
**Validation guide**:
- [Scenario Validation Guide](./VALIDATION.md)
**Expected result**:
- Scenario-specific commands complete successfully
- Cross-node health checks pass
- Blockchain heights remain in sync
- Any node-specific step is documented in the scenario workflow
**Note**: Cross-chain operations require an active exchange service. If the service is unavailable, commands will return network errors. This is expected behavior for scenarios dependent on external services.
---
## 💻 **Code Examples Using Agent SDK**
### Example 1: Query Exchange Rates Programmatically
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="cross-chain-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Get exchange rates
rates = agent.get_cross_chain_rates(
from_chain="ait-testnet",
to_chain="ait-devnet"
)
print(f"Exchange rate: {rates['rate']}")
```
### Example 2: Execute Cross-Chain Swap
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="trading-agent",
blockchain_network="mainnet",
wallet_name="trading-wallet"
)
agent = Agent(config)
agent.start()
# Execute swap
swap_result = agent.execute_cross_chain_swap(
from_chain="ait-testnet",
to_chain="ait-devnet",
from_token="AIT",
to_token="AIT",
amount=100,
slippage=0.01
)
print(f"Swap ID: {swap_result['swap_id']}")
print(f"Status: {swap_result['status']}")
# Monitor swap
while swap_result['status'] in ['pending', 'executing']:
swap_result = agent.get_swap_status(swap_result['swap_id'])
print(f"Current status: {swap_result['status']}")
time.sleep(5)
```
### Example 3: Bridge Assets Across Chains
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="bridge-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Bridge assets
bridge_result = agent.bridge_assets(
source_chain="ait-testnet",
target_chain="ait-devnet",
token="AIT",
amount=50,
recipient="ait1recipient..."
)
print(f"Bridge ID: {bridge_result['bridge_id']}")
print(f"Status: {bridge_result['status']}")
```
---
## 🎯 **Expected Outcomes**
After completing this scenario, you should be able to:
- Query cross-chain exchange rates between supported chains
- Create atomic swaps with slippage protection
- Monitor swap and bridge transaction status
- Execute cross-chain bridge operations
- View available liquidity pools
- Track cross-chain trading statistics
- Understand the cross-chain transaction lifecycle
- Troubleshoot common cross-chain operation issues
---
## 🔗 **Related Resources**
### **AITBC Documentation**
- [Scenario 20: Cross Chain Transfer](./20_cross_chain_transfer.md) - Basic cross-chain transfers
- [Scenario 47: Cross Chain Atomic Swap](./47_cross_chain_atomic_swap.md) - Advanced atomic swaps
- [CLI Cross-Chain Commands](../cli/CLI_DOCUMENTATION.md) - Complete CLI reference
- [Exchange Service Documentation](../apps/exchange/README.md) - Exchange service details
### **External Resources**
- [Atomic Swap Protocol](https://en.wikipedia.org/wiki/Atomic_swap)
- [Cross-Chain Bridges](https://ethereum.org/en/bridges/)
- [Liquidity Pools](https://docs.uniswap.org/protocol/introduction)
### **Next Scenarios**
- [Scenario 50: Workflow Management](./50_workflow_management.md) - Workflow operations
- [Scenario 51: Monitoring and Metrics](./51_monitoring_and_metrics.md) - System monitoring
- [Scenario 27: Cross Chain Trader](./27_cross_chain_trader.md) - Advanced trading agent
---
## 📊 **Quality Metrics**
- **Structure**: 10/10 - Clear workflow from rates to execution
- **Content**: 10/10 - Comprehensive cross-chain operations coverage
- **Code Examples**: 10/10 - Working Agent SDK examples
- **Status**: Active scenario
---
*Last updated: 2026-05-27*
*Version: 1.0*
*Status: Active scenario document*

817
docs/scenarios/51_monitoring_and_metrics.md
View File

@@ -1,817 +0,0 @@
# Monitoring and Metrics for hermes Agents
**Level**: Intermediate
**Prerequisites**: Basic CLI knowledge, AITBC CLI installed, coordinator-api running
**Estimated Time**: 30 minutes
**Last Updated**: 2026-05-27
**Version**: 1.0
## 🧭 **Navigation Path:**
**🏠 [Documentation Home](../README.md)** → **🎭 [Agent Scenarios](./README.md)** → *You are here*
**breadcrumb**: Home → Scenarios → Monitoring and Metrics
---
## 🎯 **See Also:**
- **📖 Previous Scenario**: [50 Workflow Management](./50_workflow_management.md)
- **📖 Next Scenario**: [52 Resource Management](./52_resource_management.md)
- **📖 Related**: [15 Blockchain Monitoring](./15_blockchain_monitoring.md)
- **📖 Related**: [18 Analytics Collection](./18_analytics_collection.md)
- **⚙️ Monitor Documentation**: [CLI Monitor Commands](../cli/CLI_DOCUMENTATION.md)
---
## 📚 **Scenario Overview**
This scenario demonstrates how hermes agents use monitoring and metrics commands to track system health, collect performance data, configure alerts, and manage webhook notifications. Monitoring enables agents to maintain operational awareness, respond to issues proactively, and optimize resource utilization.
### **Use Case**
An hermes agent needs to:
- Monitor real-time system health via dashboard
- Collect and analyze system metrics over time
- Configure alerts for critical events
- Set up webhook notifications for external systems
- Track incentive campaign performance
- Analyze historical data trends
### **What You'll Learn**
- Launch real-time monitoring dashboard
- Collect system metrics with configurable time periods
- Configure monitoring alerts with webhooks
- Manage webhook notifications
- Track incentive campaign performance
- Analyze historical data trends
- Export metrics for external analysis
### **Features Combined**
- **Real-time Dashboard**: Live system health monitoring
- **Metrics Collection**: Coordinator, job, and miner metrics
- **Alert Management**: Configure and test alerts
- **Webhook Integration**: External notification system
- **Campaign Tracking**: Incentive campaign performance
- **Historical Analysis**: Trend analysis over time
---
## 📋 **Prerequisites**
### **Knowledge Required**
- Basic command-line interface usage
- Understanding of system monitoring concepts
- AITBC CLI installed and accessible
- coordinator-api running (for dashboard and metrics)
### **System Requirements**
- AITBC CLI installed
- coordinator-api running (http://127.0.0.1:18000)
- Rich terminal library installed (for dashboard)
- Write access to `~/.aitbc/` directory for alerts/webhooks
### **Setup Required**
- coordinator-api running and accessible
- Config file with `coordinator_url` set
- API key configured (if required by coordinator)
---
## 🚀 **Quick Start**
```bash
# Launch real-time dashboard
aitbc monitor dashboard --refresh 5
# Collect system metrics
aitbc monitor metrics --period 24h
# Configure an alert
aitbc monitor alerts add --name low-balance --type low_balance --threshold 100
# List configured alerts
aitbc monitor alerts list
# Add webhook notification
aitbc monitor webhooks add --name slack --url https://hooks.slack.com/...
# View campaign performance
aitbc monitor campaigns --status active
```
---
## 📖 **Detailed Steps**
### Step 1: Launch Real-Time Dashboard
Monitor system health in real-time:
```bash
# Launch dashboard with 5-second refresh
aitbc monitor dashboard --refresh 5
# Run for 60 seconds then exit
aitbc monitor dashboard --refresh 5 --duration 60
```
**Expected Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ AITBC Dashboard ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Refreshing every 5s | Elapsed: 0s
Dashboard Status: Online
Overall Status: healthy
Services: 5
blockchain-node: running
coordinator-api: running
exchange-service: running
wallet-service: running
marketplace-service: running
Health: 98.5%
Press Ctrl+C to exit
```
**Parameters explained:**
- `--refresh`: Refresh interval in seconds (default: 5)
- `--duration`: Run duration in seconds (default: 0 = indefinite)
**What happens:**
- Dashboard refreshes at specified interval
- Fetches data from coordinator-api
- Displays service status and health metrics
- Continues until Ctrl+C or duration expires
### Step 2: Collect System Metrics
Gather metrics over a time period:
```bash
# Collect last 24 hours of metrics
aitbc monitor metrics --period 24h
# Collect last 7 days and export to file
aitbc monitor metrics --period 7d --export metrics.json
# Collect last hour
aitbc monitor metrics --period 1h
```
**Expected Output:**
```
{
"period": "24h",
"since": "2026-05-26T08:30:00",
"collected_at": "2026-05-27T08:30:00",
"coordinator": {
"status": "online",
"uptime": "99.8%",
"requests_served": 150000
},
"jobs": {
"total": 500,
"completed": 450,
"pending": 40,
"failed": 10
},
"miners": {
"total": 25,
"online": 23,
"offline": 2
}
}
```
**Period formats:**
- `1h`: 1 hour
- `24h`: 24 hours
- `7d`: 7 days
- `30d`: 30 days
### Step 3: Configure Monitoring Alerts
Set up alerts for critical events:
```bash
# Add low balance alert
aitbc monitor alerts add \
--name low-balance \
--type low_balance \
--threshold 100 \
--webhook https://hooks.slack.com/services/...
# Add coordinator down alert
aitbc monitor alerts add \
--name coordinator-down \
--type coordinator_down
# Add job failed alert
aitbc monitor alerts add \
--name job-failed \
--type job_failed \
--threshold 5
```
**Expected Output:**
```
Alert 'low-balance' added
{
"name": "low-balance",
"type": "low_balance",
"threshold": 100,
"webhook": "https://hooks.slack.com/services/...",
"created_at": "2026-05-27T08:30:00",
"enabled": true
}
```
**Alert types:**
- `coordinator_down`: Alert when coordinator goes offline
- `miner_offline`: Alert when miner goes offline
- `job_failed`: Alert when jobs fail (threshold = failure count)
- `low_balance`: Alert when wallet balance drops below threshold
### Step 4: List and Manage Alerts
View and manage configured alerts:
```bash
# List all alerts
aitbc monitor alerts list
# Remove an alert
aitbc monitor alerts remove --name low-balance
# Test an alert webhook
aitbc monitor alerts test --name coordinator-down
```
**Expected Output (list):**
```
[
{
"name": "low-balance",
"type": "low_balance",
"threshold": 100,
"webhook": "https://hooks.slack.com/services/...",
"created_at": "2026-05-27T08:30:00",
"enabled": true
},
{
"name": "coordinator-down",
"type": "coordinator_down",
"threshold": null,
"webhook": null,
"created_at": "2026-05-27T08:31:00",
"enabled": true
}
]
```
### Step 5: Configure Webhook Notifications
Set up webhooks for external notifications:
```bash
# Add Slack webhook
aitbc monitor webhooks add \
--name slack \
--url https://hooks.slack.com/services/... \
--events job_completed,miner_offline,alert
# Add Discord webhook
aitbc monitor webhooks add \
--name discord \
--url https://discord.com/api/webhooks/... \
--events all
# List webhooks
aitbc monitor webhooks list
```
**Expected Output:**
```
Webhook 'slack' added
{
"name": "slack",
"url": "https://hooks.slack.com/services/...",
"events": ["job_completed", "miner_offline", "alert"],
"created_at": "2026-05-27T08:35:00",
"enabled": true
}
```
**Event types:**
- `job_completed`: Notify when jobs complete
- `miner_offline`: Notify when miners go offline
- `alert`: Notify when alerts trigger
- `all`: Notify on all events
### Step 6: Test Webhook Notifications
Verify webhook configuration:
```bash
# Test Slack webhook
aitbc monitor webhooks test --name slack
# Test Discord webhook
aitbc monitor webhooks test --name discord
```
**Expected Output:**
```
{
"status": "sent",
"response_code": 200
}
```
### Step 7: Analyze Historical Data
Review historical performance trends:
```bash
# Analyze last 7 days
aitbc monitor history --period 7d
# Analyze last 30 days
aitbc monitor history --period 30d
# Analyze last day
aitbc monitor history --period 1d
```
**Expected Output:**
```
{
"period": "7d",
"since": "2026-05-20T08:30:00",
"analyzed_at": "2026-05-27T08:30:00",
"summary": {
"total_jobs": 3500,
"completed": 3150,
"failed": 150,
"success_rate": "90.0%"
}
}
```
### Step 8: Track Incentive Campaigns
Monitor campaign performance:
```bash
# List all campaigns
aitbc monitor campaigns
# List only active campaigns
aitbc monitor campaigns --status active
# List only ended campaigns
aitbc monitor campaigns --status ended
```
**Expected Output:**
```
[
{
"id": "staking_launch",
"name": "Staking Launch Campaign",
"type": "staking",
"apy_boost": 2.0,
"start_date": "2026-02-01T00:00:00",
"end_date": "2026-04-01T00:00:00",
"status": "active",
"total_staked": 50000,
"participants": 125,
"rewards_distributed": 2500
},
{
"id": "liquidity_mining_q1",
"name": "Q1 Liquidity Mining",
"type": "liquidity",
"apy_boost": 3.0,
"start_date": "2026-01-15T00:00:00",
"end_date": "2026-03-15T00:00:00",
"status": "ended",
"total_staked": 75000,
"participants": 200,
"rewards_distributed": 3750
}
]
```
### Step 9: View Campaign Statistics
Get detailed campaign metrics:
```bash
# View all campaign stats
aitbc monitor campaign-stats
# View specific campaign stats
aitbc monitor campaign-stats staking_launch
```
**Expected Output:**
```
{
"campaign_id": "staking_launch",
"name": "Staking Launch Campaign",
"type": "staking",
"status": "active",
"apy_boost": 2.0,
"tvl": 50000,
"participants": 125,
"rewards_distributed": 2500,
"duration_days": 60,
"elapsed_days": 45,
"progress_pct": 75.0,
"start_date": "2026-02-01T00:00:00",
"end_date": "2026-04-01T00:00:00"
}
```
---
## 🔧 **Advanced Usage**
### Custom Dashboard Configuration
Run dashboard with custom refresh rates:
```bash
# Fast refresh (1 second)
aitbc monitor dashboard --refresh 1
# Slow refresh (30 seconds)
aitbc monitor dashboard --refresh 30
# Run for specific duration
aitbc monitor dashboard --refresh 10 --duration 300
```
### Alert Threshold Tuning
Set precise thresholds for alerts:
```bash
# Alert if balance drops below 50 AIT
aitbc monitor alerts add \
--name critical-balance \
--type low_balance \
--threshold 50 \
--webhook https://hooks.slack.com/...
# Alert if more than 10 jobs fail
aitbc monitor alerts add \
--name high-failure-rate \
--type job_failed \
--threshold 10
```
### Webhook Event Filtering
Configure webhooks for specific events:
```bash
# Only notify on job completion
aitbc monitor webhooks add \
--name job-notifier \
--url https://example.com/webhook \
--events job_completed
# Notify on multiple events
aitbc monitor webhooks add \
--name critical-events \
--url https://example.com/webhook \
--events miner_offline,alert
```
### Metrics Export and Analysis
Export metrics for external tools:
```bash
# Export to JSON
aitbc monitor metrics --period 7d --export weekly_metrics.json
# Export to CSV (via jq)
aitbc monitor metrics --period 24h --format json | \
jq -r '.jobs | @csv' > daily_jobs.csv
# Import into Grafana/Prometheus
aitbc monitor metrics --period 1h --format json | \
jq '.coordinator' > prometheus_metrics.json
```
### Campaign Performance Monitoring
Track campaign progress over time:
```bash
#!/bin/bash
# monitor_campaigns.sh
while true; do
clear
aitbc monitor campaigns --status active
aitbc monitor campaign-stats
sleep 300 # Check every 5 minutes
done
```
---
## ⚠️ **Important Notes**
### Dashboard Requirements
- **Rich Terminal**: Requires `rich` Python library for formatting
- **Coordinator API**: Dashboard requires coordinator-api running
- **Refresh Rate**: Lower refresh rates increase coordinator load
- **Terminal Size**: Dashboard works best in terminals 80x24 or larger
### Alert Storage
- **Location**: Alerts stored in `~/.aitbc/alerts/alerts.json`
- **Format**: JSON file with alert configurations
- **Persistence**: Alerts persist across CLI sessions
- **Backup**: Consider backing up alerts directory
### Webhook Limitations
- **HTTPS Required**: Webhooks should use HTTPS for security
- **Timeout**: Webhook requests timeout after 10 seconds
- **Retries**: No automatic retry on webhook failure
- **Payload**: Webhook payload includes event type and timestamp
### Campaign Auto-Update
- **Status Update**: Campaigns auto-update to "ended" when end date passes
- **Local Storage**: Campaigns stored in `~/.aitbc/campaigns/campaigns.json`
- **Default Campaigns**: Default campaigns created on first use
- **Manual Edit**: Campaigns can be edited manually in JSON file
### Metrics Collection
- **Coordinator Dependency**: Metrics require coordinator-api
- **Time Periods**: Longer periods may take longer to collect
- **Export Format**: Exported metrics in JSON format
- **API Limits**: Respect coordinator API rate limits
---
## 🐛 **Troubleshooting**
### Dashboard fails to start
**Error:**
```
Error: Failed to connect to coordinator
```
**Solution:**
```bash
# Check coordinator-api status
curl http://127.0.0.1:18000/health
# Verify coordinator URL in config
aitbc config show
# Check if coordinator is running
systemctl status aitbc-coordinator-api
```
### Alert file not found
**Error:**
```
Error: Alerts file not found
```
**Solution:**
```bash
# Create alerts directory
mkdir -p ~/.aitbc/alerts
# Initialize alerts file
echo "[]" > ~/.aitbc/alerts/alerts.json
# Add alert again
aitbc monitor alerts add --name test --type coordinator_down
```
### Webhook test fails
**Error:**
```
Webhook test failed: Connection timeout
```
**Solution:**
```bash
# Verify webhook URL is accessible
curl -X POST https://your-webhook-url -d '{"test": true}'
# Check network connectivity
ping webhook-host.example.com
# Test with a simpler webhook
aitbc monitor webhooks add --name test --url https://httpbin.org/post
aitbc monitor webhooks test --name test
```
### Metrics collection fails
**Error:**
```
Failed to collect metrics: Network error
```
**Solution:**
```bash
# Check coordinator-api health
curl http://127.0.0.1:18000/health
# Verify API key if required
aitbc config show
# Check coordinator logs
journalctl -u aitbc-coordinator-api -f
```
### Campaigns file corrupted
**Error:**
```
Error: Invalid campaigns file format
```
**Solution:**
```bash
# Backup existing file
cp ~/.aitbc/campaigns/campaigns.json ~/.aitbc/campaigns/campaigns.json.backup
# Reinitialize with defaults
rm ~/.aitbc/campaigns/campaigns.json
aitbc monitor campaigns # Will recreate with defaults
```
### Dashboard rendering issues
**Issue:**
Dashboard displays incorrectly or has formatting problems
**Solution:**
```bash
# Check terminal size
echo $COLUMNS $LINES
# Ensure rich library is installed
pip install rich
# Try without colors
TERM=xterm-256color aitbc monitor dashboard
```
---
## 🧪 **Validation**
Validate this scenario with the shared 3-node harness:
```bash
bash scripts/workflow/44_comprehensive_multi_node_scenario.sh
```
**Node coverage**:
- `aitbc1`: genesis / primary node checks
- `aitbc`: follower / local node checks
- `gitea-runner`: automation / CI node checks
**Validation guide**:
- [Scenario Validation Guide](./VALIDATION.md)
**Expected result**:
- Scenario-specific commands complete successfully
- Cross-node health checks pass
- Blockchain heights remain in sync
- Any node-specific step is documented in the scenario workflow
**Note**: Monitor commands require coordinator-api running. If the service is unavailable, commands will return network errors. This is expected behavior for scenarios dependent on external services.
---
## 💻 **Code Examples Using Agent SDK**
### Example 1: Monitor System Health Programmatically
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="monitoring-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Get system metrics
metrics = agent.get_system_metrics(period="24h")
print(f"Coordinator status: {metrics['coordinator']['status']}")
print(f"Jobs completed: {metrics['jobs']['completed']}")
print(f"Miners online: {metrics['miners']['online']}")
```
### Example 2: Configure Alerts Programmatically
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="alert-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Add low balance alert
agent.add_alert(
name="low-balance",
alert_type="low_balance",
threshold=100,
webhook="https://hooks.slack.com/services/..."
)
# List all alerts
alerts = agent.list_alerts()
for alert in alerts:
print(f"Alert: {alert['name']}, Type: {alert['type']}")
```
### Example 3: Monitor Campaign Performance
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="campaign-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Get active campaigns
campaigns = agent.get_campaigns(status="active")
for campaign in campaigns:
stats = agent.get_campaign_stats(campaign['id'])
print(f"Campaign: {campaign['name']}")
print(f" TVL: {stats['tvl']}")
print(f" Participants: {stats['participants']}")
print(f" Progress: {stats['progress_pct']}%")
```
---
## 🎯 **Expected Outcomes**
After completing this scenario, you should be able to:
- Launch and configure real-time monitoring dashboard
- Collect system metrics over configurable time periods
- Configure and manage monitoring alerts
- Set up and test webhook notifications
- Track incentive campaign performance
- Analyze historical data trends
- Export metrics for external analysis
- Troubleshoot common monitoring issues
---
## 🔗 **Related Resources**
### **AITBC Documentation**
- [Scenario 15: Blockchain Monitoring](./15_blockchain_monitoring.md) - Blockchain-specific monitoring
- [Scenario 18: Analytics Collection](./18_analytics_collection.md) - Advanced analytics
- [CLI Monitor Commands](../cli/CLI_DOCUMENTATION.md) - Complete CLI reference
- [Coordinator API Documentation](../apps/coordinator-api/README.md) - API details
### **External Resources**
- [Prometheus Monitoring](https://prometheus.io/)
- [Grafana Dashboards](https://grafana.com/docs/grafana/latest/dashboards/)
- [Webhook Best Practices](https://webhook.site/)
### **Next Scenarios**
- [Scenario 52: Resource Management](./52_resource_management.md) - Resource allocation
- [Scenario 53: Simulation Scenarios](./53_simulation_scenarios.md) - Test simulation
- [Scenario 28: Monitoring Agent](./28_monitoring_agent.md) - Advanced monitoring agent
---
## 📊 **Quality Metrics**
- **Structure**: 10/10 - Clear workflow from dashboard to campaign tracking
- **Content**: 10/10 - Comprehensive monitoring operations coverage
- **Code Examples**: 10/10 - Working Agent SDK examples
- **Status**: Active scenario
---
*Last updated: 2026-05-27*
*Version: 1.0*
*Status: Active scenario document*

670
docs/scenarios/52_resource_management.md
View File

@@ -1,670 +0,0 @@
# Resource Management for hermes Agents
**Level**: Intermediate
**Prerequisites**: Basic CLI knowledge, AITBC CLI installed
**Estimated Time**: 20 minutes
**Last Updated**: 2026-05-27
**Version**: 1.0
## 🧭 **Navigation Path:**
**🏠 [Documentation Home](../README.md)** → **🎭 [Agent Scenarios](./README.md)** → *You are here*
**breadcrumb**: Home → Scenarios → Resource Management
---
## 🎯 **See Also:**
- **📖 Previous Scenario**: [51 Monitoring and Metrics](./51_monitoring_and_metrics.md)
- **📖 Next Scenario**: [53 Simulation Scenarios](./53_simulation_scenarios.md)
- **📖 Related**: [09 GPU Listing](./09_gpu_listing.md)
- **📖 Related**: [21 Compute Provider Agent](./21_compute_provider_agent.md)
- **⚙️ Resource Documentation**: [CLI Resource Commands](../cli/CLI_DOCUMENTATION.md)
---
## 📚 **Scenario Overview**
This scenario demonstrates how hermes agents use resource management commands to allocate, monitor, and optimize computing resources. **Note: All resource commands are currently EXPERIMENTAL and use placeholder logic. The --mock flag is required for testing.**
### **Use Case**
An hermes agent needs to:
- Allocate GPU, CPU, and storage resources for AI jobs
- Monitor resource utilization and efficiency
- Release unused resources to optimize costs
- Optimize resource allocation across agents
- Track resource allocation status
### **What You'll Learn**
- Allocate resources with priority levels
- List and view allocated resources
- Release resources when no longer needed
- Monitor resource utilization metrics
- Optimize resource allocation
- Check resource allocation status
### **Features Combined**
- **Resource Allocation**: Allocate GPU, CPU, and storage with priority
- **Resource Listing**: View all allocated resources
- **Resource Release**: Deallocate resources when finished
- **Utilization Metrics**: Monitor resource usage and efficiency
- **Optimization**: Improve resource allocation efficiency
- **Status Tracking**: Check allocation status via coordinator-api
---
## 📋 **Prerequisites**
### **Knowledge Required**
- Basic command-line interface usage
- Understanding of computing resources (GPU, CPU, storage)
- AITBC CLI installed and accessible
### **System Requirements**
- AITBC CLI installed
- coordinator-api running (for status/deallocate commands)
- No additional setup required for mock mode
### **Setup Required**
- coordinator-api running (for live status/deallocate)
- Config file with `coordinator_url` set (for live operations)
---
## 🚀 **Quick Start**
```bash
# Allocate resources (mock mode required)
aitbc resource allocate --resource-type gpu --quantity 4 --priority high --mock
# List allocated resources (mock mode required)
aitbc resource list --mock
# Release resources (mock mode required)
aitbc resource release alloc_1234567890 --mock
# View utilization metrics (mock mode required)
aitbc resource utilization --mock
# Optimize resources (mock mode required)
aitbc resource optimize --target all --mock
```
---
## 📖 **Detailed Steps**
### Step 1: Allocate Resources
Request computing resources with priority:
```bash
# Allocate 4 GPUs with high priority
aitbc resource allocate --resource-type gpu --quantity 4 --priority high --mock
# Allocate CPU resources with medium priority
aitbc resource allocate --resource-type cpu --quantity 8 --priority medium --mock
# Allocate storage with low priority
aitbc resource allocate --resource-type storage --quantity 100 --priority low --mock
```
**Expected Output:**
```
Allocate 4 gpu with high priority
Allocation ID: alloc_1716789123
Status: Allocated
Cost per hour: 25 AIT
```
**Parameters explained:**
- `--resource-type`: Type of resource (gpu, cpu, storage)
- `--quantity`: Number of units to allocate
- `--priority`: Allocation priority (low, medium, high)
- `--mock`: Required flag for experimental command
**What happens:**
- Resource allocation request created
- Allocation ID returned for tracking
- Mock data simulates successful allocation
- TODO: Implement actual coordinator API integration
### Step 2: List Allocated Resources
View all currently allocated resources:
```bash
# List all resources in table format
aitbc resource list --mock
# List resources in JSON format
aitbc resource list --format json --mock
# List specific resource by ID
aitbc resource list --resource-id alloc_1234567890 --mock
```
**Expected Output (table):**
```
Allocated resources:
- GPU: 4 allocated, 8 available (78.5%)
- CPU: 45.2% allocated, 54.8% available (82.1%)
- STORAGE: 45GB allocated, 55GB available (90.0%)
```
**Expected Output (JSON):**
```json
[
{
"type": "gpu",
"allocated": 4,
"available": 8,
"efficiency": "78.5%"
},
{
"type": "cpu",
"allocated": "45.2%",
"available": "54.8%",
"efficiency": "82.1%"
},
{
"type": "storage",
"allocated": "45GB",
"available": "55GB",
"efficiency": "90.0%"
}
]
```
### Step 3: Monitor Resource Utilization
Check resource usage and efficiency metrics:
```bash
# View utilization in table format
aitbc resource utilization --mock
# View utilization in JSON format
aitbc resource utilization --format json --mock
```
**Expected Output (table):**
```
Resource utilization:
cpu_utilization: 45.2%
memory_usage: 2.1GB / 8GB (26%)
storage_available: 45GB / 100GB
network_bandwidth: 120Mbps / 1Gbps
active_agents: 3
resource_efficiency: 78.5%
```
**Expected Output (JSON):**
```json
{
"cpu_utilization": "45.2%",
"memory_usage": "2.1GB / 8GB (26%)",
"storage_available": "45GB / 100GB",
"network_bandwidth": "120Mbps / 1Gbps",
"active_agents": 3,
"resource_efficiency": "78.5%"
}
```
### Step 4: Release Resources
Deallocate resources when no longer needed:
```bash
# Release specific resource by ID
aitbc resource release alloc_1716789123 --mock
# Release multiple resources
aitbc resource release alloc_1716789123 --mock
aitbc resource release alloc_1716789124 --mock
```
**Expected Output:**
```
Release resource alloc_1716789123
Status: Released
```
**What happens:**
- Resource deallocation request processed
- Resources returned to available pool
- Allocation cost stops accruing
- TODO: Implement actual coordinator API integration
### Step 5: Optimize Resource Allocation
Improve resource allocation efficiency:
```bash
# Optimize all resources
aitbc resource optimize --target all --mock
# Optimize only GPU resources
aitbc resource optimize --target gpu --mock
# Optimize for specific agent
aitbc resource optimize --target all --agent-id agent_123 --mock
```
**Expected Output:**
```
Optimize resources for target: all
Optimization score: 85.2%
Improvement: 12.5%
Status: Optimized
```
**Parameters explained:**
- `--target`: Optimization target (all, cpu, gpu, memory)
- `--agent-id`: Specific agent ID to optimize for
- `--mock`: Required flag for experimental command
### Step 6: Check Resource Status (Live)
Check allocation status via coordinator-api (no --mock required):
```bash
# Check all resource status
aitbc resource status
# Check specific resource status
aitbc resource status --resource-id alloc_1234567890
```
**Expected Output:**
```
Resource Status:
{
"resource_id": "alloc_1234567890",
"type": "gpu",
"quantity": 4,
"status": "allocated",
"allocated_at": "2026-05-27T08:30:00",
"cost_per_hour": 25,
"agent_id": "agent_123"
}
```
**Note:** This command requires coordinator-api running and does not use --mock flag.
### Step 7: Deallocate Resources (Live)
Deallocate resources via coordinator-api (no --mock required):
```bash
# Deallocate with confirmation
aitbc resource deallocate alloc_1234567890
# Force deallocation without confirmation
aitbc resource deallocate alloc_1234567890 --force
```
**Expected Output:**
```
Are you sure you want to deallocate resource alloc_1234567890? [y/N]: y
Resource alloc_1234567890 deallocated successfully
{
"resource_id": "alloc_1234567890",
"status": "deallocated",
"deallocated_at": "2026-05-27T09:00:00"
}
```
**Note:** This command requires coordinator-api running and does not use --mock flag.
---
## 🔧 **Advanced Usage**
### Batch Resource Allocation
Allocate multiple resources in sequence:
```bash
#!/bin/bash
# allocate_resources.sh
# Allocate GPU
aitbc resource allocate --resource-type gpu --quantity 4 --priority high --mock
# Allocate CPU
aitbc resource allocate --resource-type cpu --quantity 8 --priority medium --mock
# Allocate storage
aitbc resource allocate --resource-type storage --quantity 100 --priority low --mock
# View allocation
aitbc resource list --mock
```
### Resource Optimization Strategy
Optimize resources for specific use cases:
```bash
# Optimize for AI training (GPU-heavy)
aitbc resource optimize --target gpu --mock
# Optimize for data processing (CPU-heavy)
aitbc resource optimize --target cpu --mock
# Optimize for storage-heavy workloads
aitbc resource optimize --target all --mock
```
### Monitoring Resource Efficiency
Track resource efficiency over time:
```bash
#!/bin/bash
# monitor_resources.sh
while true; do
clear
echo "=== Resource Utilization ==="
aitbc resource utilization --mock
echo ""
echo "=== Allocated Resources ==="
aitbc resource list --mock
sleep 60
done
```
### Cost Estimation
Calculate resource costs:
```bash
#!/bin/bash
# estimate_cost.sh
# GPU: 25 AIT/hour
GPU_COST=25
# CPU: 10 AIT/hour
CPU_COST=10
# Storage: 5 AIT/hour
STORAGE_COST=5
# Get allocation
aitbc resource list --format json --mock > resources.json
# Calculate cost (example)
python3 << EOF
import json
with open('resources.json') as f:
resources = json.load(f)
total_cost = 0
for res in resources:
if res['type'] == 'gpu':
total_cost += res['allocated'] * $GPU_COST
elif res['type'] == 'cpu':
total_cost += float(res['allocated'].rstrip('%')) / 100 * $CPU_COST
elif res['type'] == 'storage':
total_cost += int(res['allocated'].rstrip('GB')) / 100 * $STORAGE_COST
print(f"Estimated hourly cost: {total_cost} AIT")
EOF
```
---
## ⚠️ **Important Notes**
### Experimental Status
- **All Commands**: All resource commands are EXPERIMENTAL
- **Placeholder Logic**: Current implementation uses mock data
- **--mock Required**: Most commands require --mock flag
- **TODO Status**: Actual coordinator API integration pending
### Live Operations
- **status Command**: Does not require --mock, uses coordinator-api
- **deallocate Command**: Does not require --mock, uses coordinator-api
- **Coordinator Required**: Live operations need coordinator-api running
- **Network Dependency**: Live operations require network connectivity
### Resource Types
- **GPU**: Graphics processing units for AI/ML workloads
- **CPU**: Central processing units for general computing
- **Storage**: Disk space for data persistence
### Priority Levels
- **High**: Urgent resource needs, allocated first
- **Medium**: Standard resource needs
- **Low**: Background resource needs, allocated last
### Cost Considerations
- **Hourly Billing**: Resources billed per hour
- **GPU Cost**: 25 AIT/hour (mock rate)
- **CPU Cost**: 10 AIT/hour (mock rate)
- **Storage Cost**: 5 AIT/hour (mock rate)
---
## 🐛 **Troubleshooting**
### Command without --mock flag
**Error:**
```
[EXPERIMENTAL] This command uses placeholder logic. Use --mock for testing.
To proceed with mock data, run: aitbc resource allocate --mock
```
**Solution:**
```bash
# Always use --mock flag for experimental commands
aitbc resource allocate --resource-type gpu --quantity 4 --mock
```
### Coordinator API unavailable for live operations
**Error:**
```
Network error: Failed to connect to coordinator
```
**Solution:**
```bash
# Check coordinator-api status
curl http://127.0.0.1:18000/health
# Verify coordinator URL in config
aitbc config show
# Use mock mode for testing
aitbc resource allocate --mock
```
### Invalid resource type
**Error:**
```
Error: Invalid choice: resource_type. (choose from gpu, cpu, storage)
```
**Solution:**
```bash
# Use valid resource types
aitbc resource allocate --resource-type gpu --quantity 4 --mock
aitbc resource allocate --resource-type cpu --quantity 8 --mock
aitbc resource allocate --resource-type storage --quantity 100 --mock
```
### Invalid priority level
**Error:**
```
Error: Invalid choice: priority. (choose from low, medium, high)
```
**Solution:**
```bash
# Use valid priority levels
aitbc resource allocate --resource-type gpu --quantity 4 --priority high --mock
aitbc resource allocate --resource-type gpu --quantity 4 --priority medium --mock
aitbc resource allocate --resource-type gpu --quantity 4 --priority low --mock
```
### Resource ID not found
**Error:**
```
Error: Resource alloc_1234567890 not found
```
**Solution:**
```bash
# List available resources
aitbc resource list --mock
# Use correct resource ID from list
aitbc resource release alloc_1716789123 --mock
```
---
## 🧪 **Validation**
Validate this scenario with the shared 3-node harness:
```bash
bash scripts/workflow/44_comprehensive_multi_node_scenario.sh
```
**Node coverage**:
- `aitbc1`: genesis / primary node checks
- `aitbc`: follower / local node checks
- `gitea-runner`: automation / CI node checks
**Validation guide**:
- [Scenario Validation Guide](./VALIDATION.md)
**Expected result**:
- Scenario-specific commands complete successfully with --mock flag
- Cross-node health checks pass
- Blockchain heights remain in sync
- Any node-specific step is documented in the scenario workflow
**Note**: Resource commands are EXPERIMENTAL and require --mock flag. Live operations (status, deallocate) require coordinator-api running. Mock mode can be tested without external dependencies.
---
## 💻 **Code Examples Using Agent SDK**
### Example 1: Allocate Resources Programmatically
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="resource-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Allocate GPU resources
allocation = agent.allocate_resources(
resource_type="gpu",
quantity=4,
priority="high"
)
print(f"Allocation ID: {allocation['allocation_id']}")
print(f"Status: {allocation['status']}")
```
### Example 2: Monitor Resource Utilization
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="monitoring-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Get resource utilization
utilization = agent.get_resource_utilization()
print(f"CPU Utilization: {utilization['cpu_utilization']}")
print(f"Memory Usage: {utilization['memory_usage']}")
print(f"Storage Available: {utilization['storage_available']}")
print(f"Resource Efficiency: {utilization['resource_efficiency']}")
```
### Example 3: Optimize Resource Allocation
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="optimization-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Optimize all resources
result = agent.optimize_resources(target="all")
print(f"Optimization Score: {result['optimization_score']}")
print(f"Improvement: {result['improvement']}")
print(f"Status: {result['status']}")
```
---
## 🎯 **Expected Outcomes**
After completing this scenario, you should be able to:
- Allocate GPU, CPU, and storage resources with priority
- List and view allocated resources in table or JSON format
- Release resources when no longer needed
- Monitor resource utilization metrics
- Optimize resource allocation for efficiency
- Check resource allocation status via coordinator-api
- Deallocate resources via coordinator-api
- Understand the experimental status of resource commands
---
## 🔗 **Related Resources**
### **AITBC Documentation**
- [Scenario 09: GPU Listing](./09_gpu_listing.md) - GPU marketplace operations
- [Scenario 21: Compute Provider Agent](./21_compute_provider_agent.md) - GPU provider agent
- [CLI Resource Commands](../cli/CLI_DOCUMENTATION.md) - Complete CLI reference
- [Coordinator API Documentation](../apps/coordinator-api/README.md) - API details
### **External Resources**
- [GPU Resource Management](https://www.nvidia.com/en-us/data-center/gpu-cloud/)
- [Kubernetes Resource Management](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
- [Cloud Resource Optimization](https://aws.amazon.com/blogs/architecture/optimizing-resource-usage/)
### **Next Scenarios**
- [Scenario 53: Simulation Scenarios](./53_simulation_scenarios.md) - Test simulation
- [Scenario 22: AI Training Agent](./22_ai_training_agent.md) - AI training workflows
- [Scenario 35: Edge Compute Agent](./35_edge_compute_agent.md) - Edge resource management
---
## 📊 **Quality Metrics**
- **Structure**: 10/10 - Clear workflow from allocation to optimization
- **Content**: 10/10 - Comprehensive resource management coverage
- **Code Examples**: 10/10 - Working Agent SDK examples
- **Status**: Active scenario (EXPERIMENTAL)
---
*Last updated: 2026-05-27*
*Version: 1.0*
*Status: Active scenario document (EXPERIMENTAL)*

728
docs/scenarios/53_simulation_scenarios.md
View File

@@ -1,728 +0,0 @@
# Simulation Scenarios for hermes Agents
**Level**: Intermediate
**Prerequisites**: Basic CLI knowledge, AITBC CLI installed
**Estimated Time**: 30 minutes
**Last Updated**: 2026-05-27
**Version**: 1.0
## 🧭 **Navigation Path:**
**🏠 [Documentation Home](../README.md)** → **🎭 [Agent Scenarios](./README.md)** → *You are here*
**breadcrumb**: Home → Scenarios → Simulation Scenarios
---
## 🎯 **See Also:**
- **📖 Previous Scenario**: [52 Resource Management](./52_resource_management.md)
- **📖 Next Scenario**: [13 Mining Setup](./13_mining_setup.md)
- **📖 Related**: [03 Genesis Deployment](./03_genesis_deployment.md)
- **📖 Related**: [07 AI Job Submission](./07_ai_job_submission.md)
- **⚙️ Simulation Documentation**: [CLI Simulation Commands](../cli/CLI_DOCUMENTATION.md)
---
## 📚 **Scenario Overview**
This scenario demonstrates how hermes agents use simulation commands to model blockchain scenarios, test environments, and validate system behavior without affecting production data. Simulations enable agents to stress-test systems, model market conditions, and validate workflows safely.
### **Use Case**
An hermes agent needs to:
- Simulate blockchain block production and transaction throughput
- Model wallet creation and transaction patterns
- Test price movement scenarios with volatility
- Simulate network topology and node failures
- Model AI job submission and processing
- Run custom simulation scenarios via coordinator-api
### **What You'll Learn**
- Simulate blockchain block production with configurable parameters
- Model wallet creation and transaction flows
- Simulate price movements with volatility
- Test network topology and failure scenarios
- Model AI job submission and processing
- Run custom simulation scenarios via coordinator-api
- Track simulation status and results
### **Features Combined**
- **Blockchain Simulation**: Block production and transaction modeling
- **Wallet Simulation**: Wallet creation and transaction flows
- **Price Simulation**: Market price modeling with volatility
- **Network Simulation**: Topology and failure testing
- **AI Job Simulation**: Job submission and processing modeling
- **Custom Scenarios**: Run coordinator-api simulation scenarios
---
## 📋 **Prerequisites**
### **Knowledge Required**
- Basic command-line interface usage
- Understanding of blockchain concepts (blocks, transactions)
- Understanding of network topology concepts
- AITBC CLI installed and accessible
### **System Requirements**
- AITBC CLI installed
- coordinator-api running (for run/status/result commands)
- No additional setup required for local simulations
### **Setup Required**
- coordinator-api running (for custom simulation scenarios)
- Config file with `coordinator_url` set (for coordinator-api simulations)
---
## 🚀 **Quick Start**
```bash
# Simulate blockchain block production
aitbc simulate blockchain --blocks 10 --transactions 50
# Simulate wallet creation and transactions
aitbc simulate wallets --wallets 5 --balance 1000 --transactions 20
# Simulate price movements
aitbc simulate price --price 100 --volatility 0.05 --timesteps 100
# Simulate network topology
aitbc simulate network --nodes 3 --failure-rate 0.05
# Simulate AI job processing
aitbc simulate ai-jobs --jobs 10 --models text-generation,image-generation
# Run custom simulation via coordinator-api
aitbc simulate run load-test --params '{"users": 100, "duration": 300}'
```
---
## 📖 **Detailed Steps**
### Step 1: Simulate Blockchain Block Production
Model blockchain block production and transaction throughput:
```bash
# Simulate 10 blocks with 50 transactions each
aitbc simulate blockchain --blocks 10 --transactions 50
# Simulate with custom delay between blocks
aitbc simulate blockchain --blocks 20 --transactions 100 --delay 2
# Output in JSON format
aitbc simulate blockchain --blocks 5 --transactions 25 --output json
```
**Expected Output:**
```
Simulating blockchain with 10 blocks, 50 transactions per block
Block 1: 50 txs, 25000.50 AIT, 25.25 fees
Block 2: 50 txs, 24800.75 AIT, 24.80 fees
Block 3: 50 txs, 25200.25 AIT, 25.20 fees
...
Block 10: 50 txs, 24900.00 AIT, 24.90 fees
Simulation Summary:
Total Blocks: 10
Total Transactions: 500
Total Amount: 249500.50 AIT
Total Fees: 249.50 AIT
Average TPS: 50.00
```
**Parameters explained:**
- `--blocks`: Number of blocks to simulate (default: 10)
- `--transactions`: Transactions per block (default: 50)
- `--delay`: Delay between blocks in seconds (default: 1.0)
- `--output`: Output format (table, json, yaml)
### Step 2: Simulate Wallet Creation and Transactions
Model wallet creation and transaction flows:
```bash
# Create 5 wallets with 1000 AIT each, simulate 20 transactions
aitbc simulate wallets --wallets 5 --balance 1000 --transactions 20
# Custom transaction amount range
aitbc simulate wallets --wallets 10 --balance 5000 --transactions 50 \
--amount-range 10.0-500.0
```
**Expected Output:**
```
Simulating 5 wallets with 1000.00 AIT initial balance
Created wallet sim_wallet_1: ait1abc123... with 1000.00 AIT
Created wallet sim_wallet_2: ait1def456... with 1000.00 AIT
Created wallet sim_wallet_3: ait1ghi789... with 1000.00 AIT
Created wallet sim_wallet_4: ait1jkl012... with 1000.00 AIT
Created wallet sim_wallet_5: ait1mno345... with 1000.00 AIT
Simulating 20 transactions...
Tx 1: sim_wallet_1 -> sim_wallet_2: 45.50 AIT
Tx 2: sim_wallet_3 -> sim_wallet_1: 78.25 AIT
...
Tx 20: sim_wallet_4 -> sim_wallet_5: 32.75 AIT
Final Wallet Balances:
sim_wallet_1: 1050.25 AIT
sim_wallet_2: 980.50 AIT
sim_wallet_3: 1025.75 AIT
sim_wallet_4: 950.00 AIT
sim_wallet_5: 993.50 AIT
```
### Step 3: Simulate Price Movements
Model AIT price movements with volatility:
```bash
# Simulate price from 100 AIT with 5% volatility
aitbc simulate price --price 100 --volatility 0.05 --timesteps 100
# High volatility simulation
aitbc simulate price --price 50 --volatility 0.15 --timesteps 200
# Low volatility simulation
aitbc simulate price --price 200 --volatility 0.01 --timesteps 50
```
**Expected Output:**
```
Simulating AIT price from 100.00 with 0.05 volatility
Step 1: 102.50 AIT (+2.50%)
Step 2: 99.75 AIT (-2.68%)
Step 3: 101.25 AIT (+1.50%)
...
Step 100: 98.50 AIT (-0.75%)
Price Statistics:
Starting Price: 100.0000 AIT
Ending Price: 98.5000 AIT
Minimum Price: 85.2500 AIT
Maximum Price: 115.7500 AIT
Average Price: 100.1250 AIT
Total Change: -1.50%
```
### Step 4: Simulate Network Topology
Test network topology and node failure scenarios:
```bash
# Simulate 3-node network with 5% failure rate
aitbc simulate network --nodes 3 --network-delay 0.1 --failure-rate 0.05
# Simulate 5-node network with higher failure rate
aitbc simulate network --nodes 5 --network-delay 0.2 --failure-rate 0.10
```
**Expected Output:**
```
Simulating network with 3 nodes, 0.1s delay, 0.05 failure rate
Network Topology:
node_1 (10.1.223.90): connected to node_2, node_3
node_2 (10.1.223.91): connected to node_3, node_1
node_3 (10.1.223.92): connected to node_1, node_2
Simulating network operations...
Step 1: node_1 produced block 1, 3 nodes active
Step 2: node_2 produced block 2, 3 nodes active
Step 3: node_3 failed
Step 4: node_1 produced block 3, 2 nodes active
...
Step 10: node_2 produced block 8, 2 nodes active
Final Network Status:
✅ node_1: height 5, connections: 2
✅ node_2: height 5, connections: 2
❌ node_3: height 2, connections: 2
```
### Step 5: Simulate AI Job Processing
Model AI job submission and processing:
```bash
# Simulate 10 AI jobs with text and image generation
aitbc simulate ai-jobs --jobs 10 \
--models text-generation,image-generation \
--duration-range 30-300
# Simulate with custom models
aitbc simulate ai-jobs --jobs 20 \
--models text-generation,image-generation,audio-generation \
--duration-range 60-600
```
**Expected Output:**
```
Simulating 10 AI jobs with models: text-generation, image-generation
Submitted job job_001: text-generation (est. 120s)
Submitted job job_002: image-generation (est. 240s)
Submitted job job_003: text-generation (est. 90s)
...
Submitted job job_010: image-generation (est. 180s)
Simulating job processing...
Started job_001
Started job_002
Started job_003
...
Completed job_001 in 118.5s
Completed job_003 in 92.3s
...
Completed job_010 in 175.8s
Job Statistics:
Total Jobs: 10
Completed Jobs: 10
Failed Jobs: 0
Average Duration: 145.2s
Model Usage:
text-generation: 5 jobs
image-generation: 5 jobs
```
### Step 6: Run Custom Simulation via Coordinator-API
Execute custom simulation scenarios:
```bash
# Run load test simulation
aitbc simulate run load-test \
--params '{"users": 100, "duration": 300, "requests_per_second": 10}'
# Run stress test simulation asynchronously
aitbc simulate run stress-test --params '{"concurrent_users": 500}' --async-run
# Run network partition simulation
aitbc simulate run network-partition \
--params '{"partition_duration": 60, "affected_nodes": ["node_1", "node_2"]}'
```
**Expected Output:**
```
Simulation 'load-test' started
{
"simulation_id": "sim_1716789123",
"scenario": "load-test",
"status": "running",
"params": {
"users": 100,
"duration": 300,
"requests_per_second": 10
},
"started_at": "2026-05-27T08:30:00"
}
```
### Step 7: Check Simulation Status
Monitor simulation progress:
```bash
# Check simulation status
aitbc simulate status sim_1716789123
```
**Expected Output:**
```
Simulation sim_1716789123 Status:
{
"simulation_id": "sim_1716789123",
"scenario": "load-test",
"status": "running",
"progress": 45,
"started_at": "2026-05-27T08:30:00",
"estimated_completion": "2026-05-27T08:35:00",
"metrics": {
"requests_completed": 1350,
"requests_failed": 5,
"average_latency": 125
}
}
```
### Step 8: Get Simulation Results
Retrieve simulation results:
```bash
# Get simulation results
aitbc simulate result sim_1716789123
```
**Expected Output:**
```
Simulation sim_1716789123 Results:
{
"simulation_id": "sim_1716789123",
"scenario": "load-test",
"status": "completed",
"started_at": "2026-05-27T08:30:00",
"completed_at": "2026-05-27T08:34:58",
"duration": 298,
"results": {
"total_requests": 3000,
"successful_requests": 2995,
"failed_requests": 5,
"success_rate": 99.83,
"average_latency": 122,
"p95_latency": 250,
"p99_latency": 450
}
}
```
---
## 🔧 **Advanced Usage**
### Stress Testing with High Throughput
Simulate high transaction throughput:
```bash
# Simulate 100 blocks with 500 transactions each
aitbc simulate blockchain --blocks 100 --transactions 500 --delay 0.5
# Calculate TPS
# 500 tx/block * 100 blocks / (100 * 0.5s) = 1000 TPS
```
### Market Crash Simulation
Model extreme price volatility:
```bash
# Simulate market crash with 30% volatility
aitbc simulate price --price 100 --volatility 0.30 --timesteps 200 --delay 0.05
```
### Network Partition Testing
Test network resilience with high failure rate:
```bash
# Simulate network with 25% failure rate
aitbc simulate network --nodes 5 --network-delay 0.2 --failure-rate 0.25
```
### Batch Simulation Scenarios
Run multiple simulations in sequence:
```bash
#!/bin/bash
# run_simulations.sh
echo "=== Blockchain Simulation ==="
aitbc simulate blockchain --blocks 50 --transactions 100
echo ""
echo "=== Price Simulation ==="
aitbc simulate price --price 100 --volatility 0.10 --timesteps 200
echo ""
echo "=== Network Simulation ==="
aitbc simulate network --nodes 5 --failure-rate 0.10
echo ""
echo "=== AI Job Simulation ==="
aitbc simulate ai-jobs --jobs 20 --duration-range 60-600
```
### Custom Scenario Development
Create custom simulation parameters:
```bash
# Custom load test with ramp-up
aitbc simulate run custom-load-test \
--params '{
"ramp_up_duration": 60,
"peak_users": 1000,
"peak_duration": 300,
"ramp_down_duration": 60,
"request_pattern": "sine_wave"
}'
```
---
## ⚠️ **Important Notes**
### Local vs Coordinator-API Simulations
- **Local Simulations**: blockchain, wallets, price, network, ai-jobs run locally
- **Coordinator-API Simulations**: run, status, result require coordinator-api
- **No External Dependencies**: Local simulations work without coordinator-api
- **Network Required**: Coordinator-API simulations need network connectivity
### Simulation Limitations
- **Mock Data**: Simulations use random/mock data, not real blockchain state
- **No Persistence**: Simulation results are not persisted to blockchain
- **No Side Effects**: Simulations do not affect production systems
- **Deterministic Results**: Same parameters may produce different results due to randomness
### Performance Considerations
- **Large Simulations**: High block/transaction counts may take time
- **Memory Usage**: Large simulations may consume significant memory
- **CPU Usage**: Simulations are CPU-intensive
- **Terminal Output**: Large simulations produce extensive output
### Coordinator-API Integration
- **Scenario Support**: Coordinator-api must support requested scenario
- **Async Mode**: Use --async-run for long-running simulations
- **Status Polling**: Use status command to track async simulations
- **Result Retrieval**: Results available after simulation completes
---
## 🐛 **Troubleshooting**
### Invalid JSON parameters
**Error:**
```
Error: Invalid JSON parameters
```
**Solution:**
```bash
# Ensure JSON is properly formatted
aitbc simulate run load-test --params '{"users": 100, "duration": 300}'
# Validate JSON before running
echo '{"users": 100, "duration": 300}' | python3 -m json.tool
```
### Coordinator API unavailable
**Error:**
```
Network error: Failed to connect to coordinator
```
**Solution:**
```bash
# Check coordinator-api status
curl http://127.0.0.1:18000/health
# Use local simulations instead
aitbc simulate blockchain --blocks 10 --transactions 50
```
### Simulation not found
**Error:**
```
Error: Simulation sim_1234567890 not found
```
**Solution:**
```bash
# List running simulations (if coordinator-api supports it)
curl http://127.0.0.1:18000/api/v1/simulations
# Use correct simulation ID
aitbc simulate status sim_1716789123
```
### Invalid amount range format
**Error:**
```
Error: Invalid amount range format
```
**Solution:**
```bash
# Use correct format: min-max
aitbc simulate wallets --amount-range 10.0-100.0
# Ensure numbers are valid
aitbc simulate wallets --amount-range 1.0-1000.0
```
### Simulation takes too long
**Issue:**
Simulation running for extended period
**Solution:**
```bash
# Reduce simulation size
aitbc simulate blockchain --blocks 10 --transactions 50 # Instead of 100/500
# Reduce delay
aitbc simulate blockchain --blocks 50 --transactions 100 --delay 0.1
# Use async mode for coordinator-api simulations
aitbc simulate run long-test --async-run
```
---
## 🧪 **Validation**
Validate this scenario with the shared 3-node harness:
```bash
bash scripts/workflow/44_comprehensive_multi_node_scenario.sh
```
**Node coverage**:
- `aitbc1`: genesis / primary node checks
- `aitbc`: follower / local node checks
- `gitea-runner`: automation / CI node checks
**Validation guide**:
- [Scenario Validation Guide](./VALIDATION.md)
**Expected result**:
- Scenario-specific commands complete successfully
- Local simulations run without external dependencies
- Coordinator-API simulations require coordinator-api running
- Cross-node health checks pass
- Blockchain heights remain in sync
**Note**: Local simulations (blockchain, wallets, price, network, ai-jobs) work without external services. Coordinator-API simulations (run, status, result) require coordinator-api running.
---
## 💻 **Code Examples Using Agent SDK**
### Example 1: Run Blockchain Simulation Programmatically
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="simulation-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Run blockchain simulation
result = agent.run_simulation(
type="blockchain",
params={
"blocks": 50,
"transactions": 100,
"delay": 1.0
}
)
print(f"Total Blocks: {result['total_blocks']}")
print(f"Total Transactions: {result['total_transactions']}")
print(f"Average TPS: {result['average_tps']}")
```
### Example 2: Monitor Simulation Progress
```python
from aitbc_agent_sdk import Agent, AgentConfig
import time
config = AgentConfig(
name="monitoring-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Start simulation
sim_id = agent.start_simulation("load-test", {"users": 100, "duration": 300})
# Monitor progress
while True:
status = agent.get_simulation_status(sim_id)
print(f"Progress: {status['progress']}%")
if status['status'] == 'completed':
break
time.sleep(5)
# Get results
results = agent.get_simulation_results(sim_id)
print(f"Success Rate: {results['success_rate']}%")
```
### Example 3: Run Price Simulation
```python
from aitbc_agent_sdk import Agent, AgentConfig
config = AgentConfig(
name="trading-agent",
blockchain_network="mainnet"
)
agent = Agent(config)
agent.start()
# Run price simulation
price_data = agent.simulate_price(
starting_price=100.0,
volatility=0.05,
timesteps=200
)
print(f"Starting Price: {price_data['starting_price']}")
print(f"Ending Price: {price_data['ending_price']}")
print(f"Max Price: {price_data['max_price']}")
print(f"Min Price: {price_data['min_price']}")
print(f"Total Change: {price_data['total_change']}%")
```
---
## 🎯 **Expected Outcomes**
After completing this scenario, you should be able to:
- Simulate blockchain block production with configurable parameters
- Model wallet creation and transaction flows
- Simulate price movements with volatility
- Test network topology and failure scenarios
- Model AI job submission and processing
- Run custom simulation scenarios via coordinator-api
- Track simulation status and results
- Understand the difference between local and coordinator-api simulations
---
## 🔗 **Related Resources**
### **AITBC Documentation**
- [Scenario 03: Genesis Deployment](./03_genesis_deployment.md) - Real blockchain deployment
- [Scenario 07: AI Job Submission](./07_ai_job_submission.md) - Real AI job operations
- [CLI Simulation Commands](../cli/CLI_DOCUMENTATION.md) - Complete CLI reference
- [Coordinator API Documentation](../apps/coordinator-api/README.md) - API details
### **External Resources**
- [Blockchain Simulation](https://www.ibm.com/topics/blockchain-simulation)
- [Network Topology](https://www.networkworld.com/article/3236143/network-topology-types.html)
- [Price Volatility Modeling](https://www.investopedia.com/articles/trading/07/ stochastic.asp)
### **Next Scenarios**
- [Scenario 13: Mining Setup](./13_mining_setup.md) - Real mining operations
- [Scenario 22: AI Training Agent](./22_ai_training_agent.md) - Real AI training
- [Scenario 27: Cross Chain Trader](./27_cross_chain_trader.md) - Real trading operations
---
## 📊 **Quality Metrics**
- **Structure**: 10/10 - Clear workflow from blockchain to custom scenarios
- **Content**: 10/10 - Comprehensive simulation coverage
- **Code Examples**: 10/10 - Working Agent SDK examples
- **Status**: Active scenario
---
*Last updated: 2026-05-27*
*Version: 1.0*
*Status: Active scenario document*