OutSystems Agentic Systems Engineering and the Enterprise Context Graph – Build an OutSystems Application with Claude Code

Now open to your favorite AI developer tools!

AI development is no longer a laboratory experiment. It has moved onto the factory floor, into the bank branch, and deep inside the operational core of the world’s most complex enterprises. And yet, despite a torrent of new tools and breathless promises of autonomous capability, most organizations find themselves drowning in exactly the opposite of what they were sold, fragmented agents, disconnected architecture, mounting technical debt, and a governance gap that grows wider with every new deployment. The real challenge in enterprise AI today isn’t building something that works in a demo. It’s building something that works in production, at scale, within the constraints of regulated industries and legacy systems that won’t disappear overnight. That challenge demands a fundamentally different approach. It demands Agentic Systems Engineering.

From Experimentation to Execution and the Gap in Between

The numbers tell a clear story. According to OutSystems’ 2026 State of AI Development report, 96% of enterprises are already using AI agents in some capacity, and 97% are exploring system-wide agentic AI strategies. The shift from pilot to production is happening, but it is far from smooth. Nearly 94% of those same organizations raise concerns about agentic sprawl: the unchecked proliferation of disconnected AI tools, shadow agents, and siloed automations that create more chaos than they resolve. Speed without structure isn’t innovation, it’s technical debt at machine velocity.

This is the tension that defines the current moment. The business pressure to deploy AI is immense and legitimate. Boards want efficiency gains. Operations teams want automation. Product owners want intelligent applications. But the CIOs I’ve spoken with across banking, insurance, and manufacturing aren’t primarily worried about whether AI can do something impressive. They’re worried about who is responsible when it does something wrong, how legacy systems will integrate without catastrophic rewrites, and whether the governance frameworks their organizations depend on can keep pace with the speed of AI-generated code. The future of enterprise software will be determined by how well platforms help organizations navigate that tension, not by which platform generates the flashiest prototype.

The Problem with Agentic Sprawl

When every team in an enterprise reaches for its own AI coding tool, one group using a commercial agent builder, another vibe coding with a large language model, a third stitching together open-source frameworks, what you end up with is not an agile organization. You end up with an archipelago of disconnected, uncoordinated systems that share no context, enforce no common standards, and offer no coherent governance surface. Each island may function individually. Together, they create compounding integration risk.

Legacy systems make this worse. Enterprises aren’t greenfield environments. They carry decades of accumulated business logic, compliance rules, data models, and integration contracts that can’t simply be regenerated from a natural language prompt. An agent that doesn’t understand the context of an existing enterprise architecture doesn’t accelerate modernization, it undermines it. The proliferation of agentic tools without a unifying platform context is how organizations end up with working code that can’t be trusted, deployed, or governed. Solving this isn’t a governance afterthought. It has to be architectural from the start.

Agentic Systems Engineering: A Different Philosophy

OutSystems’ answer to this challenge is Agentic Systems Engineering, a deliberate reframing of how enterprises should think about AI development. Rather than treating AI agents as standalone tools layered on top of existing systems, Agentic Systems Engineering embeds agents inside a governed, context-rich architectural framework from the beginning. The key insight is that agents don’t fail because they’re insufficiently capable. They fail because they lack the enterprise context, the business rules, data relationships, integration contracts, security guardrails, that makes capability trustworthy. Context is not a nice-to-have. It is the prerequisite for production-grade AI.

At the center of this approach is the Enterprise Context Graph, a unified representation of the business knowledge, system relationships, and governance rules that agents need to operate reliably. Rather than each agent learning about the enterprise from scratch, or worse, operating without that knowledge at all, the Enterprise Context Graph gives every agent, regardless of which tool built it, a shared understanding of the environment it’s operating in. Combined with the next generation of Mentor, OutSystems’ AI co-pilot, this means developers can move fast without sacrificing the architectural coherence that enterprise operations demand. Mentor no longer just generates a starting point and leaves teams to figure out the rest. It guides development through the full lifecycle, from natural language intent all the way to one-click deployment, maintaining quality, compliance, and structural integrity at every step.

Open by Design: Your Tools, Your AI, One Governed Platform

One of the most significant, and underappreciated, dimensions of Agentic Systems Engineering is that it is explicitly open. Enterprise context and governance in OutSystems isn’t a walled garden that only works if every developer uses OutSystems’ own tools. It’s a shared infrastructure that any agentic tool can operate within. Whether teams are building through the OutSystems Studio IDE, using Mentor directly, or working with external agentic coding tools like OpenAI Codex or Cursor, they all operate within the same shared enterprise context and guardrails that ensure compliant, production-ready output. This is the architecture that resolves the tension between developer autonomy and enterprise governance, not by restricting choice, but by making every choice safer.

This openness matters enormously in practice. CIOs don’t want to bet their entire development organization on a single tool. Developers don’t want to abandon the workflows and tools they’ve already invested in mastering. Agentic Systems Engineering acknowledges both of those realities and turns them into a strength. The platform becomes the trusted layer that unifies diverse tooling under a coherent governance model, which means enterprises get the flexibility of an open ecosystem and the operational confidence of a unified architecture, simultaneously.

Building With Claude Code and the OutSystems MCP

The openness of Agentic Systems Engineering has a concrete and exciting implication for developers who work with Claude Code: you can now use it to build OutSystems applications directly, via the OutSystems Model Context Protocol (MCP) server. For developers already fluent in conversational, prompt-driven development with Claude Code, the OutSystems MCP unlocks the ability to describe an application or workflow in natural language and have it generated and deployed directly into an OutSystems Developer Cloud environment, with real-time progress streaming and automatic deployment included.

The setup is straightforward. The OutSystems MCP server connects Claude Code to your ODC environment using your organization hostname, credentials, and development environment ID. Once configured, you can prompt your way through application creation the same way you’d interact with any other MCP-enabled tool, describing entities, screens, logic flows, and integrations in plain language and watching OutSystems translate that intent into a production-ready, governed application. This isn’t vibe coding as an experiment. It’s vibe coding with the structural confidence of an enterprise platform behind it. Every application generated through Claude Code and the OutSystems MCP inherits the same context guardrails, security controls, and architectural standards that govern everything else built on the platform. The agent works fast. The platform keeps it honest.

The Competitive Imperative

Enterprises that continue to treat agentic AI as a collection of point solutions, each team deploying its own tools, building its own context, governing its own agents, will find themselves not ahead of the curve but buried under it. The organizations that pull ahead will be those that recognize the strategic value of a governed, open platform for agentic development: one that accelerates delivery without compounding risk, that welcomes external tools without sacrificing architectural coherence, and that brings AI into the core of mission-critical systems rather than layering it nervously on the edges.

OutSystems’ Agentic Systems Engineering is the most serious and architecturally coherent answer I’ve seen to the real enterprise AI challenge. Not the challenge of generating impressive code quickly, the market has dozens of tools for that. The challenge of building governed, trustworthy, maintainable systems at enterprise scale, using the tools your teams already know, inside the constraints that regulated industries actually operate under. That’s what the future of enterprise AI looks like. And the organizations that build on that foundation, with shared context, open tooling, and genuine governance, are the ones who will still be winning five years from now.