What actually changes in the architecture?
The difference is one layer, and it is the layer everything else depends on. Both systems hold the same data. They differ in what sits on top of it, and therefore in who can operate the system and what operating it looks like.
| Layer | Conventional ERP | Agentic ERP |
|---|---|---|
| Data | Database | Database |
| Access layer | APIs, built for screens | Tools, built for agents |
| Interface | Web UI — forms, lists, screens | MCP — any agent can connect |
| Who operates it | A trained user, clicking | An agent, instructed in language |
| Where the rules live | In the application and UI layer | Beneath the tools, in the kernel |
| How AI is added | An assistant wired on top | It is the interface, not an addition |
| What a user learns | Where each screen is | What they want done |
Read the middle column and the right column as two different answers to the same question: what is this database for? One answers "for screens". The other answers "for agents". Everything downstream follows from that.
How is this different from adding AI to the ERP you already have?
This is the distinction that matters commercially, because almost every vendor now offers the first thing and calls it the second.
An assistant added to an existing stack sits above a document system, a planning tool, an ERP, some spreadsheets and a procurement portal. It reads several partial versions of the project, so its answers cannot be trusted. And it acts under none of those systems' permissions, so it cannot be allowed to act. What remains is a chatbot with opinions.
An agentic ERP inverts that. The system owns the chain end to end, so there is one record for the agent to stand on, and the permissions sit beneath the tools rather than around them. The agent is not trusted because it is clever. It is constrained because it cannot reach past what it has been granted.
What does MCP have to do with it?
MCP — the Model Context Protocol — is the open standard by which an AI agent discovers and calls external tools. It matters here for one reason: it stops the ERP being tied to a single vendor's assistant.
Because Crolle publishes its operations as MCP tools, any agent that speaks MCP can be given access, under the same permissions and the same audit trail. The connectors the desktop application offers are published as a machine-readable catalog, and an entry is listed only after it has been proved with the application's own sign-in code.
The practical consequence: the company is not buying a chat window that belongs to whoever built the ERP. It is buying a system its agents can operate.
Is there still a normal interface?
Yes. The agent being the primary interface does not make it the only one.
Crolle ships a desktop application for Windows 10 or later on x64, with its own screens for work that is better looked at than described — reviewing a prepared decision, reading a document, comparing an evidence package before approving it. Some things genuinely are faster to see than to ask for.
What disappears is the obligation to learn where seventy screens live in order to do a job you could describe in a sentence.
Who decides what the agent is allowed to do?
The organisation does, and the limits live in the kernel rather than in a wrapper around it. That placement is the whole safety argument: a rule enforced in the interface can be bypassed by reaching the data another way, while a rule enforced beneath the tools applies to every caller.
Three things hold, always:
- Delegated authority — the agent can only reach what it has been granted, by role and by scope.
- Human approval — a prepared recommendation is not permission to act. An authorised person commits it.
- An audit trail — what was decided, by whom, on what evidence, recoverable afterwards.
The agent prepares the decision. A person makes it. That order does not reverse.
Why is construction the hardest case?
The architecture is general. The value is largest where one change moves through many disciplines at once, and construction is an extreme example.
A single drawing revision changes a quantity. That quantity changes a cost. The cost changes a commitment. The commitment changes a procurement schedule, which changes a work sequence, which changes a payment certificate, which changes cash. In a fragmented stack each of those lives in a different system and the connection between them is somebody's memory.
Crolle is designed to cover the chain in one system: tender, estimation, award, planning, procurement, subcontracts, cost, revenue, finance, cash, closeout and documents. Twelve stages, one record — which is what makes the connection between them something a machine can actually follow.
Common questions
Does an agentic ERP replace the finance system too?
In Crolle's case, yes — cost, revenue, finance and cash are stages in the same chain, not a separate system to reconcile with. That is the point of owning the chain end to end: a commitment made at award is the same object the finance stage later settles, rather than a copy of it.
Is this only useful for large contractors?
No. The core is one system, so the same chain serves a contractor running a handful of projects and one running a portfolio of them. What changes with size is how much coordination the agent absorbs, not which parts of the product apply. One construction ERP for main contractors of every size covers this in detail.
What happens if the agent gets something wrong?
It prepares; it does not commit. A wrong recommendation is caught at the approval step, where the evidence behind it is visible — the drawing, the quantities, the rate basis. The audit trail records what was proposed and what was decided, so an error is traceable rather than mysterious.
Can we use our own AI assistant with it?
That is what the MCP layer is for. An agent that speaks MCP can be granted access to Crolle's operations under the same permissions a person would have. The ERP does not require you to use a particular assistant to reach your own data.
Crolle is opening early access to a small group of contractors and partners. To see it on your own projects, write to info@crolle.ai.