Agentic development

Agentic development in the NET Genium platform

Agentic development is a way of building and maintaining NET Genium applications in which an AI agent works alongside the developer – a tool that does not only give advice, but can read and modify the application model, source files and program code. Unlike a chat assistant, the agent has the real tools of the development environment at hand and makes the actual changes under the supervision of the developer.

In practice these are tools such as Claude Code or Codex connected to NET Genium through the MCP server. The agent therefore knows the architecture of the framework, the conventions of the platform and the specific customer implementation, and can work in it purposefully.

How agentic development differs from working with AI models

The two areas are closely related, but they solve a different task:

• AI models give an external assistant the knowledge of the structure of a specific implementation, so that it can explain it and help with orientation. The assistant itself, however, does not work with the application.
• Agentic development goes one step further – based on that knowledge the agent really creates and modifies the application: it creates forms and view pages, writes scripts and program code, and writes the changes directly into the instance.

AI models therefore form the knowledge base, while agentic development uses that knowledge to make the actual changes.

What the agent knows about your instance

The agent is connected to the platform by the MCP server (Model Context Protocol) built into every instance of NET Genium. Through it the agent has continuously, and always in the current form, the following at hand:

The agent therefore does not work according to general habits, but according to the valid standards of NET Genium and to the real shape of the given implementation. When the framework evolves or the application changes, the agent gets the current material automatically – nothing has to be transferred by hand.

The individual tools of the server, the personal token and the security rules are described in the text Built-in MCP server, the setup procedure in the text Connecting an AI tool to the MCP server.

How agentic development runs

Working with an agent has a settled rhythm. The developer says what should happen, the agent solves how, and the decision stays with the human:

1. The assignment in your own words. The developer describes the request in plain language – “add a completion date to the complaints and show it in the overview”.
2. The agent gets the context. It reads the model of the application concerned and the database model, so that it works with the real names of tables, columns and controls instead of a guess.
3. It proposes a solution. It shows what exactly it is going to create or change, and explains why. The developer accepts the proposal, adjusts it or rejects it.
4. It writes the change. Changes of the model go into the instance through the MCP server, changes of the program code into the source files of the working copy.
5. The result is verified. The developer looks at the change directly in the portal and the agent continues according to the comments.

The whole cycle runs without downloading and uploading the model by hand – the agent has the instance at its disposal the whole time.

What the agent can do

• propose and create new application groups, applications, categories, edit forms and view pages,
• add and modify controls, database queries and server scripts,
• rename building blocks without touching their identifiers, which are referenced from scripts and code,
• create user groups and rights groups,
• write custom functions in C# – external functions, web APIs and accompanying services,
• work through the analysis of an assignment and propose the corresponding data structure and processes,
• read and analyse application data, and in development and test environments change it as well,
• find performance bottlenecks – from the usage statistics, record counts and index analysis.

While doing so the agent respects the existing structure of the project and the style of the existing code – it does not introduce conventions of its own, but mirrors what is already established in the given implementation.

What you need for it

1. An instance of NET Genium with the built-in MCP server – it is part of the installation, nothing is installed on top.
2. An AI tool supporting the MCP protocol, typically Claude Code or Codex.
3. A personal MCP token with the read permission, and if the agent is to write as well, with the write permission too. Every user generates the token themselves in the Change password dialog on the MCP token tab.

The setup step by step – the server address, the token, the environment variable and the configuration of the tool – is described in the text Connecting an AI tool to the MCP server.

A controlled and safe procedure

Agentic development does not replace the developer, but it speeds up their work considerably. The frame in which the agent moves is firmly given:

• The token defines the scope. Without the write permission the agent changes neither the data nor the model; the permission can be taken away at any time and the token deleted, which ends the access immediately.
• Every request signs in as the owner of the token – it is therefore subject to the allowed IP addresses and to the licences, just like a regular sign-in.
• The changes are visible. Changes of the model show in the portal immediately, changes of data can be written including the record in the change history.
• The code goes through a review by the developer before deployment and is versioned in the source control, so it can be traced and reverted at any time.

The long-term maintainability, security and continuity of the solution, on which the NET Genium platform is built, are thus preserved.

Typical use

• speeding up the development of new applications and the extension of existing ones,
• routine and repetitive tasks – creating forms, controls and scripts,
• writing and modifying program code beyond the possibilities of the graphical designer,
• maintaining large implementations while keeping uniform conventions,
• reviewing performance and tracking down errors over the real data of the instance,
• onboarding of new developers, whom the agent helps to find their way around the implementation and the framework.