The MCP Server Is a New Attack Surface: Hardening the Maximo AI Service After the CVEs

The Model Context Protocol server in MAS 9.2 changed what a Maximo deployment exposes. It is no longer a fixed endpoint performing one operation; it is a catalogue of discoverable tools an autonomous agent can enumerate, reason about, and invoke in sequences nobody explicitly wrote. This article…

Share

The MCP Server Is a New Attack Surface: Hardening the Maximo AI Service After the CVEs

For twenty years, a Maximo security review had a predictable shape. You drew the integration boundary, you listed the endpoints crossing it, and for each one you asked a single question: who is allowed to call this, and what can it do? The answer was always bounded, because an endpoint in Maximo does exactly one thing. MXASSET returns an asset. The MIF processes an inbound transaction. A REST handler in Manage reads or writes a specific object structure. The surface was large, but it was enumerable, and enumerable surfaces can be reviewed by a competent person with a spreadsheet and a week.

That model has an expiration date, and it arrived with the Maximo AI Service and the Model Context Protocol server that sits inside MAS 9.2. When Maximo exposes itself through MCP, it stops presenting endpoints and starts presenting tools. A tool has a name, a description, and a schema. An agent discovers those tools at runtime, reads their descriptions as natural language, decides which combination serves the request in front of it, and calls them in an order no developer ever specified. The set of operations is still finite. The set of sequences is not. Every security control most Maximo shops built assumes the sequence was written down somewhere, and in an MCP-driven stack it frequently is not.

This is why the recent CVE activity against the Maximo AI Service matters more than the headline scores suggest. CVE-2026-90920 carries a CVSS of 9.8, a CWE-94 classification for improper control of code generation, and a description that should be read slowly: AI Service 9.1.0 and 9.2.0 could allow a remote attacker to execute arbitrary code because generated code was not properly controlled. It sits alongside three previously reported dependency vulnerabilities at 7.5, all availability class, and the whole set is remediated by AI Service 9.1.19 or later and 9.2.3 or later from the MAS catalog. The patch is the easy part. The hard part is that the flaw's existence tells you something about the design assumption underneath the agent-to-Maximo seam, and that assumption will be re-derived by every team that builds an MCP server against Maximo this quarter.

The honest framing, before anything else: exploitation is recorded as none, there is no public proof of concept, and the EPSS score is well under one percent. This is not a fire. It is a design lesson delivered early, and it is worth more as a design lesson than as an alarm. What follows is the boundary, the failure mode, and the checklist.

Drawing the MCP Trust Boundary Instead of Gesturing at It

Most teams that say "we secured the MCP layer" cannot draw it. They can describe it in the abstract, which is not the same thing. So start with the concrete question: what are the distinct authentication and authorization decisions in a Maximo MCP request, and where does each one happen?

There are four hops worth naming precisely. First, the agent or orchestrator authenticates. In a watsonx Orchestrate deployment this is typically a service credential or an OAuth client, and it identifies the agent, not the human on whose behalf the agent claims to act. Second, that credential is presented to the MCP layer, which authorizes the agent to see a subset of the tool catalogue. Third, the MCP layer executes a tool, which means it calls into the Maximo AI Service. That call carries its own authorization, because the AI Service needs permission to read or write the Maximo objects the tool touches. Fourth, the underlying Maximo API call runs as whatever integration user the AI Service is configured with.

The failure mode is almost always in hops two and three, and it is always the same shape. A single credential is reused for all agents. A single integration user backs all tool invocations. The tool catalogue is exposed whole because per-tool scoping felt like premature optimization. Each of those choices is defensible in a pilot with one agent answering questions about asset counts. None of them survives contact with a second agent, a second use case, or an agent that can also write.

The reason hop three is where CVE-2026-90920 lives is structural rather than incidental. The MCP layer is the only place in the stack where generated content crosses from data into instruction. Everything upstream of it treats the agent's output as a payload: text to be parsed, a tool name to be matched, arguments to be validated. At the tool boundary, the same output becomes something the system acts on. If the component authorizing and executing that transition treats generated code as trusted because it came from inside the trust boundary, the boundary has already failed, because the whole point of the boundary is that "inside" is a claim requiring verification, not a property inherited from position.

So the useful exercise is not to list your endpoints. It is to answer, for each of the four hops, three questions. What authenticates here? What is the credential's scope, expressed as a specific list of Maximo objects and operations? What happens if this credential is used by something other than the agent it was issued to? A team that can answer those twelve questions has a trust boundary. A team that cannot has a diagram.

