GeneXus
for Agents: from intention to software, with knowledge at the center
In 2023, while participating in a Gartner Magic Quadrant process, we put together a story to explain how we saw the evolution of software development. Shortly after, Gastón Milano (CTO of Glob.AI and GeneXus) picked it up again at the GeneXus GX30 Meeting:
The idea was simple: ever since we started doing things with computers, there has always been a gap between a person’s intention and the system capable of materializing it. For a long time that gap was enormous, because creating software required translating a need, designing, programming, compiling, testing, fixing, and deploying. Only then could someone use what had been imagined and built.
The history of the industry can be read as a succession of attempts to close that gap. CASE (Computer Aided Software Engineering), RAD (Rapid Application Development), model-driven development, knowledge-driven development, and Low-Code platforms all sought to describe more of the problem and write less of the implementation.
GeneXus was born within that search and for decades focused on ways to capture knowledge about the system and generate solutions from it. No-Code expanded who could create solutions, and then, with LLMs, a new simplification and convergence appeared: natural language could bring us closer to the original intention.
In 2023 we were already talking about a convergence between creating and using software, and today, a task can begin in a conversation, continue in a terminal, modify a repository, run tests, and end up integrated into a product. And as that gap narrows, a question that GeneXus asked from the very beginning becomes ever more central: where does the knowledge about the system live?
When creating and using begin to converge
In this new agentic era of natural language, an IDE no longer necessarily occupies the center of development, nor does it constitute its only medium or mandatory entry point. Development now happens in a more distributed system – with chats, CLIs, repositories, documentation, automated processes, and agents.
It’s true that for decades we organized development around the separation between design time and runtime: there was one place to create and another to use. But today, with coding agents or chat interfaces with LLMs, that boundary has become tremendously blurred. We can interact with a product while it generates a query or a software modification to resolve a new intention. We are truly using and creating at the same time.
That shift makes it more important to preserve what we know. The interfaces, agents, AI models, and implementation technologies will change, but the knowledge that explains why a system exists and how it should behave needs to survive those changes.
The industry is looking for a new source of truth
Much of the evolution of agentic development and the conversations developers are having today responds to that need. Coding agents, persistent context files, wikis, spec-driven development, knowledge graphs, skills, MCP, memory, and rules systems are all topics that converge because they share a common problem: an agent needs known context in order to act well.
An enterprise system concentrates business rules, data structures, integrations, architecture decisions, and exceptions. Part of that knowledge lives in the code; another part is scattered across documentation, tickets, conversations, and people – or some of it has surely already been lost. That is why so many tools have appeared that attempt to build new layers of context around the code. Some automatically generate documentation from the repository. Others maintain files where product and architecture decisions are recorded. Others require writing specifications before implementing. Others build graphs to represent the relationships between different parts of the system.
The signal is clear: agents need more than code. Here GeneXus offers an important historical difference: while much of the industry tries to reconstruct knowledge from existing software, or looks for ways to preserve it when coding with AI, GeneXus always sought to make the reverse journey – generating software from knowledge, or from a knowledge base.
GeneXus and the separation of What and How
GeneXus’s proposition has always been to describe the business reality, capture that knowledge in a Knowledge Base, and derive the necessary implementations from it. The code appears as a consequence of objects, attributes, relationships, rules, structures, and dependencies that represent what we know about the system.
This made it possible to separate two things that in traditional development were tightly coupled: the What and the How. The What expresses what the business needs; the How determines how to implement it on a given technology. If a database, language, architecture, platform, or device changes, the knowledge should remain valid. What changes is one of its possible implementations.
That principle today extends to AI models, agents, and development surfaces. Today it might be Claude, Codex, Glob.AI Desktop, Globant Coda, a CLI, a corporate agent, or a web experience. The knowledge of a system should outlast all of them, because technology will change much faster than business knowledge.
The industry is using generative AI and seeking to preserve knowledge and obtain repeatable results. GeneXus arrives at that point from a tradition rooted in knowledge and generation. The interaction technology has changed. If IDEs cease to be the central work surface, we need another way to connect GeneXus’s more permanent idea – that everything starts from knowledge – with the current way of working, which increasingly happens through agents. It is in that intersection between the permanent and the new that GeneXus for Agents comes in.
GeneXus for Agents and the power of knowledge
GeneXus for Agents opens the Knowledge Base to a new class of operators: agents. An agent can receive an intention in natural language, learn GeneXus concepts and practices through skills, inspect a textual representation of the Knowledge Base, query its objects, propose modifications, and execute operations via CLI and MCP.
The knowledge remains GeneXus, while the work surface expands. The Knowledge Base can participate in an environment where humans, agents, repositories, and automated processes query, modify, version, review, and validate changes.
An LLM can interpret an intention, explore alternatives, navigate natural language, and help us understand something that has not yet been formalized. GeneXus can take what we already know, convert it into operational knowledge, and derive software in a consistent, repeatable, and reliable way.
Generative AI can also do something even more interesting than simply generating code. It can help us navigate ambiguity and progressively convert what we learn into reusable knowledge: a rule, a relationship, an abstraction, a pattern, or a new part of the model.
Generative AI thus expands the traditional GeneXus idea of Knowledge-Based Development.
From modeling knowledge to modeling intention
The next step we are taking carries the separation between What and How one level higher, because even before the What there is an intention – what I want to do… and why, as Simon Sinek would say. A person starts with a problem: they want a customer to complete a task, change a business rule, reduce a risk, modify a process, or answer a question.
Natural language allows you to start close to that point. Its value grows when the conversation can be converted into structured knowledge. Exchanges are ephemeral: months later it can be difficult to reconstruct why the system ended up working a certain way. Enterprise software needs a memory capable of preserving facts, relationships, rules, constraints, and decisions in a verifiable model.
The conversation then becomes the interface for modifying that knowledge. In classic GeneXus we described a system through an IDE and generated different implementations. Going forward, humans and agents can converse about the business while the platform transforms that conversation into a formal model of intention and knowledge: versionable, capable of explaining changes, analyzing dependencies and impact, and of outlasting the agent, the AI model, and the technologies that helped build it.
The next chapter
The direction we imagined in 2023 remains valid. We went from programming every detail to modeling, from Low-Code to No-Code, and from natural language to agents. Each leap brought creation and use ever closer together.
At this stage, knowledge becomes even more important. When producing code becomes cheaper, what matters is knowing what should exist, why, what rules it must respect, and what can change or remain. GeneXus for Agents extends that idea to a new generation of tools and operators. It opens the Knowledge Base to agents and turns natural language into a new entry point into system knowledge, without requiring an IDE to be the starting point.
The story keeps moving forward. The future of GeneXus should come ever closer to intention: better capturing what people want to achieve, converting it into formal knowledge, and using that knowledge to continuously create and adapt software. And doing so reliably, because in the era of stochastic code generators, we need to build trust – that is, find ways to be able to trust the generated code (the same trust we had with GeneXus-generated code, which was generated deterministically).
That is where we will be working, both at GeneXus and at Glob.AI OS: in allowing our customers to build mission-critical, reliable, knowledge-based software systems, leveraging artificial intelligence to generate code. In other words, the GeneXus team keeps innovating so that our customers can continue doing what they have been doing for nearly 40 years: building systems from knowledge, evolving them easily, and taking advantage, at every moment, of the most advanced technologies.
To dive deeper into the latest in our technology, you can explore:
You may also be interested in reading:
The New GeneXus: Modeling Intent, Not Just Writing It
GeneXus and Neuro-Symbolic Architecture
The Problem with Prompt-Based Development
GeneXus for Agents: 15 key questions answered