Skip to main content

Orchestration & Workflow Governance

AxonFlow provides two complementary capabilities for AI workflow orchestration. Which one you use depends on whether you want AxonFlow to run your workflows or govern workflows that another orchestrator runs.

Two Approaches​

Multi-Agent Planning (MAP)Workflow Control Plane (WCP)
What it doesAxonFlow generates and executes multi-step plansAxonFlow adds governance gates to workflows run by external orchestrators
Who runs the workflowAxonFlow orchestratorYour orchestrator (LangGraph, CrewAI, Temporal, Airflow, custom)
When to useYou want AxonFlow to handle orchestration end-to-endYou already have an orchestrator and need governance, audit trails, and policy enforcement
GovernancePolicies evaluated at plan execution timePolicies evaluated at every step gate check
GranularityPer-plan and per-stepPer-step and per-tool within steps

Most teams evaluating AxonFlow for the first time start with WCP, because it works with their existing orchestrator without requiring migration. Teams that want AxonFlow to handle orchestration end-to-end use MAP.

Multi-Agent Planning (MAP)​

MAP is AxonFlow's built-in orchestration engine. It breaks down user requests into subtasks, assigns them to specialized agents, executes steps (sequentially, in parallel, or conditionally), and aggregates results. Governance policies are enforced at plan execution time.

Key capabilities:

  • Plan generation from natural language queries with domain-specific templates
  • Five step types: llm-call, connector-call, conditional, function-call, api-call
  • Agent registry with YAML configuration (file-based in Community, database-backed in Enterprise)
  • Execution modes: sequential, parallel, and conditional branching
  • Plan lifecycle: generate, update with optimistic concurrency, execute, cancel, rollback
# Generate a plan
curl -X POST http://localhost:8080/api/request \
  -H "Content-Type: application/json" \
  -d '{"query": "Research remote work benefits", "request_type": "multi-agent-plan"}'

# Execute the plan
curl -X POST http://localhost:8080/api/request \
  -H "Content-Type: application/json" \
  -d '{"query": "execute", "request_type": "execute-plan", "context": {"plan_id": "plan_abc123"}}'

Learn more: MAP Getting Started | Agent Configuration | Step Types | Planning Patterns

Workflow Control Plane (WCP)​

WCP adds governance checkpoints to workflows run by external orchestrators. Instead of modifying your orchestrator's code, you add gate checks before each step executes. AxonFlow evaluates policies and returns allow, block, or require_approval.

Key capabilities:

  • Step gates for any workflow step: LLM calls, tool calls, connector calls, human tasks
  • Per-tool governance within multi-tool nodes (each tool gets its own gate check)
  • LangGraph adapter for Python, TypeScript, Go, and Java with automatic lifecycle management
  • MCP tool interceptor for policy-enforced data access through Model Context Protocol
  • Circuit breaker with auto-trip on upstream LLM failures and per-tenant thresholds
  • Trace correlation with LangSmith, Datadog, and OpenTelemetry via trace_id
from axonflow import AxonFlow
from axonflow.adapters import AxonFlowLangGraphAdapter

async with AxonFlow(endpoint="http://localhost:8080") as client:
    adapter = AxonFlowLangGraphAdapter(client, "my-workflow")

    async with adapter:
        await adapter.start_workflow(trace_id="langsmith-run-abc")

        # Gate check before each step
        if await adapter.check_gate("generate", "llm_call", model="gpt-4"):
            result = await generate(state)
            await adapter.step_completed("generate")

        # Per-tool governance within a tools node
        if await adapter.check_tool_gate("web_search", "function"):
            result = await web_search(state)
            await adapter.tool_completed("web_search", output=result)

Learn more: WCP Overview | SDK Integration | Per-Tool Governance | Policy Configuration

Execution Visibility​

Both MAP and WCP executions are captured for debugging, auditing, and compliance. The Execution Viewer provides a timeline of every step, policy decision, token usage, and cost. Enterprise customers get a unified Execution Timeline in the Customer Portal with SSE real-time streaming.

Choosing Between MAP and WCP​

Use MAP when:

  • You are building a new AI application and want AxonFlow to handle orchestration
  • You want LLM-powered plan generation from natural language
  • Your workflow maps to the agent-task-step model

Use WCP when:

  • You already use LangGraph, CrewAI, Temporal, Airflow, or a custom orchestrator
  • You need to add governance to an existing system without migration
  • You need per-tool governance granularity within workflow nodes
  • You need human-in-the-loop approval gates at specific steps

Both capabilities share the same policy engine, audit trail, and observability infrastructure. Teams can adopt one or both depending on their needs.

Last updated on