Multi-Agent Planning (MAP)

Enterprise Feature

Full Multi-Agent Planning capabilities including database-backed agents and CRUD APIs are available in AxonFlow Enterprise. This page provides an overview of MAP architecture and basic usage.

Contact Sales | View Enterprise Guide

Overview

Multi-Agent Planning (MAP) is AxonFlow's orchestration layer for coordinating multiple AI agents to accomplish complex tasks. MAP breaks down user requests into subtasks, assigns them to specialized agents, and aggregates results.

Key Concepts

Planning Engine

The Planning Engine analyzes incoming requests and generates execution plans:

User Request: "Plan a business trip to Mumbai"
                    │
                    ▼
            ┌───────────────┐
            │ Planning      │
            │ Engine        │
            └───────────────┘
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
   ┌─────────┐ ┌─────────┐ ┌─────────┐
   │ Flight  │ │ Hotel   │ │ Ground  │
   │ Agent   │ │ Agent   │ │ Trans.  │
   └─────────┘ └─────────┘ └─────────┘
        │           │           │
        └───────────┴───────────┘
                    │
                    ▼
            ┌───────────────┐
            │ Aggregated    │
            │ Response      │
            └───────────────┘

Agent Types

Type	Description	Example
Specialist	Single-domain expertise	Flight booking, hotel search
Coordinator	Orchestrates other agents	Trip planner, workflow manager
Validator	Validates outputs	Policy checker, data validator

Execution Modes

Mode	Description	Use Case
Sequential	Agents run in order	Dependent tasks
Parallel	Agents run simultaneously	Independent tasks
Conditional	Agents run based on conditions	Decision trees
Iterative	Repeat until condition met	Refinement loops

Community vs Enterprise Features

Feature	Community	Enterprise
Static agent registry	✅	✅
Basic planning	✅	✅
Sequential execution	✅	✅
Parallel execution	✅	✅
Database-backed agents		✅
Agent CRUD API		✅
Customer-defined agents		✅
Agent versioning		✅
Execution analytics		✅
Visual workflow builder		✅

Basic Usage (Community)

Define Static Agents

Create agents in your configuration:

# agents.yaml
agents:
  - id: flight-search
    name: Flight Search Agent
    description: Searches for flight options
    capabilities:
      - flight_search
      - fare_comparison
    tools:
      - amadeus-connector
    prompt_template: |
      You are a flight search specialist.
      Search for flights matching: {{query}}

  - id: hotel-search
    name: Hotel Search Agent
    description: Searches for hotel accommodations
    capabilities:
      - hotel_search
      - rate_comparison
    tools:
      - hotel-connector
    prompt_template: |
      You are a hotel search specialist.
      Find hotels matching: {{query}}

  - id: trip-planner
    name: Trip Planner Coordinator
    description: Coordinates travel planning
    type: coordinator
    delegates_to:
      - flight-search
      - hotel-search

Request Processing

Send a multi-agent request:

curl -X POST https://your-axonflow.com/api/v1/plan \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "query": "Plan a 3-day business trip to Mumbai from Delhi, departing Dec 15",
    "mode": "multi-agent-plan",
    "options": {
      "execution_mode": "parallel",
      "timeout_seconds": 60
    }
  }'

Response:

{
  "plan_id": "plan-abc123",
  "status": "completed",
  "execution_time_ms": 2450,
  "agents_used": ["trip-planner", "flight-search", "hotel-search"],
  "result": {
    "flights": [...],
    "hotels": [...],
    "summary": "Found 5 flight options and 12 hotels for your Mumbai trip."
  }
}

Planning Templates

Sequential Planning

Tasks execute in order, each receiving the previous output:

plan:
  type: sequential
  steps:
    - agent: data-collector
      input: "{{user_query}}"
    - agent: analyzer
      input: "{{previous.output}}"
    - agent: report-generator
      input: "{{previous.output}}"

Parallel Planning

Independent tasks execute simultaneously:

