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 influence plan generation, plan execution, and gated step approvals where enabledPolicies evaluated at every step gate check
GranularityPer-plan and per-stepPer-step and per-tool within steps

Most teams assessing 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. In production, teams typically separate plan generation from execution so they can inspect, approve, update, version, or estimate a plan before they run it.

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, inspect, update with optimistic concurrency, execute, cancel, resume, and roll back where enabled by tier
  • Broad provider support through the shared runtime config layer: openai, anthropic, gemini, azure-openai, bedrock, and ollama
# Generate a plan through the Agent convenience surface
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 stored plan through the Agent convenience surface
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"}}'

MAP's confirm / step execution modes pause the plan at each gated step and route the step to the HITL queue; reviewers approve or reject via POST /api/v1/plans/{plan_id}/steps/{step_id}/approve|reject and list pending plan-level approvals via GET /api/v1/plans/approvals/pending. The plane-scoped endpoints are available on Evaluation+ and share response shape with the WCP equivalents (minus plan_id, which only the MAP plane populates). See HITL Approval Gates for the full reviewer surface.

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 replacing your orchestration stack, you add gate checks before each step executes. AxonFlow evaluates policies and returns allow, block, or require_approval, while your orchestrator stays in control of the actual work.

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
  • Generic workflow registration for LangChain, CrewAI, and custom sources via source: external
  • 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. Teams that need richer operator workflows can also use the unified execution APIs and protected portal views for tenant-level monitoring and approvals.

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
  • You want a reviewed plan lifecycle with preview, cost estimation, approval, or versioning before execution
  • 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.

Strategic Orchestration Guides​

If you are assessing AxonFlow as an operating layer for serious agent systems, the most useful companion pages are:

Last updated on