Skip to main content

AI Capabilities Overview

Flowable is the Agentic Case Platform that brings together AI agents, people, and processes — orchestrated. AI services can be modeled as agent models and are supported as first-class citizens, alongside process, case, and business rules models. For enterprise applications, where consistency, predictability, and auditability are critical, the Flowable platform provides the necessary tools to include AI in a controlled and transparent way. The combined AI features collectively are known under the product name Flowable Agentic Case Platform.

Processes and case models can be extended with AI functionality, allowing users to define the level of autonomy given to AI services. On the one side of the spectrum this includes fully automated behavior and on the other extreme flows where human input is required to review and approve AI-generated suggestions. These patterns are typically implemented using well-known standard BPMN and CMMN patterns and constructs.

The sections below cover the core AI capabilities of the platform: the agent engine and its agent types, how CMMN provides a dynamic orchestration harness, multi-LLM provider support, RAG and knowledge bases, AI-assisted design, document AI, interoperability standards, guardrails and evaluators, agent testing, governance, cost management, and dashboard generation.

AI Agent Engine​

Flowable includes a dedicated Agent Engine, a first-class engine alongside its BPMN, CMMN, and DMN engines, purpose-built for embedding AI agents into business process and case management workflows. Agents are modeled visually in the low-code Design environment and deployed alongside process and case definitions, following the same governed lifecycle as any other automation artifact. Agents participate natively in BPMN processes and CMMN cases as service tasks, making AI a first-class participant in structured workflows rather than an external add-on.

See the Agent Introduction for modeling details and the AI Agent Task in BPMN and AI Agent Task in CMMN reference pages for usage within process and case models.

Agent Types​

Eight agent types are supported:

  1. Utility Agent: Executes specific tasks within processes or cases autonomously using LLM prompts with defined input/output.
  2. Knowledge Agent: Retrieval-augmented agent grounded in organizational knowledge through Knowledge Base models.
  3. Document Agent: Document understanding, classification, summarization, and structured data extraction.
  4. Orchestrator Agent: Coordinates multiple sub-agents in multi-agent patterns. See the Orchestrator Agent Deep Dive for advanced usage.
  5. External Agent: Delegates to third-party AI platforms such as Salesforce Agentforce, AWS Bedrock, and Azure AI Foundry.
  6. A2A Agent: Supports Google's Agent-to-Agent protocol for cross-platform agent interoperability.
  7. Guardrail Agent: 2026.1.0+ Acts as a content judge that checks text before or after an LLM call and returns a pass/fail result, enforcing safety and quality policies at runtime. See Guardrails.
  8. Evaluator Agent: 2026.1.0+ Acts as a quality judge that grades the output of another agent, recording a pass/fail verdict and a score for observability and testing. See Evaluators.

Multi-Agent Orchestration​

Multi-agent orchestration is a core capability: orchestrator agents compose sub-agents, chain tool calls, and coordinate complex multi-step AI workflows. Agents can invoke other agents, platform services, and external APIs as tools with validated inputs and outputs.

See Orchestrating AI Services for orchestration patterns and the Advanced Orchestration page for complex scenarios.

CMMN as an Agentic Orchestration Harness​

Flowable uses its CMMN (Case Management) engine as a dynamic orchestration harness for AI agents. Unlike sequential process flows, a CMMN case model defines a space of possible actions that evolves as the case progresses through its lifecycle. Actions that are available early in a case (e.g., requesting additional information) may no longer be permitted at a later stage (e.g., after a decision has been made). The case state continuously governs what the agent can and cannot do.

In this model, plan items act as tools available to the agent. Each plan item is a modeled, governed building block that the agent can select and invoke, much like tools in an agentic AI framework. These building blocks range from simple actions (a human task, a service call) to entire subprocesses with their own logic, calling external services, orchestrating multi-step operations, or doing anything a BPMN process can do. The difference is that these tools are not statically registered but dynamically scoped by the case lifecycle.

The core mechanism is AI activation: whenever something changes in a case, the platform evaluates all currently enabled plan items and uses the AI agent to determine which ones should be activated. Plan items can be configured for AI-driven suggestion (the agent recommends an action for human approval) or AI-driven automatic activation (the agent triggers the step directly).

This creates a fundamentally different orchestration model compared to traditional process automation. Rather than following a predefined sequence, the AI agent navigates a dynamically scoped set of actions, responding to incoming data and changing conditions. The case model provides structure and governance; the agent provides adaptiveness and autonomy.

See the Orchestrator Agent Deep Dive for a detailed explanation of the engine implementation and the Orchestrator Agent Example for a practical walkthrough.

Multi-LLM Provider Support​

