Your MCP Server Is a New Attack Surface: Hardening the Maximo AI Service After CVE-2026-90920
The Model Context Protocol server that connects AI agents to Maximo is a genuine new attack surface, and IBM's AI Service RCE advisory proves the tooling layer is already being probed. This article maps the MCP trust boundary end to end, explains what CVE-2026-90920 exposes about the agentic…
Your MCP Server Is a New Attack Surface: Hardening the Maximo AI Service After CVE-2026-90920
Every integration into Maximo has always been a doorway, and every doorway is a decision about who gets to walk through it. For twenty years the practical version of that decision was simple: a REST call, a MIF queue, a database link, or a web service endpoint, and the security model was whatever surrounded those transports. Identity was checked at the edge, the payload went in, the record came out. The attack surface was large but conceptually flat. You enumerated your endpoints, you locked them down, you moved on.
The Model Context Protocol (MCP) server in MAS 9.2 broke that flatness. MCP does not just expose a fixed endpoint that performs one operation. It exposes Maximo as a catalogue of discoverable tools that an autonomous AI agent can enumerate, reason about, and invoke in sequences nobody explicitly wrote. The agent decides which tools to call and in what combination based on a natural language goal. That is exactly the flexibility that makes agentic workflows valuable, and it is exactly the flexibility that makes the integration layer a security problem rather than a plumbing problem. A tool catalogue is not a contract. It is an inventory of capabilities that a non-deterministic caller will exercise in ways you did not anticipate.
Then, on 05 October 2026, IBM published a security bulletin for the Maximo AI Service disclosing CVE-2026-90920, described as an RCE-class flaw in a code-generation path, alongside several vulnerable third-party dependencies. The affected releases were AI Service 9.1.0 and 9.2.0, remediated in 9.1.19 and later and 9.2.3 and later. The timing is the story. The industry spent the autumn wiring agents into Maximo, publishing afternoon tutorials on how to stand up a first agent, and in the same week the vendor disclosed that a component sitting squarely in that path could be made to execute code. This is not a reason to avoid agentic Maximo. It is a reason to stop treating the MCP boundary as a convenience feature and start treating it as production infrastructure with a threat model.
This article does not rehash the bulletin. It uses the bulletin as a starting point to do the architectural work that most MCP deployments skip. We will map the trust boundary of an MCP integration end to end, dissect what CVE-2026-90920 reveals about the agentic toolchain as a whole, work through identity, transport, and tool-scoping decisions that determine whether your deployment is defensible, and close with the operational controls that make the difference between a demonstration and a system you would let touch a production Maximo environment. The audience is anyone who is about to, or already has, exposed Maximo to an AI agent.
The MCP trust boundary, mapped properly
The first mistake teams make with MCP is imagining a single boundary: agent on one side, Maximo on the other. That model is wrong, and it is wrong in a way that hides the exact places CVE-2026-90920 lives. There are at least four distinct boundaries in any real MCP deployment, and each one has its own identity story, its own failure modes, and its own audit requirements.
The outermost boundary sits between the AI model itself and the agent runtime that hosts it. If you are using a hosted model, prompts and tool definitions leave your environment, and tool results come back. The model does not hold credentials, but it does hold the authority to ask the runtime to call tools on its behalf. The model is untrusted by design. Any data that reaches the model, including Maximo records returned by a tool call, can influence the next tool-call decision. This is the prompt-injection surface, and it is real in Maximo because so much of what the platform stores is free text: work order long descriptions, follow-up logs, failure remarks, problem descriptions entered by technicians. A record you trust at the database layer is untrusted content the moment it lands in a model context.
The second boundary is between the agent runtime and the MCP server. This is where protocol-level authentication and authorization happen. The MCP server needs to know which agent is calling and what that agent is allowed to do. If this boundary is a shared static token, you have collapsed every agent identity into one, and the audit trail becomes useless. If it is unauthenticated because the server sits inside a trusted network zone, you have assumed that anything capable of reaching the network is trustworthy, which is the assumption that every lateral-movement incident in history has punished.
The third boundary is between the MCP server and Maximo itself. The MCP server holds a Maximo identity, and it will act as that identity for every tool call. If it holds an administrative identity, the agent inherits administrative reach through a protocol designed for flexible composition. If it holds a read-only identity, the blast radius of a misbehaving agent is bounded by that identity. This single decision, which Maximo identity the MCP server runs as, is the most consequential security choice in the whole deployment, and it is routinely made by whoever happened to have a service account handy during the pilot.
The fourth boundary is the tool implementation layer: the code inside the MCP server that translates a tool call into a Maximo API operation, and in some deployments, that generates or evaluates code to do so. CVE-2026-90920 lives at or near this boundary. A code-generation path is a component that takes input influenced by a caller and produces something that executes. When that path is vulnerable, the MCP boundary stops being a gate and becomes a conduit. This is why the bulletin matters beyond its specific CVE: it proves that the newest layer of the Maximo stack is the least mature, and that maturity gaps are being discovered in production-facing components rather than in the UI.
Mapping the boundary this way changes the questions you ask. Not "is our MCP server secure" but "which identity does the runtime present, which identity does the server present, what can the model influence, and what executes at the tool layer." Those four questions, answered honestly, tell you where you actually stand.
What CVE-2026-90920 reveals about the agentic stack
It is tempting to read a single advisory, patch, and move on. That reaction is understandable and insufficient. The value of a disclosed vulnerability in a young component is not the specific exploit; it is what the disclosure tells you about how the component was built and what else might be built the same way.
The first lesson is that the AI Service's code-generation path is not a sandbox in the strict sense. Any component that generates or evaluates code based on model output or caller-supplied input must assume that the input can be adversarial. In a Maximo context, that input can originate from stored asset data, from a user's natural language request, or from content the agent retrieved and passed back into the toolchain. The vulnerable code path existed because somewhere in the design, generated code was treated as trusted enough to execute. That pattern, treating generated artifacts as trusted, is a recurring theme in agentic systems, and it appears in MCP tool implementations well beyond the specific component that was patched.
The second lesson concerns the dependency surface. The bulletin names vulnerable third-party dependencies in addition to the code-generation flaw. This is the least glamorous and most important part of the advisory. An MCP server that packages a large tool catalogue typically drags in a broad dependency tree: HTTP clients, serialization libraries, templating engines, code parsers, and model SDKs. Every one of those is a channel. Where the vendor maintains the AI Service, the dependency surface is the vendor's responsibility, and remediation is a matter of upgrading to 9.1.19 or 9.2.3 or later. Where you run a third-party MCP server that exposes a large catalogue of Maximo tools, that dependency surface is yours, and the vendor has no visibility into it at all.
The third lesson is about remediation latency. Between the affected versions and the fixed versions there is a window in which a deployment is exposed, and the practical question is how long your environment sits in that window. For the AI Service itself, the answer is controlled by your upgrade discipline on the OpenShift cluster, which many Maximo teams have historically treated as a quarterly rather than a weekly concern. For third-party MCP servers, there may be no vendor bulletin at all, which means the only detection mechanism is your own dependency scanning. If your agentic deployment does not include automated dependency scanning of every MCP server and sidecar in the path, you do not have a remediation process; you have a hope.
The fourth lesson is a pattern warning. When a vendor discloses one flaw in a category, it is common for similar flaws to surface later in adjacent components, particularly in components that share design assumptions. The design assumption here, that generated or model-influenced artifacts can be executed with limited trust checking, is not unique to one binary. Any Maximo deployment that runs agent tooling should plan for a security-maintenance cadence rather than a one-time hardening pass. The agents will keep being adopted. The tooling will keep maturing. The disclosures will keep coming, and the organizations that handle them well are the ones that built the cadence before they needed it.
None of this argues against agentic Maximo. It argues for treating the agentic layer as a component with a lifecycle, a dependency tree, and an advisory feed, exactly as you would treat a database or an application server. The bulletin is the moment to build that reflex, because the next advisory is not far away.
Identity and authorization at the MCP layer
If CVE-2026-90920 is the emergency, identity architecture is the real work. Most MCP exposures are not exploits; they are over-privilege, and over-privilege at the MCP layer inherits everything upstream and downstream of it. Getting identity right is therefore the highest-leverage security decision available, and it costs nothing but discipline.
Start with the model-to-runtime boundary. The model should never hold credentials, and it should never be the thing that is authenticated. The agent runtime authenticates; the model only proposes. This distinction matters because it determines where you can enforce policy. If your architecture authenticates the model, you have nothing to attach policy to. If your architecture authenticates the runtime and treats model output as an untrusted proposal, you can inspect, allow, deny, and log every action at a single choke point.
Move to the runtime-to-server boundary and insist on per-agent identity. Each distinct agent, and ideally each distinct workflow, should present a separate credential and receive a separate authorization scope. Shared static tokens are the single most common shortcut in MCP deployments and the single most damaging one, because they erase the ability to attribute anything. Per-agent identity makes it possible to revoke one agent without breaking others, to rate-limit one noisy workflow without penalizing the rest, and to read an audit log that says which agent requested which tool at which time. At the MCP layer, tool invocation should be authorized, not merely authenticated. Authenticating the caller tells you who is asking. Authorizing the tool tells you whether they may. Both are required.
Then confront the server-to-Maximo identity, which is where real-world deployments most often go wrong. The MCP server will act as a Maximo user for every operation. That user must be deliberately designed, not inherited. It should be a dedicated service identity, not a human administrator account, and it should carry the minimum set of Maximo security groups and privileges that the exposed tool catalogue actually requires. If the catalogue includes a work-order-creation tool, the identity needs the ability to insert work orders and nothing more. If the catalogue includes only read tools, the identity should be read-only, and the write tools should not be exposed at all. The principle is that the tool catalogue and the Maximo identity are two views of the same privilege set; if they disagree, the larger one wins, and the larger one is usually an accident.
Finally, design authorization to be deny-by-default and explicit. New tools should not appear in a catalogue and immediately be usable. They should appear, be reviewed, be assigned to an identity, and be enabled deliberately. This inverts the common pattern, in which a third-party MCP server is installed and its full catalogue becomes reachable the moment it is connected. That pattern is convenient and indefensible. The organizations that will weather the next advisory are the ones whose default is closed.
Underpinning all of this is a simple test. Take the MCP server's Maximo identity, run a privilege report, and ask what the biggest single action that identity could take is. If the answer alarms you, the architecture is not ready, no matter how well the transport is configured. Identity is not one control among many. It is the control that bounds every other one.
Transport, network, and the blast radius question
Transport and network controls do not make a deployment safe on their own, but they decide how bad a bad day gets. Their job is to shrink blast radius, and blast radius is the only thing that matters once an attacker or a misbehaving agent is already inside the boundary.
The first decision is whether the MCP server is reachable from anywhere beyond the agent runtime that needs it. In most deployments the answer should be an emphatic no. The MCP server is not a user-facing service. It should be bound to a private interface, reachable only by the specific runtime instances that call it, and ideally only within a dedicated network segment. The mistake pattern is exposing an MCP endpoint on a shared application network because it was convenient during setup, which puts the agentic boundary on the same plane as everything else on that network. Network segmentation does not replace authorization, but it converts a single mistake into a contained one.
The second decision is transport security and its configuration details. Traffic between the runtime and the MCP server should be encrypted in transit, and the server should present a certificate the runtime validates, not one that is blindly accepted. Certificate validation disabled for convenience is a recurring pattern in pilot deployments that then graduates to production untouched. Mutual TLS is the stronger posture where the runtime and server can both present identities, because it makes the connection itself an authenticated fact rather than an anonymous pipe protected only by a bearer token that can be replayed.
The third decision is the shape of the egress path from the MCP server to Maximo. The server needs to reach the Maximo APIs, and it should reach them the same way any other integration component does, through the supported interface, on the supported port, with the identity you designed in the previous section. It should not reach the database directly, it should not use an administrative channel bypassing the application layer, and it should not have network reach into parts of the estate it does not need. Every additional reachable system is a potential pivot, and an MCP server that can talk to half the intranet is a pivot waiting to happen.
The fourth decision concerns rate and volume limits, which are security controls dressed as performance controls. An agent that goes wrong rarely goes wrong quietly; it loops. Tool-call rate limits per agent, per tool, and per time window turn a runaway loop into a throttled error rather than a flood of Maximo writes. Concurrency limits on how many simultaneous tool calls one agent may hold prevent a single workflow from saturating the API layer and starving legitimate traffic. Payload size limits bound how much data a single call can move. None of these stop a targeted attacker, but all of them blunt the accidental denial of service that unsupervised agents produce, and that is the failure mode most teams will actually experience.
The fifth decision is logging and retention. Every tool invocation should produce a record: which agent, which tool, which arguments, which Maximo identity, what result, and when. Arguments matter because they tell you what the agent asked for, not just that it asked. Results matter because they let you reconstruct what data left the boundary. Without this, an incident review is guesswork, and a security audit is a conversation you cannot win. Logs should be shipped off the MCP host so that a compromised host cannot erase its own trail, and retention should be long enough to cover your slowest detection scenario.
Transport and network controls share a property: they are cheap to get right at design time and expensive to retrofit. The pilot that exposed the endpoint openly will not naturally tighten as it scales. Someone has to decide, explicitly, that the agentic boundary is production infrastructure, and that decision is what these five controls implement.
Operational controls: patching, audit, and kill switches
Even a well-architected MCP deployment will need operational controls, because architecture bounds the blast radius but operations determine whether you notice and respond. These controls are about survivability over time, not configuration on day one.
Patching is the first and least negotiable. The Maximo AI Service remediation, upgrading to 9.1.19 or later and 9.2.3 or later, is a concrete action with a concrete deadline, and it should be tracked with the same urgency as any other security patch on the cluster. Beyond the vendor component, every third-party MCP server in the path needs a dependency inventory and automated scanning. If you cannot answer "what version of which libraries is my MCP server running" without a research project, you cannot patch on a reasonable cadence, and the cadence is the control. The dependency-heavy tool catalogues common in the third-party ecosystem make this a first-class obligation rather than an afterthought.
Audit is the second. Beyond the tool-invocation logs, you need to be able to reconstruct intent. Agentic systems fail in ways that look innocent in isolation: a sequence of individually valid reads that together reconstruct a sensitive dataset, or a chain of writes that is only obviously wrong in aggregate. An audit capability that records sequences, not just events, is what makes those patterns visible. It also serves a second purpose, which is trust. When an agent proposes an action that touches production data, the audit trail is what allows a human to review the agent's actual behaviour rather than its described behaviour. If your audit cannot produce that, review is theater.
Kill switches are the third. Every agent should be revocable independently, and revocation should take effect without redeploying the cluster. This means per-agent credentials that can be disabled, a tool catalogue that can be narrowed at runtime, and ideally a circuit breaker that can suspend a specific workflow when it exceeds behavioural thresholds. The scenario you are defending against is not exotic: an agent that was fine yesterday behaves strangely today because upstream data changed, and you need to stop it in seconds, not in a change window. Build the switch before you need it, because you will not build it during the incident.
Change control is the fourth. Adding a tool to the catalogue is a privilege change, not a feature change, and it should be reviewed as such by someone who understands what that tool can do to Maximo. The common failure is that tool catalogues grow by accretion, each addition individually reasonable, until the cumulative privilege set is far larger than anyone intended. A lightweight review step, where each new tool is mapped to a Maximo privilege and to a business justification, keeps the catalogue honest.
Finally, exercise the controls. Run a tabletop in which an agent is assumed to have gone rogue, and walk through detection, revocation, and recovery using the actual logs and switches rather than an imagined procedure. Most teams discover during the exercise that their revocation path depends on a person who is asleep, or their logs lack the one field they need, or the kill switch is behind the same door the compromise used. Finding those gaps in a tabletop is free. Finding them during an incident is not.
Practical implications
For integration architects, the immediate consequence is that MCP is now a security architecture problem, not just a connectivity design. The trust boundary has four layers, each with its own identity and its own failure modes, and the code-generation path at the tool layer has a proven vulnerability class. The practical step is to redraw your architecture diagram with those four boundaries explicit, assign an identity to each, and confirm that no boundary relies on network position alone.
For teams running the Maximo AI Service, the action is concrete and time-bound: verify your version, upgrade to 9.1.19 or later on the 9.1.x line and 9.2.3 or later on the 9.2.x line, and confirm the fix has landed rather than assuming the cluster's rolling update carried it. Treat the bulletin as the start of a security-maintenance cadence, not a task to close.
For teams running third-party MCP servers with large tool catalogues, the exposure is different and arguably larger, because there may be no vendor bulletin. You own the dependency surface. Inventory every server in the path, scan its dependencies, and constrain its Maximo identity to the minimum the exposed tools require. If a server exposes write tools you do not use, that is not a feature sitting idle; it is privilege you are paying for with risk.
For security owners, the ask is to fold the agentic layer into existing controls rather than inventing a parallel process. Identity review, dependency scanning, network segmentation, audit retention, and kill switches are all controls you already operate for other systems. The MCP server should be subject to the same ones, and the gap is usually that no one has declared it in scope. Declaring it in scope is the single highest-value action available.
Bottom line
CVE-2026-90920 did not expose a flaw in Maximo's core. It exposed a maturity gap in the newest layer of the stack, the agentic tooling that everyone has been racing to adopt. That is a fixable kind of problem, and the fix is architectural rather than heroic: map the trust boundary, give every layer a deliberate identity, bound the Maximo service identity to the minimum the tool catalogue requires, contain the network path, and run the operational controls that let you patch, audit, and revoke on a cadence.
The teams that get this right will not be the ones that avoided agentic Maximo until it was mature. They will be the ones that treated the MCP boundary as production infrastructure from the first pilot, so that when the next advisory lands, patching is routine, attribution is instant, and the kill switch is already tested.
The capability is real, the value is real, and so is the surface. Wire the agent in, then harden the door it came through.