Content
# Tool List
> **Internet of Agents — Cross-Domain Distributed Task Collaborative Scheduling System**
>
> C4 Network Technology Challenge B-EP1 "Internet of Agents Innovation Research" | 2026
## Project Overview
This system is a **two-layer architecture IoA (Internet of Agents) application**:
- **Lower Layer (IoA Middleware)**: Self-developed universal multi-Agent communication and orchestration infrastructure — Multi-dimensional weighted message routing bus, DAG task scheduling engine, Agent registration center, closed-loop verifier, identity authentication
- **Upper Layer (Application Scenario)**: Distributed network operation and maintenance — The system contains **9 Agent instances, covering 5 types** (each instance runs in an independent container when deployed in a distributed manner) to collaboratively complete network-wide monitoring, fault diagnosis, automatic repair, and closed-loop verification:
- **OrchestratorAgent** ×1 — Natural language intent parsing and DAG orchestration
- **MonitorAgent** ×4 — Sub-domain real-time monitoring (East China/North China/South China/West China)
- **DiagnoserAgent** ×1 — Multi-strategy root cause diagnosis (rule engine + LLM enhancement)
- **RepairerAgent** ×1 — Differentiated repair execution (5 strategies: routing switch/ACL/traffic shaping/link transfer/service restart)
- **VerifyAgent** ×1 — Closed-loop verification (pass/retry/fail status machine)
- **ReporterAgent** ×1 — Full-link operation and maintenance report generation
Core innovation: Not just a network operation and maintenance tool, but **using network operation and maintenance scenarios to prove the universality and practicality of IoA middleware**. The system starts with natural language operation and maintenance instructions, automatically matches DAG templates through multi-dimensional weighted routing, and realizes the full-link automation of "intent understanding → task orchestration → collaborative execution → closed-loop verification".
## System Characteristics
- **Natural Language Driven**: Use colloquial instructions to trigger complex operation and maintenance processes without API calls
- **Multi-Dimensional Weighted Message Routing**: Agent communication based on capability matching rather than hard-coded addressing, achieving loose coupling
- **DAG Orchestration Engine**: Kahn topological sorting + retry strategy + audit log, task graph automatic parsing and execution
- **Closed-Loop Verification**: Three-state judgment (pass/retry/fail), real-time indicator bottom-line logic to prevent infinite retries
- **Multi-Domain Collaboration**: East China/North China/South China/Southwest four-domain network topology, fault injection → repair full-link
- **Dark Technology Wind GUI**: Topology real-time status, indicator dashboard, IoAP message flow, DAG visualization
## Core Innovations
### 1. Two-Layer Architecture Design
This system adopts a **two-layer architecture**, decoupling the universal middleware from the specific application scenario:
- **Lower Layer (IoA Middleware)**: Provides universal Agent communication, orchestration, and verification infrastructure
- **Upper Layer (Application Scenario)**: Quickly build network operation and maintenance applications based on the middleware
This design enables the middleware to be reused in other scenarios (such as intelligent customer service, automated testing, etc.).
### 2. Multi-Dimensional Weighted Routing Engine
Self-developed **four-dimensional scoring algorithm** realizes intelligent Agent selection:
- **Capability Matching Degree**: The matching degree between Agent capability and task requirements
- **Domain Affinity**: The consistency between the Agent's domain and the task's target domain
- **Load Balancing Degree**: The current load situation of the Agent
- **Semantic Similarity**: The semantic correlation between task description and Agent specialty
### 3. LangGraph Workflow Integration
Use LangGraph to implement stateful Agent workflow:
- **Intent Parsing Node**: LLM extracts structured parameters
- **Template Matching Node**: Semantic matching DAG template
- **Parameter Verification Node**: Verify parameter integrity
- **DAG Generation Node**: Generate DAG definition
Supports conditional routing and error recovery, realizing intelligent task orchestration.
### 4. Closed-Loop Verification Mechanism
Innovative **three-state judgment** mechanism ensures task execution quality:
- **pass**: All indicators return to normal
- **retry**: Partial improvement, worth retrying (up to 3 times)
- **fail**: Retry exhausted or severely deteriorated
Real-time indicator bottom-line logic prevents infinite retries, ensuring system stability.
### 5. Multi-Protocol Bridging
Taking self-developed IoAP as the core, compatible with industry standard protocols:
- **IoAP** (production protocol): Agent communication, multi-dimensional weighted routing + DAG orchestration
- **A2A** (server-side ready): REST endpoint already mounted (`/a2a`), Agent Card can be discovered
- **MCP** (partially integrated): SSE server-side already mounted (`/mcp`), MonitorAgent ×4 preferentially use AutoToolClient
## Technical Stack
| Layer | Technology |
|------|------|
| Backend Framework | Python 3.12 + FastAPI |
| Middleware | Self-developed IoA (registration center, multi-dimensional weighted routing, DAG scheduling, closed-loop verification) |
| AI Engine | LangGraph (Agent workflow), DeepSeek API (LLM inference) |
| Data Storage | SQLite (IoA metadata) |
| Network Simulation | Self-developed multi-domain network simulator (4 domains × 16 nodes) |
| Frontend | Native HTML5 + Chart.js + vis-network.js |
## Architecture Overview
```
┌─────────────────────────────────────────────┐
│ GUI Control Panel (Material Symbols) │
│ Topology View │ Message Flow │ DAG Visualization │ Dashboard │
├─────────────────────────────────────────────┤
│ IoA Middleware Layer (Self-Developed) │
│ ┌────────┐ ┌────────┐ ┌────────┐ ┌──────┐ │
│ │Registration Center│ │Multi-Dimensional Weighted Routing│ │DAG Scheduling│ │Closed-Loop Verification│ │
│ └────────┘ └────────┘ └────────┘ └──────┘ │
├─────────────────────────────────────────────┤
│ Agent Runtime (LangGraph) │
│ orchestrator → monitor → diagnoser → │
│ repairer → verifier │
├─────────────────────────────────────────────┤
│ Integration & Data Layer │
│ Network Simulator │ MCP Server │ Log │ SQLite │
└─────────────────────────────────────────────┘
```
## Quick Start
### Environment Requirements
- Python 3.10+
- pip
- System memory ≥ 1GB (simulator + middleware ≈ 500MB)
### Installation
```bash
cd backend
pip install -r requirements.txt
```
### Start (default port)
```bash
python run.py
```
After the service starts:
- Middleware + GUI: http://127.0.0.1:8000
- Network Simulator: http://127.0.0.1:8001
- GUI: http://127.0.0.1:8000/gui
### One-Click Experience
Open the GUI, click the **▶ One-Click Demo** button, and the system will automatically execute:
1. Clear existing faults
2. Inject "East China region link congestion" fault
3. Send natural language instructions → trigger full_remediation DAG
4. Approximately 6 seconds to complete the full-link closed-loop (monitoring → diagnosis → repair → verification)
## Agent Architecture (9 instances / 5 types)
| Agent | Instances | Responsibilities | Technology |
|-------|--------|------|------|
| **OrchestratorAgent** | ×1 | Receive natural language instructions, intent identification → DAG template matching → task distribution | LangGraph + rule engine |
| **MonitorAgent** | ×4 | Sub-domain real-time indicator collection (East China/North China/South China/West China), anomaly detection | Simulator API polling |
| **DiagnoserAgent** | ×1 | Root cause analysis, multi-dimensional indicator cross-comparison, rule engine + LLM enhancement | DeepSeek LLM |
| **RepairerAgent** | ×1 | Differentiated repair execution (5 strategies: routing switch/ACL/traffic shaping/link transfer/service restart) | State machine |
| **VerifyAgent** | ×1 | Closed-loop verification, three-state judgment + real-time indicator bottom-line | Verification engine |
| **ReporterAgent** | ×1 | Full-link operation and maintenance report generation | LLM text generation |
## DAG Workflow
```
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ monitor │ ──→ │diagnose │ ──→ │ repair │ ──→ │ verify │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
Collect indicators Root cause analysis Automatic repair Closed-loop verification
(5-10s) (LLM inference) (instruction execution) (three-state judgment)
```
The full_remediation DAG from fault injection to verification passing takes about **6 seconds** (link congestion scenario).
## Key APIs
| Endpoint | Method | Description |
|------|------|------|
| `/registry/agents` | GET | Agent list (Bearer <PSK>, need to configure IOA_PSK environment variable) |
| `/dag` | POST | Create DAG |
| `/dag/{dag_id}` | GET | Query DAG status |
| `/messages` | POST | Send IoAP message (NL instruction entry) |
| `/simulator/metrics` | GET | Network-wide real-time indicators |
| `/simulator/fault/inject` | POST | Inject fault |
| `/simulator/fault/clear_all` | GET | Clear all faults |
## Project Structure
```
IoA Distributed Network Operation and Maintenance Collaborative Platform/
├── backend/
│ ├── ioa_middleware/ # IoA middleware core
│ │ ├── main.py # FastAPI application entry
│ │ ├── registry.py # Agent registration center
│ │ ├── router.py # Multi-dimensional weighted message routing bus
│ │ └── orchestrator/ # DAG scheduling engine
│ │ ├── scheduler.py # Kahn topological sorting
│ │ └── templates.py # DAG template library
│ ├── agents/ # Agent implementation
│ │ ├── __init__.py # Agent factory
│ │ ├── base_agent.py # Base class
│ │ ├── orchestrator_agent.py
│ │ ├── monitor_agent.py
│ │ ├── diagnoser_agent.py
│ │ ├── repairer_agent.py
│ │ └── verifier_agent.py
│ ├── simulator/ # Network simulator
│ │ ├── api.py # Simulator API
│ │ └── network.py # Topology and traffic model
│ ├── data/ # SQLite database
│ └── run.py # One-click startup
├── gui/
│ └── index.html # Control panel (Material Symbols icon)
├── docs/
│ ├── ARCHITECTURE.md # Architecture design document
│ ├── IOAP_PROTOCOL.md # IoAP protocol specification
│ └── DEMO_SCRIPT.md # Demo video script
├── requirements.txt
└── README.md
```
## Team
- Competition event: B-EP1 Intelligent Internet of Agents Innovation Research
- Topic direction: Cross-domain distributed task collaborative scheduling system
- Technical keywords: IoA, multi-dimensional weighted routing, DAG orchestration, LangGraph, closed-loop verification
## Original Statement
This project is a **2026 C4 Network Technology Challenge B-EP1 event** participating work, independently designed and developed by the participating team.
**Statement content**:
1. **Originality**: All codes, architecture design, and documents of this project are original works, without plagiarism of any existing projects or open-source codes.
2. **Technical implementation**:
- Multi-dimensional weighted message routing engine (four-dimensional scoring algorithm) is self-developed
- DAG scheduling engine (Kahn topological sorting + retry strategy) is self-developed
- Closed-loop verification mechanism (three-state judgment + real-time indicator bottom-line) is self-developed
- IoAP message protocol is self-developed protocol specification
- Network simulator (4 domains × 16 nodes) is self-developed
3. **Open-source framework usage**:
- LangChain / LangGraph: Used for LLM integration, following Apache 2.0 protocol
- FastAPI: Used for web framework, following MIT protocol
- MCP SDK: Used for MCP protocol implementation, following MIT protocol
- All dependencies are declared in `requirements.txt`
4. **Third-party resources**:
- Material Symbols icon: Provided by Google, following Apache 2.0 protocol
- vis-network.js: Used for topology visualization, following Apache 2.0 protocol
- Chart.js: Used for chart display, following MIT protocol
5. **Data source**: All test data are simulated and generated, without involving real user data.
6. **Intellectual property**: This project does not infringe on any third-party intellectual property rights. If there is any infringement, the participating team bears all responsibilities.
**Participating team commitment**: This work is original and meets the competition rules and academic integrity requirements.
## License
This project adopts the [MIT License](LICENSE) open-source license.
*Last updated: 2026-06-03*
