From request to release,
your enterprise software is built by an agent organization.
In xLAP a screen, a field and a permission are definitions, not code. The same definition runs on desktop, web and mobile, on one shared authorization layer. The operations of that screen become agent tools.
Not off-the-shelf agents. Agents built for your organization.
In off-the-shelf ERPs, AI works on the vendor’s standard processes; anything specific to your organization is pushed outside the core, into a separate project. In xLAP your own screen is the product’s own definition. Every step from request to release is recorded.
Request to release
One metadata layer · one permission model
The request hits the board
The voice agent runs on a real phone line. The conversation lands on the control plane as a request.
The flow above is illustrative; the step names, stamping format and release gate are the real system.
Modules that run on the shop floor, open to agent tools.
Every module lives in the xLAP definition layer: the same screen runs on desktop, web and mobile, and its operations can be exposed as agent tools.
Order Management
End-to-end tracking from order entry to dispatch. Price lists, pre-orders and customer management.
Production Planning
Work orders, routing, capacity planning and machine assignment. Automatic batching.
Production Tracking (MES)
Serial and barcode based process check-in/out. Live production status and efficiency.
Bill of Materials (BOM)
Recipe, material list and operation structures. Raw-material requirement planning.
Quality Control
QC rules, defect codes, inspection points. Reject/accept decisions and quality reports.
IoT Monitoring
Machine sensors, downtime analysis, live dashboards. Continuous factory monitoring.
PDA / Handheld
Stock, production and dispatch operations on handhelds. Mobile barcode flows.
Dashboards & Analytics
KPI panels with DevExpress Dashboard. Pivot, chart and card components.
Warehouse Management
Warehouse management, stock transfer, in-out tracking. Barcode-based inventory.
Gantt & Scheduling
Process-based Gantt charts. Work-order planning and resource-assignment views.
Modules are enabled per industry; screens and fields specific to your organization live in the same definition layer.
The layers are separate, the definition is one.
Four layers, from the user surface down to the database. Screens, fields and permissions are defined once; every layer reads the same definition.
Not weeks. Minutes.
These are the jobs as they run in the field today. Durations reflect typical workload; they are experience, not a benchmark.
Data source, query, component layout and permissions; hand-built design with repeated revisions.
Describe it in plain language; grid, chart, pivot and card components are produced with their permissions.
Pick a job to see both sides of it.
The budget does not go on licences. It goes on what is specific to you.
In an ERP project the money is spent on what is specific to you, not on what is standard: that screen, that report, that approval flow, that permission matrix. In off-the-shelf ERPs, exactly that part is pushed outside the product.
Not three systems. One definition.
In xLAP, ERP, MES and IoT are not separate products. All three are defined in the same metadata layer and run on the same permission model, and a screen’s operations are exposed as agent tools from that very definition.
The real interface, the real flow.
A simulation of the xLAP orchestration panel. Pick a scenario and start the flow: see how the request is split across agents and which objects get produced, step by step.
- 1OrchestratorPress Start; the hand-offs between agents show up here.
- 2SQL DDL SpecialistPress Start; the hand-offs between agents show up here.
- 3Object ManagerPress Start; the hand-offs between agents show up here.
- 4Screen SpecialistPress Start; the hand-offs between agents show up here.
- 5Dashboard DesignerPress Start; the hand-offs between agents show up here.
This flow is illustrative; the agent and tool names are real.
The agents run the meeting, you approve the decision.
The agents pull ERP, MES and IoT data through RAG, discuss it at the table, and produce decisions and an action plan. The flow runs without human intervention; the resulting decisions wait for approval.
xLAP+ — the meeting, the decisions and the action log stay in the same flow; the plant manager reads every unit from the same screen.
Every production, revenue, OEE, investment and cost figure in this section is an illustrative value written to demonstrate the flow; none of it is a real customer’s data. What is real is the mechanics of the meeting: retrieving the data, the discussion, and the record of decisions and actions.
400+ specialist agents. One orchestrator.
Each one is a specialist in its own domain, working under a single orchestrator. Reasoning happens in the AI, execution in deterministic tools.
The cards below are a representative slice of the registry; the full list grows with each deployment. Tap an agent to open its detail.
If AI is getting close to your data, the first question is permissions.
The answers below are not marketing copy; they are rules written into the code. Each one is a separate gate, built and tested as such.
What the agent sees = what the user sees.
If a user cannot see a field on screen, they cannot see it by asking the agent either. Being an administrator does not bypass the read gate: it is a separate gate with its own tests.
Role control
System-layer capabilities are open only to the administrator role, and the role is checked by identity, not by name. If the role is unknown, the default behaviour is to deny.
Allow-list
The permission operations an agent can call are enumerated. An operation not on the list will not run, even if approval was given.
Cannot touch its own role
An agent cannot escalate its own permissions. Without this rule the other two gates would be meaningless.
The model sees tool results bounded by the user’s permissions. A field the user cannot see is never sent to the agent either.
Not in one leap. In three measurable steps.
Each step has its acceptance criterion written up front; if it does not pass, we do not move on. The decision stays with you and every step is reversible.
Discovery and live demo
We listen to your processes, take one of your screens and watch the request → build → verification chain together on a live system.
A concrete need you choose turns into a screen in the same session.
Limited-scope pilot
One department, a few screens, real users. With your own data, in your own environment; the request flow and permission model are live.
Users open their requests from their own screens and see the released work on those same screens.
Rollout
Module-by-module expansion, opening the web channel, growing the agent scope screen by screen and enabling the guidance layer.
A steady release cadence that passes through the release gate.
One owner and a few users
A business owner who can decide and a few people who will really use the pilot scope. The fate of a pilot is decided by real usage, not technology.
An environment and access
A database environment and access permissions for the pilot. We handle setup and deployment; no need to distribute files to clients.
In the first meeting, do not ask us to “introduce the product”. Tell us the screen that wears you out the most — let us talk through that one, and build it in the same session if we can.
We would rather answer the hard questions up front.
These come up in every first technical meeting. We would rather not save our answers for later.
What you need to trust is not the model’s goodwill but the system’s limits. The model does not write free-form code; it calls the tools we wrote. Its work is not released until it passes the verifier, and release opens with human approval. So the guarantee is not “trust the model” but “the model cannot release without approval”.
Counted from the control plane’s own records (9 September 2026). These are evidence that this runs end to end, not the size of a vendor catalogue.
“With xLAP we get through in minutes what would have taken us a day. Creating screens, new steps, functions, reports, dashboards — all of it just by talking.”
See xLAP running on your own processes.
We walk through one request end to end: how it is opened, planned, built and released.
Request a demoWe use your details only to respond to this request.
- Screen, object and report definition from natural language
- The request → plan → build → verification steps working live
- The same definition running on desktop, web and mobile
- MES, IoT and quality control modules
- A scenario tailored to your own industry