WBSP
ProvidersDocsSign in

starter

A variant of AI Agent Orchestration Platform.

View the interactive variant page →

AI Agent Orchestration Platform

Part of the worlds-biggest-software-project initiative.

An open, LLM-native orchestration platform that unifies multi-agent workflow management, tool registries, and observability in a single product.

The AI Agent Orchestration Platform is a developer-first system for defining, executing, and governing multi-agent workflows. It targets platform engineering teams, AI-native product teams, and enterprise IT leaders moving agents from proof-of-concept to production, where today's stack typically requires bolting a framework (LangGraph, CrewAI, AutoGen) onto a separate durable execution engine (Temporal, Inngest) and a third-party tracing tool (LangSmith, Langfuse).

Why AI Agent Orchestration Platform?

  • Fragmented stack: most teams cobble together a framework (LangGraph/CrewAI), a durable execution engine, and a separate tracing tool — a single product that bundles orchestration and observability removes that integration friction.
  • Durable engines are not LLM-native: Temporal and Inngest were not designed around token budgets, rate limits, or model fallback chains; an engine that treats LLM calls as first-class citizens has a structural advantage.
  • Split between visual and code-only tools: n8n offers a visual builder with shallow agent primitives, while LangGraph and AutoGen demand significant boilerplate; a hybrid product addresses both segments.
  • Compliance is bolted on, not built in: regulated buyers in finance and healthcare need audit trails, PII redaction, and access controls in the orchestration layer — Kore.ai delivers this at six-figure annual contracts, leaving the mid-market unserved.
  • Cross-org agent delegation is sparse: emerging standards like Model Context Protocol (MCP) and Agent2Agent (A2A) are not natively supported by most incumbents, despite enterprises increasingly invoking agents across business units and vendors.

Key Features

Multi-Agent Orchestration

  • Multi-agent management with message passing, context sharing, and delegation between agents
  • Sequential, hierarchical, and consensual execution models for collaborative workflows
  • Sub-agent and subgraph composition for modular multi-agent architectures
  • Role-based agent abstraction with goal and backstory definition

Durable Execution and State

  • State persistence with crash recovery and replay
  • Checkpoint-resume pattern for efficient retries without full re-execution
  • Time-travel debugging with state snapshots for inspection of past executions
  • Configurable retry logic with backoff and termination policies
  • Long-running task support without timeout constraints

LLM-Native Runtime

  • First-class LLM call primitives with token budgeting and cost attribution
  • Multi-model support across OpenAI, Anthropic, and open-source providers
  • Streaming output for real-time agent feedback
  • Tool/action registry with OpenAPI / JSON Schema definitions
  • Model Context Protocol (MCP) support for standardised tool hand-off

Workflow Definition and UX

  • Hybrid code and no-code workflow builder with drag-and-drop composition and code escape hatch
  • Trigger surface covering API, webhooks, events, and cron schedules
  • Git-based workflow versioning and version control
  • Human-in-the-loop interruption gates for state modification

Governance and Observability

  • Real-time execution traces, event logs, and OpenTelemetry-compatible spans
  • Audit trails, PII redaction, and policy enforcement for regulated industries
  • Role-based access control for team collaboration
  • Per-agent and per-execution cost dashboards
  • Anomaly and drift detection on agent behaviour

AI-Native Advantage

The platform treats LLM calls as first-class workflow primitives rather than opaque activities, enabling token-aware scheduling, automated fallback chains across providers, and execution-trace analysis to surface prompt and tool-selection improvements over time. AI-driven anomaly detection flags hallucination, drift, and security violations, while governance policy suggestion analyses observed agent behaviour to recommend audit and redaction rules. Cross-organisation delegation via MCP and A2A is built into the core rather than retrofitted.

Tech Stack & Deployment

The platform is designed to support self-hosted, cloud, and hybrid deployment, mirroring the flexibility offered by Temporal, n8n, and Trigger.dev. It aligns with emerging open standards: Model Context Protocol (MCP) for tool and inter-agent context hand-off, Agent2Agent (A2A) for cross-organisational discovery and delegation, OpenTelemetry for observability, and OpenAPI / JSON Schema for tool descriptions. SDK and integration approach follows the multi-language pattern established by Temporal (Java, Go, Python, Node.js) with strong TypeScript ergonomics in the spirit of Trigger.dev.

Market Context

The global AI agent orchestration software market was valued at approximately USD 4.7 billion in 2024 and is projected to reach USD 26.3 billion by 2034 at a CAGR of 18.8% (IntelEvoResearch, 2026). Open-source frameworks (LangGraph, CrewAI, AutoGen) are free; managed observability tiers start around USD 39/mo (LangSmith), self-serve durable execution SaaS targets USD 50–500/mo (Inngest, Trigger.dev), and enterprise governance platforms such as Kore.ai command six-figure annual contracts. Primary buyers are platform engineering teams, AI-native product teams, enterprise IT leaders, and AI/ML engineers at mid-size companies — a population where 62% of organisations are experimenting with agents but only 23% are scaling them (Redis, 2026).

Project Status

The platform is built and shipping — all nine development phases are complete, with SDKs, a one-command self-hosted deploy, and a standalone preview image for evaluation. Contributions, feedback, and domain expertise are welcome.

Contributing

We welcome contributions from developers, domain experts, and potential users. See CONTRIBUTING.md for guidelines.

Important: All contributions must be your own original work or clearly attributed open-source material with a compatible licence. Copyright infringement and licence violations will not be tolerated and will result in immediate removal of the offending contribution. If you are unsure whether a piece of code, text, or other material is safe to contribute, open an issue and ask before submitting.

Licence

Licence to be determined. See discussion for context.

Quickstart (self-hosted, one command)

All application code lives under target/. Data stores are provisioned by the WBSP platform — never a hand-rolled compose database.

# 1) Deploy the single component (provisions Postgres 16 + Redis 7, runs migrations)
wbsp-app deploy --destination dev          # container on :8080, host port 30341

# 2) Sign in via HAP hosted login, then create a programmatic API key
open http://localhost:30341/api/auth/login
#   → POST /v1/api-keys  (secret shown once)

# 3) Define and invoke a costed agent (US1 MVP)
curl -X POST http://localhost:30341/v1/agents -H "Authorization: Bearer $AOP_KEY" \
  -d '{"slug":"researcher","name":"Researcher","model":"claude-opus-4-8",
       "model_provider":"anthropic","risk_classification":"limited"}'
curl -X POST http://localhost:30341/v1/agents/researcher/invoke \
  -H "Authorization: Bearer $AOP_KEY" -d '{"input":"Summarize relativity in one sentence"}'
#   → response + {tokens_input, tokens_output, cost_cents, model, is_fallback}

Local development loop

cd target
uv sync                       # backend deps + gates (ruff, mypy, pytest, testcontainers)
uv run ruff check src && uv run ruff format --check src
uv run mypy --strict src
uv run pytest                 # unit + integration (real PG16/Redis7 via Docker)
uv run python scripts/export_openapi.py   # regenerate docs/openapi.json

cd ui && pnpm install && pnpm run build    # Next.js static export → ui/out (served by FastAPI)
pnpm exec vitest run                        # UI unit tests