plan:
  type: parallel
  steps:
    - agent: flight-search
      input: "{{travel_details}}"
    - agent: hotel-search
      input: "{{travel_details}}"
    - agent: car-rental
      input: "{{travel_details}}"
  aggregation:
    strategy: merge

Conditional Planning

Execution path based on conditions:

plan:
  type: conditional
  condition: "{{intent}} == 'booking'"
  branches:
    - when: "booking"
      agent: booking-agent
    - when: "inquiry"
      agent: info-agent
    - default:
      agent: general-agent

Enterprise Features Preview

Database-Backed Agents

Enterprise customers can create agents dynamically via API:

POST /api/v1/agents
{
  "name": "Custom Support Agent",
  "description": "Handles customer support queries",
  "capabilities": ["support", "faq"],
  "prompt_template": "...",
  "model": "claude-3-sonnet"
}

Agent Versioning

Track and manage agent versions:

GET /api/v1/agents/support-agent/versions
{
  "versions": [
    {"version": "v2.1.0", "status": "active", "created": "2025-12-01"},
    {"version": "v2.0.0", "status": "archived", "created": "2025-11-15"}
  ]
}

Execution Analytics

Monitor agent performance:

• Execution time per agent
• Success/failure rates
• Token usage by agent
• Cost attribution

Architecture

Request Flow

1. Request arrives at Orchestrator
2. Planning Engine analyzes intent
3. Agent Registry provides available agents
4. Execution Plan generated
5. Agents execute (parallel/sequential)
6. Results aggregated
7. Response returned

Agent Registry

Mode	Description	Storage
Static	Config file agents	YAML/JSON
Database	Dynamic agents (Enterprise)	PostgreSQL
Hybrid	Both sources (Enterprise)	Combined

Best Practices

Agent Design

1. Single responsibility - Each agent has one clear purpose
2. Clear capabilities - Define what each agent can do
3. Appropriate tools - Only provide needed connectors
4. Specific prompts - Tailored prompt templates

Planning Optimization

1. Parallelize when possible - Independent tasks run faster
2. Set appropriate timeouts - Prevent hung plans
3. Use caching - Cache repeated queries
4. Monitor execution - Track agent performance

Error Handling

1. Graceful degradation - Handle agent failures
2. Retry logic - Automatic retries for transient errors
3. Fallback agents - Alternative agents for failures
4. Timeout handling - Cancel hung tasks

Example: Travel Planning

Agent Configuration

agents:
  # Specialist agents
  - id: flight-specialist
    capabilities: [flight_search, booking]
    tools: [amadeus]

  - id: hotel-specialist
    capabilities: [hotel_search, booking]
    tools: [hotel-api]

  - id: policy-checker
    capabilities: [compliance_check]
    tools: [policy-api]

  # Coordinator
  - id: travel-coordinator
    type: coordinator
    delegates_to:
      - flight-specialist
      - hotel-specialist
      - policy-checker

Execution Flow

User: "Book a trip to Mumbai for next week"
        │
        ▼
┌─────────────────────────────────────┐
│ Travel Coordinator                   │
│ - Parse request                      │
│ - Create execution plan              │
└─────────────────────────────────────┘
        │
        ├──────────────┬──────────────┐
        ▼              ▼              ▼
  ┌──────────┐  ┌──────────┐  ┌──────────┐
  │ Flight   │  │ Hotel    │  │ Policy   │
  │ Search   │  │ Search   │  │ Check    │
  └──────────┘  └──────────┘  └──────────┘
        │              │              │
        └──────────────┴──────────────┘
                       │
                       ▼
              ┌──────────────┐
              │ Aggregate &   │
              │ Return Result │
              └──────────────┘

Related

• Policy Syntax
• Policy Examples
• MCP Connectors

Get Enterprise

For full MAP capabilities:

• Request a Demo - See MAP in action
• Contact Sales - Discuss your use case
• Enterprise Guide - Full implementation details