OutSystems Agent Workbench goes GA with MCP and marketplace

Breaking: a low code control center for enterprise agents

Today in Lisbon, on October 1, 2025, OutSystems moved its Agent Workbench into general availability and planted a clear flag for pragmatic enterprise AI. The company framed the release as an answer to a familiar problem: most organizations have proofs of concept for agents, but few have a safe way to scale them across systems and business units. The news landed on stage at ONE, the company’s annual conference, alongside an official GA press release that emphasized two headliners. First, a curated agent marketplace to speed adoption. Second, native support for the Model Context Protocol so agents can speak a common language to tools and data.

If you are a chief information officer staring down a Q4 roadmap, this is not a science project. It is a control center for shipping governed, cross system agents without building an internal platform first.

What changed today

OutSystems is not introducing a brand new idea as much as consolidating the stack that enterprise teams need to run it safely. Agent Workbench now brings together design, orchestration, observability, and policy controls in one place. It is delivered inside the familiar low code environment that many OutSystems customers already use for line of business apps.

Two additions matter for enterprise scale:

Agent marketplace. Prebuilt agents and connectors reduce the time to a first production deployment. Think of it as an app store for repeatable enterprise tasks, from ticket triage to invoice matching. The promise is speed and standardization, not novelty.
Model Context Protocol support. MCP creates a common way for agents to connect to tools and data sources. With MCP, security and integration patterns can be reused instead of reinvented for every agent. That lowers risk and shortens the checklist for compliance and architecture reviews.

Why the timing is pragmatic

The typical agent experiment stalls at the handoff from a demo to an audit. Leaders need to answer basic questions. Who approved what the agent can do. Where are its logs. How does it authenticate to systems we already own. How do we roll it back. Without consistent answers, most teams keep their agents in a sandbox.

Agent Workbench answers with a platform that speaks the language of enterprise software delivery. Policies are first class objects. Integration is not a cliff but a library. Observability is not an afterthought; it is the main view. This changes the conversation from experiments to deployments.

For context across the market, we have seen similar moves that push agents toward production. AWS added an operations layer for production agents with AWS AgentCore adds an ops layer. And on the go to market side, HubSpot illustrated how marketplaces can turn agents into teammates in HubSpot's Breeze marketplace lessons. Agent Workbench arrives with both an ops posture and a marketplace, which is why today matters.

What Agent Workbench actually is

Think of Agent Workbench as mission control for a fleet of small digital workers. Each agent has a job description, a set of tools, and guardrails. The workbench coordinates these agents, handles their permissions, and provides dashboards so engineers and business owners can see what is happening in real time.

Concretely, teams can:

Define agents that plan, call tools, and act based on policies you set.
Connect agents to systems using reusable connectors and MCP servers.
Orchestrate multi step flows across departments without stitching together custom glue code.
Monitor outcomes, cost, and drift, then iterate like you would with any other production service.

On the model front, the GA supports a broad roster. That includes services from Azure OpenAI and Anthropic, as well as newer options like Gemini, Cohere, Mistral, Databricks, AI2, and IBM’s WatsonX. It also accommodates custom models on Vertex AI and open source models hosted on Hugging Face. This matters because many enterprises run mixed model portfolios for cost, performance, and data residency reasons. The workbench meets that reality instead of forcing a single supplier.

The early deployments that matter

Early adopters offer a pattern worth noting. Thermo Fisher Scientific built a customer escalation agent that reads unstructured signals from tickets and communications, classifies urgency, and routes work to the right teams. The Arch Company replaced spreadsheet driven processes with an agent that classifies and routes inquiries automatically. Grihum Housing Finance is using agents to improve loan underwriting and property evaluation consistency. Axos Bank reports gains on internal automation through a log analysis agent and automated document mapping. KPMG’s low code center of excellence highlights the governance angle: progress with policy, auditability, and lifecycle control, not just clever prompts.

These are not moonshots. They are targeted workflows that create measurable impact inside real systems. The common thread is scope discipline and a closed loop from action to outcome.

A closer look at MCP in the enterprise

Model Context Protocol matters because integration is where most agent initiatives run aground. MCP defines how agents discover and use tools and data. It standardizes capabilities like listing resources, reading files, executing functions, and streaming results. That turns a bespoke exercise into a plug and play pattern. For security teams, MCP also creates a well understood boundary where identity, secrets, and permissions can be managed consistently. If you need a primary reference for your architects, point them to the Model Context Protocol on GitHub.

In practice, here is how it changes the shape of work:

Faster tool onboarding. Instead of writing one off adapters, teams add or swap MCP servers that provide the same interface to new systems.
Clearer blast radius. MCP scoping describes what an agent is allowed to do. That makes it easier to reason about risk and to design targeted tests.
Better reuse. Once a finance reconciliation agent knows how to talk to your ledger through MCP, a cash application agent can reuse the same path with minimal new code.

Under the hood: how the workbench fits

Agent Workbench slots into existing delivery practices rather than replacing them:

Identity and access. Agents authenticate using the same enterprise identity you use elsewhere. Policies can limit which tools each agent can call and which data resources it can reach.
Versioning and rollout. Agents are versioned like services. You can promote from test to production, run A and B variants, and roll back if a policy or prompt change causes drift.
Observability. The platform captures traces of agent decisions, tool calls, and outcomes. That enables post incident analysis and gives compliance a transparent log of what happened and why.
Orchestration. Multi agent flows can be serialized or parallelized. For example, a claims intake agent can normalize a document, a policy agent can check coverage, and a pricing agent can compute a reserve in a single run with intermediate checkpoints.