Flowable provides a vendor-neutral LLM integration layer built on Spring AI. Natively supported providers include OpenAI, Anthropic Claude, and Azure OpenAI. It also supports any provider that exposes an Anthropic/OpenAI compatible REST API, such as a locally hosted model (Ollama, vLLM), a reverse proxy in front of the official API, or a third-party hosted model, by overriding the base URL and request paths and setting custom authentication or headers. External agent integrations additionally support Azure AI Foundry, AWS Bedrock, and Salesforce Agentforce. Any LLM provider supported by the Spring AI ecosystem can be added with minimal effort. Each agent independently configures its AI vendor, model, and parameters through Model Settings, enabling mixed-model strategies within a single application (e.g., one model for reasoning tasks, another for structured extraction, a local model for sensitive operations).

2026.1.0+ Alternatively, an Agent Connection holds the vendor, model, and credentials centrally and is referenced by key from the agent model, so administrators can govern which endpoints and models are in use and change a model or credential in one place without republishing the agents.

See the AI Setup Guide for configuration details.

RAG and Knowledge Bases​

Flowable provides an end-to-end Retrieval-Augmented Generation (RAG) pipeline as a first-class platform capability. Knowledge Bases are a visual model type, created in Design, deployed to Work, versioned and governed like any other definition.

The ingestion pipeline automatically processes documents (PDF, Word, Excel, PowerPoint, Email) through text extraction, intelligent chunking, embedding, and vector storage. Supported vector store backends include Elasticsearch and OpenAI and can be extended with custom implementations.

Agent prompts are transparently augmented with relevant knowledge base content at invocation time. Two modes are available: full lifecycle management (the platform owns the index) and search-only (federated access to externally managed indexes).

Vectorization?

Vectorization is the process of converting text into numerical representations (vectors) that capture the meaning and context of the content. This enables efficient similarity searches and matching during AI queries and prompt matching.

AI-Assisted Process Design​

The Design environment includes generative AI capabilities for model authoring. Users can generate complete models from natural language descriptions using the AI-Assisted Modeling feature. An interactive AI chat enables multi-turn conversational editing of any model; users describe desired changes in natural language and the platform applies structured modifications to the visual model.

2026.1.0+ Beyond individual models, AI app generation builds a complete application from a prompt or an uploaded specification document. It runs as a guided sequence of steps: it validates the prompt and asks about unclear parts, proposes the case or process structure and a data dictionary, checks which REST and agent integrations are needed, generates the models, the forms and a set of tests, and validates the result before you review and import the app.

A separate coding assistant supports script generation. Generated models can be previewed and refined before import. The AI is context-aware: it understands the current model structure, available data types, variables, and referenced models when generating or modifying designs.

Starting from 2025.2.04+, Flowable also supports OpenAI's Responses API and Anthropic Claude models for AI-assisted modeling. This enables the use of OpenAI's Codex models and Anthropic's Claude Opus models, both of which give superior results for AI-assisted modeling and script generation. See the AI-Assisted Modeling section for the current model recommendations and the AI Setup section for configuration details.

See Creating Models with AI for the model generation workflow and the Overview of GenAI Capabilities section for more information.

Document AI​

The platform provides built-in document intelligence capabilities through the Document Agent and the content analysis features: sentiment analysis across multiple dimensions, summarization, multi-language translation with PDF output, conversational Q&A over document content with multi-turn history, document classification and structured data extraction. Classification and structured data extraction can be triggered automatically when a document is uploaded to a form — see Document analysis.

2026.1.0+ The same classification also runs without a form: when a message arrives on an email inbound channel, the body and each attachment are stored as content items and classified separately, so an email can be recognized as a customer request while its attachment is recognized as an invoice. See Unstructured data classification.

A configurable content transformation pipeline controls how documents (PDF, Word, PowerPoint, Excel, email) are converted before being processed by AI agents. For example, PDFs can be converted to markdown or images. The enabled document formats can be controlled per agent.

Interoperability​

Flowable supports two key open standards for AI interoperability:

  • Agent-to-Agent (A2A): Google's A2A protocol enables cross-platform agent communication. Flowable agents can interact with agents on any A2A-compliant platform through the A2A Agent type.
  • Model Context Protocol (MCP): Allows designers to discover available operations from external MCP-compliant services directly within the Design environment and register them as platform services. These discovered services can then be used deterministically within BPMN processes and CMMN cases like any other integrated service, bridging the gap between AI-era tool ecosystems and structured process automation. See the MCP Configuration Examples, the MCP Parameters Reference, and the Service Registry Introduction for details. Agents can also use MCP services as tools.

2026.1.0+ MCP works in both directions. Flowable also exposes MCP servers of its own, so an AI assistant can drive Flowable through natural language instead of the user interface: the Work MCP server browses process and case definitions, reads and acts on running instances and tasks, and invokes actions, while the Design MCP server browses workspaces and packages and reads, edits, validates, and publishes models. Both enforce the same permissions, tenant scoping, and validation as the corresponding user interface and REST API.

Guardrails 2026.1.0+​

Guardrails validate what goes into an LLM and what comes out, enforcing safety policies, quality standards, and compliance requirements. Input guardrails run before the LLM call and can prevent it entirely, for example on a prompt injection attempt or PII. Output guardrails run afterwards and can discard a response that is off-topic or non-compliant.

