In
the previous articles of this series, we explored why prompt-only development has structural limitations, and why the GeneXus Knowledge Base is the ideal source of truth for Artificial
In
telligence agents. But how does an AI agent concretely interact with the KB? What mechanism makes that conversation between the world of LLMs and the world of GeneXus possible?
The answer is GeneXus MCP Server.
To understand why it matters, we first need to understand what GeneXus for Agents is and what role the MCP Server plays within this GeneXus product.
I invite you to keep reading to review or learn these concepts.
What is GeneXus for Agents?
GeneXus for Agents is the layer that allows AI agents to work directly on the GeneXus Knowledge Base – the place where all system knowledge is stored – with access to the complete system context and with the GeneXus engine validation as a consistency guarantee.
In
stead of generating code from isolated prompts, agents propose changes to the KB, the engine validates them, and GeneXus generates the code deterministically.
All of this is made possible by the GeneXus MCP Server.
What is Model Context Protocol (MCP)?
Before diving deeper into GeneXus MCP Server, we first need to understand what the Model Context Protocol, or MCP, is.
MCP is an open standard designed to solve a specific problem: how to connect AI agents with external data sources and tools in a standardized way.
Before MCP, every tool that wanted to integrate with language models had to develop its own integration, with its own API, its own data format, and its own authentication logic. For agent developers, this meant having to learn and maintain a different integration for every tool they wanted to use.
MCP defines a common protocol: a standard way for any tool to expose its capabilities and data to any compatible AI agent. The result is an ecosystem where integrations are built once and work with any agent that respects the standard.
For AI agents, MCP is a standard that allows connecting any tool with any agent without the need for custom integrations.
What is GeneXus MCP Server?
GeneXus MCP Server is the implementation of this protocol for the GeneXus Knowledge Base. It is the component that exposes the KB to the world of AI agents through a standard, controlled, and secure interface.
GeneXus MCP Server allows any MCP-compatible AI agent to:
- Read objects from the Knowledge Base: transactions, procedures, data objects, screens, and rules.
- Query relationships between objects: what attributes a transaction has, which other transactions it relates to, what rules apply.
- Propose changes to existing objects or the creation of new objects.
- Trigger compilation and validation on the proposed changes.
- Receive feedback from the GeneXus engine on detected errors or inconsistencies.
All of this happens through the standard MCP interface, which means the agent does not need to know anything specific about the internals of GeneXus to interact with the KB. The GeneXus MCP Server translates between the language of the agent and the language of the KB.
The Flow of a Typical
In
teraction
To make this more concrete, let’s look at what a typical interaction between an AI agent and the KB would look like through GeneXus MCP Server.
Suppose a developer asks the agent: “Add a supplier management module that includes invoice approval with authorization levels based on amount.”
In
this case, the flow would be as follows:
- The agent receives the instruction and, before proposing any changes, queries the GeneXus MCP Server to understand the current state of the KB: what transactions exist related to suppliers or invoices, what attributes are already defined, what approval patterns exist in other modules.
- With that context, the agent reasons about how to implement the requirement in a way that is consistent with the existing system. It uses GeneXus Skills to understand naming conventions, recommended design patterns, and the typical structure of similar modules.
- The agent proposes the changes: new transactions, attributes, business rules, and approval logic. That proposal is sent to the GeneXus MCP Server in structured text format.
- The GeneXus MCP Server receives the proposal and passes it to the GeneXus engine for validation. The engine verifies that the proposed objects are correct, that the relationships are valid, and that there are no conflicts with existing objects.
- If the validation is successful, the changes are integrated into the KB.
- If there are errors, the GeneXus MCP Server returns feedback to the agent with details about what is wrong, and the agent can attempt to correct the proposal.
- Once the changes are integrated into the KB, GeneXus generates the code for the target technology deterministically.
Why Standardization Matters: No LLM Lock-in
One of the most important benefits of GeneXus MCP Server is that, by implementing a standard protocol, it makes GeneXus for Agents independent of the language model used by the agent.
The integration with the KB works the same in all cases because the GeneXus MCP Server exposes a standard interface that none of those models need to understand in detail.
This has important implications for teams, allowing them to:
- Choose the most suitable AI model for each task without being tied to a single vendor.
- Update or switch models as technology evolves, without modifying the integration with GeneXus.
- Keep control of the system in the KB and the GeneXus engine, not in the AI vendor.
- Combine different models in the same workflow if it makes sense for your use case.
From the IDE or from the CLI
The GeneXus MCP Server is designed to work in the two contexts where modern development teams operate.
From the GeneXus IDE, developers can interact with AI agents visually, integrated into the environment they already know. The agent has access to the KB through the MCP Server, proposes changes, and the developer can review them before they are integrated.
From the CLI (Command Line
In
terface), teams can incorporate AI agents into CI/CD pipelines, automation scripts, or workflows that already use command-line tools. This is key for teams that work with branching, pull requests, and code reviews, because it allows the agent to be part of the development workflow without requiring manual intervention at every step.
Both working modes are compatible with Git and with modern team collaboration workflows. Changes proposed by the agent can go through code review like any other change, keeping human control over what enters the system.
GeneXus MCP Server in the Broader Ecosystem
GeneXus MCP Server does not operate in isolation. It is part of a set of components that together make GeneXus for Agents possible:
- GeneXus Skills provide the agent with specialized context on how to work with GeneXus: conventions, patterns, and best practices.
- The textual representation of the KB allows any LLM to read and reason about KB objects.
- The GeneXus engine acts as the final validator: nothing reaches the KB without passing through its validation.
The GeneXus MCP Server is the glue that holds these pieces together. It is the layer that makes it possible for an external agent, using any LLM, to participate in the development cycle of a GeneXus system with the same reliability and control as if a developer were doing it from the IDE.
You may also be interested in reading:
The Problem with Prompt-Based Development
GeneXus for Agents: Development with GenAI without losing control
GeneXus in the Era of Agentic Development