Your Agent Reads the Repo—Not the App
Your Coding Agent Knows Your Code, But Not Your Actual App. An agent reads repository files, but that is not the app. A repository reveals source files, not necessarily the live schema, role assignments, deployment stage, or service dependencies. Nor does it show the latest runtime failures.
This context gap presents a practical risk. An agent can produce syntactically sound changes while misunderstanding connections within the running application. It misses how an entity, a screen, or a server action is connected. Claude Code, Codex, and Copilot analyze static codebases; they remain blind to runtime metadata.
More code or a longer prompt cannot reliably supply information an agent cannot access. The limitation is a context gap, not a weak-model problem. All of that lives in the platforms your app runs on, not in the code. Your agent never sees it.
An agent cannot directly inspect:
- Live relational schemas
- Stage-specific configurations
- Cross-service dependencies
- Access control roles
- Runtime telemetry
Without this context, agents hallucinate configurations or generate code that breaks downstream dependencies. This leads to footguns: syntactically correct but functionally flawed code. Your AI Coder Is Blind to Your App.
MCP Gives the Agent a Window Into ODC
Model Context Protocol (MCP) gives your agent a window into OutSystems Developer Cloud (ODC). MCP is a standardized connection. It links host agents like Claude Code, Codex, or Copilot to tools exposed by ODC. This integration allows agents to move beyond static repository analysis.
Agent workflow changes dramatically. Before proposing or requesting changes, the agent looks up real entities, screens, logic, roles, and dependencies. It grounds decisions in platform context, not guesses. This prevents hallucinated configurations and broken deployments.
The division of labor is clear. An external agent orchestrates through MCP. It queries the Enterprise Context Graph to map application components. OutSystems Mentor, the platform's native AI, handles platform-native build, validation, and publishing tasks. This two-tier agent delegation flow ensures platform integrity.
MCP operates with identity delegation. The remote MCP server authenticates as your active ODC user. This enforces strict Role-Based Access Control (RBAC). If you lack permission to modify an entity or deploy to an environment, your agent is similarly restricted. This prevents unauthorized changes.
The integration even extends to observability. If something breaks post-deployment, the same session pulls real-time traces and execution logs. This pinpoints failures without context-switching to external APM platforms. OutSystems MCP is available on the Personal Edition, allowing free testing with your preferred coding agent.
One Session Can Build, Publish, and Debug
One session now traces the full application lifecycle. An agent can inspect an application, map dependencies, then hand build work to Mentor, the coding agent built into OutSystems. Mentor compiles, validates, and publishes changes through the platform.
If something breaks post-deployment, the same agent session pulls logs and traces to diagnose the failure. This closes the observability loop, allowing developers to investigate issues without manually rebuilding context across disparate tools. The agent operates with the developer's permissions, ensuring security and adherence to Role-Based Access Control (RBAC).
This platform-connected assistance streamlines development. It unifies what were previously siloed tasks:
- Application inspection
- Dependency mapping
- Build delegation
- Deployment
- Log retrieval
The Model Context Protocol (MCP) enables this integration. For more details on the protocol and its implementation, consult the OutSystems MCP - ODC Documentation. This unified workflow reduces friction and context-switching, but it does not guarantee every change is correct, nor does it imply agents autonomously resolve all production incidents. It provides a powerful, integrated window into the application's runtime reality.
Enjoying this? Get one like it in your inbox each morning.
one email a day · unsubscribe in two clicks · no third-party tracking
More Context, Same Permissions—and Real Trade-Offs
Agent acts within your established permissions. Identity delegation means the agent inherits your OutSystems Role-Based Access Control (RBAC) settings. If you cannot deploy to production, neither can your agent. This prevents unintended deployments or edits.
Workflow depends on the OutSystems platform and its visual models. For precise UI layout work, refining elements directly in the visual IDE may remain faster. The agent excels at
- discovery
- dependency mapping
- governed changes
- log triage
Consult OutSystems documentation for current availability and setup details. Verify consequential edits before publishing. You now have a window into your app's runtime context, not just its source.
Frequently Asked Questions
What is OutSystems MCP?
It connects compatible AI coding agents to OutSystems Developer Cloud tools and application context through the Model Context Protocol.
What can an AI agent see through OutSystems MCP?
Depending on permissions and available tools, it can inspect app elements and dependencies, assist with builds and publishing, and access runtime logs.
Does OutSystems MCP let an agent bypass user permissions?
No. The integration operates with the developer’s identity and access, so the agent is limited by that user’s permissions.
Can I use OutSystems MCP with Claude Code or Copilot?
The video describes connecting external agents such as Claude Code, Codex, and Copilot to OutSystems MCP.
Is OutSystems MCP available for free?
The video says Personal Edition is free and includes OutSystems MCP; check current OutSystems documentation for availability and setup details.