Before you give an AI agent write access
- Read access fails in ways you can check. Write access fails in ways you cannot undo.
- The question is not whether an AI agent may write to ERP, MES or PLM. It is who approves the write, and where that approval lives.
- Standard protocols such as MCP make an agent’s access to enterprise systems uniform. They say nothing about authority.
The two questions people ask as one
Every conversation about AI and industrial systems collapses two questions into one sentence. The first is about permission: may the agent change anything? The second is about governance: when it changes something, who approved it, and can we prove that six months later?
Teams answer the first with a binary, read-only or full access, and never reach the second. That is how a project gets demoed with enthusiasm in month one and switched off in month four.
We build one of these layers, so treat the rest of this as an argument you can use against us.
Why an AI agent’s read access and write access are different permissions
A read permission fails in the direction of attention. The agent summarizes something wrong, a person acts on that sentence, and someone re-checks the source. A wrong decision, caught by whoever owns it.
A write permission fails in the direction of fact. A record changes, and every system downstream treats it as true. Industrial platforms are not documents with version history and an undo button. Reversing a released change is a reconciliation exercise.
What an unwanted write looks like in the three systems this discussion is really about:
In a PLM, a drawing revision is superseded while a linked assembly still references the old one, or a BOM substitution is applied without the engineering change order that would have authorized it. Manufacturing then builds a configuration engineering never released.
In an MES, a work order is closed without the inspection step recorded, and the record now asserts that inspection happened.
In an ERP, a part number or quantity changes, and the consequence travels into purchasing, inventory valuation and customs documents that the agent was not reasoning about.
None of this is exotic. It is the ordinary content of a change an experienced engineer would have paused over, for a reason the agent has no access to.
| What the agent does | Failure looks like | Recovery | Reasonable gate |
|---|---|---|---|
| Answers a question | A wrong sentence someone acts on | Re-check the source | None |
| Drafts a record | A wrong draft | Discarded before sending | Author reviews the draft |
| Creates a record | A stray ticket, supplier entry or issue | Manual cleanup | Scoped approval, role-restricted |
| Modifies a released record | Silent break in configuration or traceability | Reconciliation, possibly an audit finding | Named approver, before and after visible |
| Deletes or closes | A record asserting that work was done | Often not recoverable | Two people, and only if the system supports it |
Four models for AI agent write access to ERP
Almost every deployment you will be offered is one of these four. They differ in where the human sits, not in how capable the model is.

