AgentFlow — Multi-Agent Collaborative Engineering Analysis Platform

AgentFlow is a multi-agent collaborative framework that orchestrates specialized AI agents to solve complex engineering analysis problems. It demonstrates long-chain reasoning and multi-agent collaboration — where a Planner decomposes problems, an Analyst performs mathematical modeling, a Coder generates simulation code, and a Reviewer validates results, all coordinated through an intelligent Orchestrator.

Architecture

┌─────────────────────────────────────────────────────────┐
│                    Orchestrator Agent                    │
│         (Workflow coordination & state management)       │
└──────┬──────────┬──────────┬──────────┬─────────────────┘
       │          │          │          │
       ▼          ▼          ▼          ▼
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Planner  │ │ Analyst  │ │  Coder   │ │ Reviewer │
│  Agent   │ │  Agent   │ │  Agent   │ │  Agent   │
├──────────┤ ├──────────┤ ├──────────┤ ├──────────┤
│ Problem  │ │ Math &   │ │ Code     │ │ Result   │
│ Decompo- │ │ Physics  │ │ Genera-  │ │ Validation│
│ sition   │ │ Modeling │ │ tion     │ │ & Refine  │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
       │          │          │          │
       └──────────┴──────────┴──────────┘
                       │
                       ▼
              ┌─────────────────┐
              │  Shared Context  │
              │  & Memory Store  │
              └─────────────────┘

Key Features

• Long-chain reasoning: Problems are decomposed into 5-10+ sequential reasoning steps, with each agent building on the previous agent's output
• Multi-agent collaboration: 5 specialized agents communicate through a structured message-passing protocol
• Iterative refinement: The Reviewer agent can trigger re-analysis loops when results don't meet quality thresholds
• Real engineering applications: Built-in examples for beam deflection analysis, truss structure FEA, and thermal stress simulation
• Token-efficient orchestration: Designed to simulate high-volume LLM interactions — each full workflow consumes 50K-200K tokens

Project Structure

agentflow/
├── src/agentflow/
│   ├── __init__.py
│   ├── core/
│   │   ├── __init__.py
│   │   ├── orchestrator.py    # Main workflow coordinator
│   │   ├── context.py         # Shared state & memory
│   │   └── messaging.py       # Inter-agent communication protocol
│   ├── agents/
│   │   ├── __init__.py
│   │   ├── base.py            # Base agent class
│   │   ├── planner.py         # Problem decomposition agent
│   │   ├── analyst.py         # Math/physics modeling agent
│   │   ├── coder.py           # Simulation code generation agent
│   │   └── reviewer.py        # Quality validation agent
│   ├── examples/
│   │   ├── __init__.py
│   │   ├── beam_deflection.py # Cantilever beam analysis
│   │   ├── truss_fea.py       # Truss structure FEA
│   │   └── thermal_stress.py  # Thermal-structural coupling
│   └── utils/
│       ├── __init__.py
│       └── reporting.py       # Result visualization & reporting
├── tests/
├── results/                   # Simulation outputs
├── requirements.txt
└── README.md

Quick Start

# Install dependencies
pip install -r requirements.txt

# Run a beam deflection analysis (demonstrates full multi-agent workflow)
python -m agentflow.examples.beam_deflection

# Run truss structure FEA with iterative refinement
python -m agentflow.examples.truss_fea

# Run thermal-structural coupling analysis
python -m agentflow.examples.thermal_stress

Example: Cantilever Beam Deflection Analysis

The system receives a natural language description: "Analyze a 2m steel cantilever beam under 5kN tip load, determine max deflection and stress"

Workflow (demonstrating long-chain reasoning):

1. Planner Agent → Decomposes into 7 sub-tasks: geometry modeling, material properties, loading analysis, analytical solution, FEA discretization, numerical solution, validation
2. Analyst Agent → Computes analytical solution: δ_max = PL³/(3EI), σ_max = My/I
3. Coder Agent → Generates 150+ lines of Python FEA code with mesh generation, stiffness matrix assembly, and solver
4. Reviewer Agent → Validates FEA vs analytical results (error < 2%), checks mesh convergence
5. Orchestrator → Compiles comprehensive engineering report with visualizations

Token consumption per run: ~85,000 tokens (demonstrating heavy AI usage)

Use Cases

This framework is designed for engineering scenarios requiring complex multi-step AI reasoning:

• Structural analysis & FEA simulation
• Thermal-mechanical coupling problems
• Fluid dynamics parameter studies
• Multi-physics optimization workflows
• Automated engineering report generation

Why This Matters for AI Agent Evaluation

AgentFlow is intentionally designed to stress-test LLM capabilities:

• Context management: Shared state across 5+ agents requires robust context handling
• Long-form reasoning: Each workflow involves 5-10 sequential reasoning steps
• Code generation quality: Agents must produce correct, runnable scientific Python code
• Self-correction: The Reviewer agent identifies errors and triggers re-generation loops
• Domain expertise: Requires cross-disciplinary knowledge (mechanics + numerical methods + programming)

License

MIT License — feel free to use, modify, and distribute.