There is a second dimension that Maximo shops under-weight because their historical threat model was internal. MCP servers are frequently deployed to serve more than one consumer: a desktop assistant for planners, an orchestrator running scheduled maintenance triage, a migration tool, a data-quality agent. Each consumer brings its own users, its own failure modes, and its own tolerance for an incorrect write. If the MCP server cannot distinguish them, it will authorize all of them identically, and the weakest consumer defines the security posture of the whole estate. Distinguishing them is not a hardening afterthought. It is the boundary.

Why Reads and Writes Cannot Share a Credential

The single highest-leverage change in a Maximo MCP deployment is to stop letting reads and writes travel through the same identity, and the community has already converged on the slogan for it: reads are queries, writes stay verbs.

Markus van Kempen's IBM Community write-up on what building MCP servers taught him, published 11 October, is the closest thing to an authoritative practitioner reference this cycle, and its central arguments are worth compressing. Treat the tools like a database: the catalogue is an inventory, it needs owners, it needs an audit, and it should be curated rather than accumulated. Manage tool count aggressively, because a large catalogue degrades agent reliability and expands the surface simultaneously. And keep the read path separate from the write path, because a query is idempotent and harmless to repeat while a status transition, a work-order approval, or a parts issue is neither.

The operational version of that principle is a two-credential minimum per agent. One identity carries read scope across the object structures the agent legitimately needs. A second, separate identity carries narrowly scoped write permission on exactly the objects and transitions the workflow requires, and nothing else. The read credential is issued broadly and monitored for volume. The write credential is issued narrowly, logged at the object level, and ideally held by the approval path rather than the agent.

That last point is where the design gets interesting, because it is where a Maximo team can impose a control the agent framework cannot circumvent. The agent produces a proposal: a structured object describing an intended change, with the reasoning attached. That proposal is validated against the same Maximo business rules any human-initiated change would face, and applied by a separate executor identity. The agent never holds a credential that can mutate state. Whatever the agent convinces itself to do, the worst outcome is a rejected proposal, and that property survives every prompt injection, every tool misuse, and every future CVE in the component that generates the proposal.

This is not a theoretical pattern either. Two live deployments surfaced this window both implement some version of it, which is the strongest evidence available that it is not exotic. IBM's engagement with Mashreq routes roughly four thousand agent requests a month through IBM Context Forge, an MCP gateway, rather than letting agents reach services directly, and is separately exploring on-premises deployment of the underlying agent tooling for data residency. A Japanese practitioner tool, MX Stage from TSUNAGI, routes Excel-to-Maximo integration work through an approved AI environment with human final confirmation before anything commits. Both are small. Both get the shape right: the agent proposes, the gateway authorizes, the human or the business rule disposes.

The counter-argument a Maximo lead will raise is throughput. If a human confirms every write, an agent that replaces manual data entry has bought you validation time rather than saved labor. That is true for high-volume, low-risk writes, and the right answer is to classify the writes rather than to abandon the pattern. A status change on a non-critical asset is not the same decision as issuing a part against a safety-critical work order. Build the classifier, apply per-class confirmation rules, and let the write scope follow the classification. Teams that skip this step eventually grant one broad write credential to quiet the friction, and they have purchased throughput with the exact exposure the two-credential design existed to prevent.

Treating the Tool Catalogue as Inventory You Have to Audit

If reads and writes need separate credentials, what does the read side look like when it grows? Maximo has an enormous object model. Exposing it naively through an MCP server is the fastest way to build an attack surface that nobody can review and an agent that nobody can debug.

The discipline is to treat every exposed tool as an asset with an owner, exactly as you would treat a Maximo configuration, and to run the same lifecycle. A tool enters the catalogue because a named workflow needs it. It carries a description written for an agent's benefit, including what it does not do. It carries a schema that constrains inputs to the values that make sense. It has an owner who reviews it when the object model changes. It leaves the catalogue when the workflow it served is retired, and that removal is a deliberate act rather than the residue of nobody maintaining it.

The reason this matters technically, not just administratively, is that tool descriptions are prompt surface. An agent reads them as instructions. A description that says "updates the asset record" invites the agent to update asset records. A description that says "proposes a change to an asset record, which is reviewed before it is applied" tells the agent the shape of the correct action. Vague descriptions produce vague behavior, and vague behavior in an agent with any write scope is a security problem disguised as a UX problem.