They come in four levels that are typically combined: parameter constraints for cheap in-process rules, service registry guardrails that call an external moderation or PII service, delegate expression guardrails for custom Java logic, and guardrail agents that use an LLM to judge nuanced policies. What happens on a violation is modeled rather than fixed: a guardrail can throw a business error caught by a BPMN error boundary event or CMMN fault sentry, log a warning, skip the LLM call, or reject its output, so the surrounding process or case decides how to respond.

See Guardrails for the configuration reference and the guardrails example for a walkthrough.

Evaluators 2026.1.0+​

Evaluators score the quality of an agent's output along dimensions such as correctness, tone, faithfulness to the provided context, and format. Unlike guardrails, they never block, skip, or reject a request; they only measure. They run after an operation has finished, asynchronously and outside the process or case that invoked the agent, so they can never delay or alter the response the caller already received.

Three kinds are supported: evaluator agents that use an LLM as a judge, service registry evaluators that call an external scoring service, and delegate expression evaluators for deterministic Java logic. Each run records a pass/fail verdict, an optional score, and a reason, surfaced on the Evaluations tab of an agent instance and as an evaluator pass rate metric on the agent dashboard, which makes quality regressions between agent versions visible.

See Evaluators for the configuration reference and the evaluators example for a walkthrough.

Testing AI Agents 2026.1.0+​

Agents can be tested in Design before an app is published. A test runs an agent for a given input while mocking the services it calls, so the run is deterministic and independent of live systems, and asserts on the response text, structured output fields, guardrail outcomes, or an extracted document. An agent can also be evaluated ad hoc during modeling to see what it does for a single input, without storing anything.

Agent tests are part of the shared model testing framework, so they live in test sets alongside process and case tests and are executed by Flowable Inspect.

See Testing AI Agents for the configuration reference.

AI Governance, Audit and Human-in-the-Loop​

Every AI invocation is fully auditable: the agent definition used, prompt and output token counts, duration, user attribution, and exchange details are tracked. The agent definition captures which AI vendor and model were configured, providing traceability of which model produced each result. Audit granularity is configurable per agent. Observability integration enables production monitoring of latency, token usage, and error rates. Agent API endpoints can be restricted to specific user groups.

For human-in-the-loop governance: agents can evaluate intent and activation decisions before autonomous execution, enabling human review of AI-proposed actions. Because agents are embedded as activities within BPMN processes and CMMN cases, they inherit the full workflow governance model. Approval gates, escalations, SLAs, and human task assignments can surround any AI step. The CMMN adaptive case model supports patterns where AI and human activities coexist dynamically based on runtime conditions.

See Orchestrating AI Services for the full list of enterprise features.

Cost Management 2026.1.0+​

Agents that call an LLM consume tokens, and tokens usually cost money. Flowable prices the token counts captured during auditing with the per-model rates configured in Flowable Hub or Flowable Control, turning usage into an estimated spend per model, per agent, and over time. The figures are estimates for monitoring and trend analysis, not authoritative billing.

Cost is shown per run on the Agent Timeline and aggregated on a built-in Agent cost dashboard, and the same data can be used in custom dashboard components. Spend can be steered as well as measured: each agent picks its own model through model settings, so a small model can handle simple tasks while a stronger one handles reasoning, and input guardrails can skip an invocation before it reaches the LLM.

See Cost Calculation for the calculation details and the configuration reference.

AI-Powered Dashboard Generation​

Business users can generate analytics dashboards from natural language. A plain-text description produces a complete dashboard configuration with appropriate visualizations (charts, tables, KPI values) and relevant process and case metrics as data sources. Existing dashboards can be updated through follow-up AI prompts.

Architectural Differentiators​

  1. AI as workflow-native: Agents are first-class entities modeled, versioned, deployed, and governed alongside process, case, and decision definitions. They are not a separate system.
  2. Case-managed AI with dynamic tool scoping: CMMN cases act as an agentic harness where plan items serve as tools for the agent. The available tools change dynamically with the case lifecycle, combining the adaptiveness of agentic AI with the governance of structured case management.
  3. Multi-agent with process control: Orchestrator agents compose sub-agents within process and case logic. Tools can range from simple tasks to full subprocesses with their own logic, combining the flexibility of agentic AI with the predictability of structured automation.
  4. Vendor-neutral AI layer: Any Spring AI-supported LLM provider can be used; swap providers without changing definitions; use different models for different agents.
  5. Standards-based interoperability: A2A for agent federation and MCP for tool discovery. No proprietary lock-in.
  6. Full-lifecycle AI: AI assists at both design time (generating and editing models from natural language) and runtime (executing agent tasks in workflows).
  7. Enterprise governance built-in: Token tracking, audit trails, and human-in-the-loop are platform-level capabilities, not add-ons.
  8. Multi-tenant: All AI entities are tenant-scoped for SaaS and shared-service deployments.

Reference Documentation​

Use the links above or the sections on the left-hand side to explore each of the topics in more detail. If you're already familiar with the basics, refer to the agent reference documentation for configuration details and advanced usage.