Introducing CUGA: The enterprise-ready configurable generalist agent

Imagine you’ve built an AI agent that performs beautifully in sandbox demos. But once it hits production, things unravel — it misuses tools, skips critical steps, and fails silently when faced with real-world complexity. Debugging becomes a nightmare, and scaling across domains feels like reinventing the wheel every time.

This is the reality of many agentic systems today. They’re either too brittle to handle enterprise-grade workflows or too generic to meet policy, safety, and integration requirements. That’s why we built CUGA — the ConfigUrable Generalist Agent — a powerful, adaptable agent framework designed to meet the complex demands of enterprise automation.  And importantly, CUGA is open source.  

What makes CUGA different?

CUGA is a configurable, general-purpose AI agent designed to abstract away many of the complexities from developers. It’s capable of handling sophisticated tasks and it integrates seamlessly with a wide range of tools. It works with MCP, and can interact with REST APIs, web applications via the browser, and soon, with file systems, data stores, and command-line interfaces.

CUGA encapsulates the best practices and institutional knowledge we've accumulated at IBM, effectively shielding developers from much of the underlying complexity. Instead of manually coding prompts and making architectural decisions, developers simply configure the MCP tools and provide domain knowledge, standard operating procedures, guardrails, and other parameters.

As a result, developers using CUGA will likely see significant improvement in development time and cost, along with built-in enterprise guarantees such as safety, trustworthiness, and optimization for cost and latency.

Here’s what sets it apart today:

• Complex task execution: State-of-the-art results across web and APIs.
• Multi-tool mastery: CUGA works across REST APIs via OpenAPI specs, MCP servers, and custom connectors.
• Composable agent architecture: CUGA itself can be exposed as a tool to other agents, enabling nested reasoning and multi-agent collaboration.
• Configurable reasoning modes: Choose between fast heuristics or deep planning depending on your task’s complexity and latency needs.

CUGA’s architecture is a modular, multi-layer, multi-agent system designed to handle complex, long-horizon tasks across web and API environments. At its core is a Plan Controller Agent that decomposes user intents into structured sub-tasks, tracks their execution states, and orchestrates workflows. These sub-tasks are delegated to specialized Plan-Execute Agents — browser agents for UI interactions, API agents for structured application calls, and custom agents — each equipped with short-term memory, reflection mechanisms, and variable management.

The system coordinates the state of the agent orchestration, while a context enrichment layer ensures planners receive actionable, policy-aligned instructions. This layered design enables CUGA to maintain consistency, recover from failures, and scale across diverse enterprise applications.

Proven performance

CUGA is currently the leader on AppWorld — a benchmark with 750 real-world tasks across 457 APIs — outperforming other agentic platforms powered by the best frontier LLMs. CUGA also currently sits at #2 on WebArena, a complex benchmark for autonomous web agents across application domains.

CUGA also integrates seamlessly with Langflow, the low-code visual builder for agentic workflows. You can drag-and-drop CUGA into Langflow flows, allowing you to build multi-agent systems with CUGA as the reasoning or execution core. You can also configure, test, and deploy agents visually and combine CUGA with LLMs, vector databases, and observability tools.

What’s next

We’re working to improve CUGA with new features in the works, including:

• Save and reuse successful trajectories: CUGA captures and reuses successful execution paths, enabling consistent and faster behavior across repeated tasks.
• Enterprise guarantees out of the box: CUGA components can be configured with policy-aware instructions to improve alignment of the agent behavior

To make agents like CUGA even more robust in production, we’re also working to build an agent lifecycle toolkit (ALTK). It will be a modular set of components that enhances agent performance across the full lifecycle.

The ALTK will improve reasoning quality, reduce tool invocation errors with smart fallback strategies, and enforce output guardrails for safe, policy-compliant responses. Designed for developers, the goal is for it to integrate seamlessly into existing agent pipelines with minimal overhead — making it easier to build agents that are not only intelligent but also reliable, auditable, and enterprise-ready. Stay tuned for more details on ALTK soon.