Then there is the count. Van Kempen's argument that a large tool set degrades reliability applies here with a security twist: every additional tool is another authorization decision, another schema to validate, another description that can be interpreted in a way its author did not intend. A Maximo MCP server exposing fifty tools is not five times as risky as one exposing ten, because an agent composing tool sequences has a search space that grows combinatorially. Curate toward the smallest set that serves the workflows you have actually deployed. If a tool has no current consumer, remove it; it can be re-added in an afternoon, and the interval between removal and re-addition is time during which nobody can invoke it by accident.

The audit itself is straightforward once the catalogue is treated as inventory. For each tool, record the Maximo object structures it reads or writes, the credential it executes as, the workflows that call it, and the owner. Then ask the question auditors actually care about: can you demonstrate, for a given agent action last week, which credential authorized it, which human or rule approved it if it wrote, and what the object looked like before and after? If that reconstruction takes an afternoon of log spelunking, the catalogue is inventory in name only.

Finally, remember that the MCP server itself is a Maximo component and inherits the estate's patching discipline. CVE-2026-90920 and the three dependency CVEs are all remediated on the supported CD line, which means a Maximo shop that has stopped patching does not merely have an old catalogue. It has a catalogue whose execution boundary cannot be updated. That is the practical reason the entitlement question and the agent-governance question are the same question, and it is why the migration conversation should be had by the same people who own the agent roadmap.

The Hardening Checklist, in the Order You Would Actually Do It

Enough framing. Here is the sequence, ordered so that each step makes the next one cheaper.

One. Inventory the AI Service and confirm your release line. Identify which MAS deployment runs the Maximo AI Service, and which version. If it is 9.1.x below 9.1.19 or 9.2.x below 9.2.3, you are on a release line carrying a critical code-generation flaw and three availability-class dependency flaws. Check the MAS catalog for "Update Available" and confirm your channel can actually see the fix. If the deployment sits behind a support gap, record that as a risk item owned by a named person, because it will not resolve itself and it is now the sharpest example of what a support gap costs.

Two. Restrict network reachability to the AI Service. The vulnerability is described as remotely exploitable, which means the reachable surface is a control you own. In most deployments the AI Service does not need to be reachable from user subnets at all; it needs to be reachable from the agent runtime and, if you have one, the gateway. Put it behind that path and treat any other source as an anomaly. This is a firewall change, it takes an afternoon, and it is the control that most reliably survives a future vulnerability of the same class.

Three. Separate credentials by agent and by workflow. Issue one distinct credential per agent, and where a workflow's blast radius justifies it, one per workflow. Never a shared service account across multiple agents. Scope each credential to the specific object structures and operations that agent's legitimate work requires, and write the scope down where a reviewer can find it. The test for adequate scoping is simple and slightly brutal: if this credential were used by an agent that had been fully hijacked, what is the worst thing that could happen to the asset estate, and is that answer acceptable?

Four. Split the write path out of the agent. Agents hold read scope and produce proposals. A separate executor identity, ideally behind an approval step or a business-rule gate, applies the mutation. Classify writes by risk so that low-risk transitions can flow with light confirmation while high-risk ones require a human. This step is the one that most improves the security posture per hour of engineering effort, and it is also the one that most improves auditability, because proposals are inherently more explainable than mutations.

Five. Monitor code generation and execution, not just API traffic. The mechanism in CVE-2026-90920 is improper control of code generation, which means the observable signal is not an unusual HTTP request. It is unusual generation and execution behavior: unexpected code paths, atypical resource consumption, execution traces that do not correspond to any deployed tool's declared purpose. Post-patch, watch resource consumption and execution patterns on the AI Service anyway, because a post-update baseline is the most useful baseline you will get. Alert on deviation from it.

Six. Run the same provenance discipline over your dependencies that you would over your own code. The advisory set includes the AI Service's third-party dependency list, which is the ordinary reality of a modern Java and Go component. The implication is not that those libraries are suspect; it is that AI Service security is substantially supply-chain security, and the same argument applies to any Maximo MCP server you build yourself. Track what your build pulls in, know which of it is reachable from an agent-invokable path, and treat an unexplained new direct dependency as a review trigger rather than a convenience.