The marketplace effect

A marketplace is only useful if it saves teams real time and reduces risk. For a first wave catalog, the goal should be breadth across common enterprise jobs. Expect practical modules first: triage, summarization, classification, reconciliations, data extraction, and workflow automation in systems like customer relationship management, information technology service management, enterprise resource planning, and document management.

Two ways to judge marketplace quality in the next quarter:

Reference designs. Look for examples that include policies, test data, and monitoring templates. If an agent template ships with a tested access policy and alert thresholds, it will shorten your security review.
Update velocity. New connectors and MCP servers should land regularly. A marketplace that goes quiet is a sign to temper your roadmap exposure.

This is where OutSystems’ approach rhymes with the broader wave of agent native launches. Salesforce’s move with Agentforce 3 tipping point shows that marketplaces and governance travel together. OutSystems adds the low code DNA and the tight loop to delivery teams.

How to ship governed agents in Q4 without building a platform

If you want results this quarter, treat Agent Workbench like any other platform capability. Set a narrow goal, agree on the safety model, and deliver in weeks, not months.

Here is a practical plan:

Pick one high leverage workflow. Choose a process with measurable value and bounded scope. Examples: high volume ticket triage, invoice validation, call center after call notes, or log analysis for incident response.
Define the service level. What turnaround time, accuracy threshold, and exception rate are acceptable. Put a number on each. This drives model choice and prompts the right observability.
Map systems and access. List the data sources and tools the agent will use. Decide which will be reached via MCP and which through native connectors. Document identities, secrets, and least privilege scopes.
Start with a marketplace template if one fits. Use it as a scaffold. Replace sample policies and prompts with your own. Do not start from a blank canvas if a vetted example exists.
Encode guardrails as policies, not tribal knowledge. Express rate limits, data retention, escalation rules, and approval steps in the workbench. Make them enforceable by the platform.
Instrument from day one. Capture traces, tool call counts, model tokens, and business outcomes. Create dashboards that a product owner can read without a data science degree.
Test like a service. Run red team prompts. Inject bad inputs. Validate access controls using negative tests. Confirm rollbacks. Treat the agent like a microservice with nasty neighbors.
Pilot with a human in the loop. For the first releases, require approval on high risk actions. Measure how often humans overrule the agent and why. Use those signals to refine prompts and policies.
Plan for model plurality. Keep at least one alternate model qualified behind the same interface. Costs and performance change. Do not marry a single model for a critical workflow.
Write the runbook. Include playbooks for drift, degraded responses, tool failures, and identity issues. Who gets paged. What gets disabled first. How to fall back to a safe baseline.

Follow these steps and you can ship a production agent in a sprint or two, then rinse and repeat for the next workflow.

Risk, reality, and what to watch

No platform removes the need for ownership. Agent Workbench gives you controls, not guarantees. Three pitfalls to avoid:

Overbroad scopes. If an agent can reach every system, it will eventually try. Keep tool scopes as small as possible and add privileges only when you see a proven need.
Silent failures. Treat low confidence or tool errors as first class outcomes. Route them to a queue with human review. Reward teams for catching mistakes, not hiding them.
Shadow configuration. Prompts and policies that live in slide decks will bite you. Put them under version control. Require approvals on changes that affect access or behavior.

On the positive side, the GA footprint is already wide. In addition to the model choices noted earlier, the workbench’s alignment with MCP means you can build once and reuse. That is a multiplier on both security reviews and developer productivity.

How this compares to coding assistants and do it yourself stacks

Coding assistants speed developers. Orchestrated agents change business operations. The difference shows up in who feels the impact. A single developer can ship a feature faster with a coding assistant. A front line team can resolve incidents faster when an agent triages logs, opens tickets, and proposes fixes inside your rules.

Building your own agent platform can work if you have the people, time, and appetite for integration debt. You will need to define policies, create connectors, log everything, build a control plane, and keep it all in sync with changing models and security expectations. If you are late in the year and want to show value without overcommitting, a governed workbench that plugs into systems you already use is the faster path. For a sense of how operations centric agent stacks mature, compare OutSystems’ approach to AWS AgentCore adds an ops layer. The trend is clear: agents are graduating from prototypes to services with SLAs.

What success looks like by December

Set targets that your finance partners will support. Three measurable outcomes fit most first deployments:

Cycle time reduction. Measure first response and resolution time in tickets or cases. Aim for a 20 to 40 percent reduction on scoped processes.
Manual touch reduction. Track the share of items handled without human intervention. Start small, for example 15 percent of a queue, and expand as confidence grows.
Cost to serve. Calculate cost per transaction by including platform usage, model calls, and human review. Use this to decide when to swap models or tune prompts.

By December, a credible program will have a few agents in production, a backlog of candidates, and a shared playbook that business and security both trust. That foundation matters more than a flashy demo.

The bottom line

The general availability of Agent Workbench is not a promise of easy wins. It is a practical move that brings governance, integration, and observability into one place, then pairs it with an agent marketplace and a standard like MCP. Early deployments at Thermo Fisher, Axos Bank, The Arch Company, and Grihum show the pattern: pick a real workflow, set guardrails, integrate through known paths, and measure outcomes. Do that, and you can turn Q4 into a season of shipping, not another scramble to explain a pilot.

Finally, remember the broader context. Agent marketplaces are maturing, ops layers are standardizing, and best practices are converging. If you have been waiting for a way to operationalize agents at scale without reinventing your stack, Agent Workbench is a timely on ramp.