1. Read-only. The agent answers questions across systems and writes nothing. A legitimate starting point, and often the fastest way to prove value. It stops being sufficient the moment the answer has to go somewhere.
2. The agent drafts, a human executes. The agent produces the update and a person pastes it into the system. This is where most teams actually are, whatever the architecture diagram says. It works, it needs no permission model, and it does not scale past a few times a day, which is why people start feeding real data into a personal AI tool instead.
3. The agent proposes, a human approves inside the system. The proposal carries the target system, the record, the field or operation, the current value, the proposed value, a reason and a timestamp. A named person approves or rejects it in the product, and the decision stays attached to the change it authorized. For anything touching a system of record, this is the model we would defend.
4. The agent writes directly, within policy guardrails. Defensible for operations with a small radius: a tag, an internal comment, a draft status, a label on a document a human already reviews. Not defensible for master data, released requirements or financial quantities.
Two mistakes account for most of what you will see: choosing model 4 because the demo was faster, and staying at model 2 forever while calling it human in the loop.
What a real approval actually needs
“Human in the loop” is used loosely enough to mean anything from a glance at a screen to accountability for a change. Five properties separate a control from a gesture.
The proposal is a stored object, not a message. Target system, record identifier, field or operation, current value, proposed value, reason, timestamp. That is seven things. If you cannot list all seven for a given change, you have a chat, not a proposal.
The approver is a named, authorized person, authorized for that system and that operation, not merely present in the conversation. Once anyone in a thread can say yes, accountability has left the room.
The decision is stored with the thing it changed. The first question an auditor asks is not whether approval existed, but whether you can show the approval for this record.
Execution re-reads the target. Approval is often granted against stale state, because the record moved between proposal and click. Read the current value again before writing, and record both versions when they diverge, or the audit trail documents an intention rather than an event.
Permission is scoped, not switched. “AI access: enabled” is not a permission model. What matters is per connector, per operation, per role, and for high-consequence fields, per field.
One failure that guardrails never catch: the agent writes a field it is genuinely allowed to write, and gets the content wrong. Permission was correct and the value was not, which is why permitted writes to high-consequence fields still deserve review.
MCP standardizes access. It does not standardize authority.
In November, MappingSpace ALM opened its MCP surface, exposing its R&D management tooling as standard tools, and Mapping Intelligence connects to it. That is a good development, and it makes this article more urgent rather than less.
What a protocol like MCP settles is access. A tool is described in a uniform way, an agent calls it without a bespoke wrapper, and the integration tax that used to justify a six-month project drops to an afternoon. That is a real gain, and it is why the number of agents able to reach an enterprise system is about to rise sharply.
What it does not settle is authority. An MCP server exposing update_requirement describes what can be called. It does not say who may call it, which fields are in scope, whether a person must approve, where that approval is recorded, or what happens when the record has changed since the agent last read it. Those are policy questions, and a protocol is the wrong place to answer them.
So the practical instruction is not “adopt MCP or do not”. Take the standard for what it is, a transport and a catalog, and keep the approval gate above it, in a layer that knows identity, scope and history. If the gate lives inside each MCP server, you will re-implement it once per system and audit it once per incident.
How Mapping Intelligence handles write access
The line we use in public is deliberately blunt: the AI proposes, a person signs. Our position is that a write should reach a system of record only after a named person approves it, and that the approval belongs in the product rather than in a chat thread.
Three things we can show you today answer the governance half of the question, and all three are on the product page:
- Access is scoped per member and per role, covering which models, connectors and features each person can use, so “who can do this” is a setting rather than a convention.
- Token consumption is visible per team, user, application and API, which is how a runaway workflow becomes visible before it becomes a budget dispute.
- The model is swappable, including a locally deployed one, so deployment location does not force a trade against governance.
What we do not claim: there is no universal permission matrix that makes any agent safe to point at master data. Scoping a workflow into a permission model is real configuration work, and it is work we do with you rather than for you.
Six questions to ask any AI vendor, including us
- Is authorization scoped per system and per operation, or is there one “AI enabled” switch?
- Can you show me the approval record for a specific record you changed last month?
- Does the system re-read the target before executing, and record the difference when it moved?
- Does your MCP surface, or equivalent, separate read tools from write tools?
- What is recorded when a proposal is rejected?
- Can we start read-only, and enable write for one workflow and one approver?
A vendor who answers these six with specifics has thought about the problem. One who answers the first four with “yes, we have human in the loop” has not.
FAQ
Is read-only enough?
For a first month, yes, and that is how most teams should start. As a permanent architecture, no: if the value is in the workflow, the write happens somewhere, and the only question is whether it happens inside your permission model or in a paste step that leaves no record.
Doesn’t an approval step make the automation useless?
Only if every action needs one. Classify by consequence: let the agent read and prepare freely, gate the writes that touch a system of record, and require nothing for operations a human already reviews.
We already have change control. Isn’t this duplication?
It should be the same process, run inside the tool rather than beside it. If your change control runs on documents, the proposal is simply its input. Where the two disagree, the tool is wrong, and the fix is to reconcile them rather than add a second gate.
Does using a local model make this safer?
Deployment location and write governance are separate questions. A local model does not give you an approval trail, and a cloud model does not prevent you from having one. For the full architectural breakdown of local endpoints versus full perimeter control, see our guide to cloud vs on-premise AI and data sovereignty in manufacturing.
Want to see the propose-and-approve flow on a live connector? Write to us at support@mappingintell.ai.