Seven. Re-derive the boundary whenever the catalogue changes. A trust boundary is not a one-time artifact. Every new tool, every new agent, every new consumer of the MCP server is a boundary change and deserves an authorization review proportional to the write scope it introduces. Put it in the change process next to the Maximo configuration review, because it is the same class of change.

The order matters. Patching and network restriction come first because they are cheap and they buy time. Credential separation and write-path splitting come next because they reduce the blast radius of everything that follows. Monitoring last, because monitoring without a scoped boundary produces an alert stream nobody can act on.

What This Means for the Agent Roadmap You Are About to Fund

There is a version of this story where the CVEs are an argument for slowing down, and that reading is wrong. Two live deployments are already running governed agent access to enterprise systems at meaningful volume, and the vendor's own agenda for the next quarter is about governing agents in production rather than demonstrating new capability. The direction is settled. What is unsettled is whether Maximo teams build the governance into the first deployment or retrofit it later, and retrofit is dramatically more expensive because by then the credentials are shared, the catalogue is unowned, and the write path is load-bearing.

The concrete implication for a Maximo lead planning the next quarter is to treat agent access as an integration project with a security deliverable, not as an AI project with a security question attached. That means the same people who own your MIF connections and interface tables own the MCP catalogue. It means the architecture review that gates a new interface also gates a new tool. It means the credential model is written down before the first agent reaches production rather than after the second one does. Teams that make that shift will find the technology side surprisingly undramatic, because the hard problems turn out to be the ones Maximo teams have solved before: who owns this, what can it do, and how would we know if it did something else.

There is also an uncomfortable implication for the way Maximo security reviews are scoped. The review questions that matter now are not about endpoints. They are about identities, scopes, and execution paths. A competent reviewer who has spent years on Maximo integration security will find the object model familiar and the authorization model new, and the gap between those two is where the risk concentrates. Bring in whoever owns identity and access management in your organization early, because the credential design decisions here are IAM decisions wearing an EAM costume, and the people who have made those decisions before will recognize the failure modes immediately.

Finally, budget for the boring parts. Tool inventory takes weeks of somebody's attention spread across quarters. Credential separation requires plumbing that will look like overhead until the first incident makes it look cheap. Monitoring requires baselines, which require patience. None of that is exciting, and all of it is the difference between an agent deployment that scales across the estate and one that gets shut down by a risk committee the first time something surprising happens.

Practical Implications

If you administer a MAS deployment with the AI Service enabled, the immediate action is a version check and, if you are below 9.1.19 or 9.2.3, a patch through the MAS catalog, followed by network restriction of the service and a post-patch baseline of resource consumption and execution behavior. Do not treat the "exploitation: none" status as a reason to sequence it behind other work; the reason to patch now is that the window before a proof of concept appears is exactly when the cost of patching is lowest.

If you are architecting agent access to Maximo, design the credential model before you design the tool catalogue, because the catalogue is easy to change and the credential model is not. One credential per agent, separate read and write identities, an executor that applies mutations under business-rule or human approval, and a write-risk classification that lets low-risk transitions flow without turning the whole estate into a confirmation dialog.

If you own the platform roadmap, connect the agent governance work to the support and patching conversation rather than running them as separate tracks. The fix vehicles for the current critical vulnerabilities live on the supported CD line, which means a shop with a support gap has no path to remediate its agent execution boundary. That is a durable argument for closing the entitlement gap, and it is more persuasive in a steering committee than an abstract warning about unsupported software.

If you are the person who will be asked, in a year, why nobody reviewed the MCP catalogue: start the inventory now, with owners and scopes and a review cadence, and keep it small enough that the review is real. The catalogue will grow. The question is whether it grows with an owner or without one.

Bottom Line

The Maximo AI Service CVEs are a patch event and a design lesson at the same time, and the design lesson outlives the patch. CVE-2026-90920 is a critical code-generation flaw at the exact point where an agent's output stops being data and starts being instruction, and the reason it is worth writing about is that the same design assumption will be reintroduced by every team building MCP access to Maximo over the next year. The defenses are neither exotic nor expensive: patch to 9.1.19 or 9.2.3, restrict network reachability to the AI Service, issue one credential per agent with separate read and write identities, keep the agent proposing while a separate executor applies, curate the tool catalogue as owned inventory, and monitor code generation and execution rather than just API traffic. None of that requires waiting for a proof of concept. Doing it now costs an afternoon of firewall changes and a quarter of attention. Doing it after the first incident costs a risk committee.