Your Asset Data Is More Ready for AI Than You Think: Killing the Objection That Stalls Every Agentic Maximo Programme
The most common reason agentic Maximo programmes never leave the pilot is a data-quality objection that rarely survives contact with close inspection. IBM's own position, published in October 2026, is that Maximo asset data is more ready for AI than practitioners assume. This article takes that…
Your Asset Data Is More Ready for AI Than You Think: Killing the Objection That Stalls Every Agentic Maximo Programme
Every agentic Maximo programme in the last eighteen months has died the same quiet death. Not at the architecture review, not at the security assessment, and not at the procurement table, but in a data-quality conversation that nobody wins because nobody has defined what winning looks like. Someone in the room says the asset data is not clean enough for AI, the room nods, and the initiative is deferred to a fiscal year that never quite arrives. The phrase sounds prudent. It sounds like engineering discipline. In practice it is often a deferral dressed as diligence, and it has cost more Maximo AI programmes than any technical obstacle ever has.
IBM pushed back on that reflex directly in October 2026, with a first-party community piece titled "Your asset data is more ready for AI than you think." The timing is not accidental. The same window brought a self-hosted deployment option for IBM Bob, a hardening conversation around the Maximo MCP server, and a security bulletin for the Maximo AI Service. The agentic stack is being governed in public, and one of its three faces is adoption. The vendor is telling its own installed base, in plain language, that the objection holding them back is smaller than they believe.
This article takes that claim seriously rather than repeating it. Data readiness for AI is not a slogan, and it is not a green light to point an agent at production. It is a set of specific requirements that agentic workloads place on data, and those requirements are narrower than the exhaustive cleansing projects that Maximo teams reflexively scope. We will break down what agentic workloads actually ask of asset data, separate the readiness requirements that matter from the ones that are inherited folklore, work through a phased method that starts from the records already in your system, address the governance and security frame that keeps the programme defensible, and close with the practical sequencing that turns a stalled pilot into a running capability. The audience is anyone who has been told their data is not ready and wants to know whether that is true.
What agentic workloads actually require from asset data
The first thing to understand is that an AI agent does not need your data to be perfect. It needs your data to be navigable. The difference between those two requirements is the difference between a five-year cleansing programme and a six-week readiness sprint, and conflating them is the single most expensive mistake in this space.
An agent does not read your asset register the way a person reads a spreadsheet. It queries, filters, joins, and reasons over whatever it retrieves in the context of a specific goal. When an agent is asked to identify work orders that resemble a recurring failure pattern, it does not need every attribute of every work order to be correct. It needs the failure codes to be populated consistently enough that a pattern is detectable, the asset references to resolve reliably, and the date fields to be trustworthy. Those are narrow, checkable properties. They are not the same thing as "clean data," and the failure to distinguish between them is why so many assessments conclude wrongly that the data is unusable.
The second requirement is stable identifiers. An agent that cannot reliably connect a work order to the asset it concerns, and that asset to its location and its parent hierarchy, cannot reason about anything. Referential integrity matters far more to an agent than attribute completeness. A perfectly spelled asset description with a broken asset number is worthless to a query engine, while a terse asset description with a rock-solid asset number is entirely usable. Teams routinely invert this priority, spending months standardizing descriptions while leaving the join keys that agents depend on untouched. The readiness work that pays off is almost always about keys, not prose.
The third requirement is a defined vocabulary for the things the agent must classify. Failure codes, work type codes, status transitions, and criticality bands are the agent's vocabulary. When these are free text, the agent is reduced to fuzzy matching, which produces plausible-sounding output with unreliable grounding. When these are controlled lists, the agent becomes genuinely useful, because it can group, count, and rank. Here is the important part: you do not need historically perfect coding to get value. You need a controlled vocabulary going forward and a bounded backfill on the specific fields the agent will use. That is a project measured in weeks for a well-scoped domain, not years.
The fourth requirement is provenance and timeliness. An agent operating on stale data produces confidently wrong recommendations. If the agent's view of asset condition is a data warehouse snapshot that refreshes monthly, and the operational reality changes daily, the agent is reasoning about a different plant than the one that exists. Readiness requires knowing, for each data domain the agent touches, how current it is and where it came from. This is a metadata question more than a data-quality question, and it is often answerable in days once someone is asked to answer it explicitly.
The fifth requirement, and the one teams most often skip, is a defined boundary of what the agent is allowed to conclude. A readiness assessment that does not state which decisions the agent will support, and which it will only inform, is not an assessment. Data can be ready for a recommendation that a planner reviews and unready for an automatic action that changes a work order. Readiness is therefore relative to the task, not absolute. Framing it any other way guarantees an argument you cannot win.
Separating real readiness gaps from inherited folklore
Maximo teams carry a set of beliefs about their own data that are so widely repeated they are rarely examined. Most of them are half true, which is why they persist. The useful move is to sort them.
The first piece of folklore is that descriptions must be standardized before AI can work. This is generally false for analytical workloads. An agent grouping duplicate assets or detecting recurring failures works from identifiers and codes, not from free-text prose. Description standardization improves human readability and search quality, both of which are valuable, but neither is the gate on agentic readiness. If description hygiene is your stated blocker, you are probably optimizing the wrong variable and stalling for the wrong reason.
The second is that duplicate assets make AI useless. This is partly true and mostly overstated in its scope. Duplicate asset records degrade aggregate reporting and inflate counts, which does matter for a reliability agent that ranks assets by failure frequency. But the correct response is not a full deduplication programme before any AI work begins. It is to scope the agent to a domain, hierarchy level, or site where duplicates are manageable, deliver value there, and let the demonstrated value fund the cleanup. Duplicates are a reason to narrow scope, not a reason to stop.
The third is that missing historical records prevent model training. This confuses training your own model with using a foundation model. An agent built on a general-purpose model does not require a training corpus from your Maximo instance. It requires retrieval-ready data at inference time. If you are not training a custom model, historical completeness is far less critical than current accuracy. Teams that assume they are missing the training data often find they never needed it, because the workload was retrieval and reasoning, not supervised learning.
The fourth is that data quality must be perfect before the agent touches production. This is the most dangerous belief because it sounds like rigor. In practice, no production Maximo environment has perfect data, and waiting for perfection means waiting forever. The defensible position is a bounded agent in a scoped domain operating in read-mostly mode with human review of its output, expanding as evidence accumulates. That posture delivers value while the long tail of data issues is resolved at a pace that does not block the programme.
The fifth is that cleaning data is a prerequisite to measuring readiness. It is the reverse. Measuring readiness is a prerequisite to cleaning data, because without a measurement you cannot know which fields are actually load-bearing for the agent's task. A readiness assessment is cheap, fast, and produces the exact list of gaps worth fixing. Skipping it and jumping straight to cleansing is how teams spend a year fixing fields no agent would ever query.
A phased readiness method that starts from the data you have
The practical answer to the data objection is not an argument, it is a method. What follows is a sequencing that a Maximo team can run without a data-warehouse rebuild, without a multi-year cleansing contract, and without waiting on a perfect source of truth.
Phase one is task definition. Before touching data, write down the specific decisions the agent will support, in the language of the business. Not "improve maintenance" but "recommend a preventive maintenance interval adjustment for a given asset class based on failure history." The level of specificity is the point. A vague task produces a vague readiness requirement, which produces an endless argument. A specific task produces a specific data list, which produces a finite assessment.
Phase two is field mapping. For each defined task, list the exact Maximo objects and fields the agent must retrieve to produce a grounded answer. For a PM interval recommendation, that is likely asset, asset classification, work order, work order status, failure code, and the relevant date and meter fields. This list is usually twelve to twenty fields, not hundreds. The number is small because the task is specific, and it is the direct payoff of phase one.
Phase three is honest profiling on that field list alone. For each field in the mapped set, determine fill rate, value distribution, whether values come from a controlled list or free text, and referential integrity against the join targets. This is a matter of running targeted queries against Maximo, not building an enterprise data-quality dashboard. The output is a short table showing, field by field, whether the agent has what it needs. Most teams find that the majority of mapped fields are usable and a small number are genuinely blocking, which reframes the whole conversation from "our data is bad" to "we have six fields to fix."
Phase four is vocabulary closure. For the classification fields the agent depends on, define or formalize the controlled list, and backfill the bounded historical set the task actually requires. If the task looks at the last twenty-four months of a specific asset class, backfill twenty-four months for that class. You are not coding the entire work order history, and you are not standardizing every failure code in the platform. You are closing the vocabulary for the domain in scope, which is a bounded and achievable effort.
Phase five is a read-only pilot. Stand the agent up against the mapped, profiled, vocabulary-closed domain in a mode where it retrieves and recommends but changes nothing. Measure the quality of its recommendations against planner judgment. This phase produces the evidence that the data is or is not sufficient, using the agent itself as the test rather than a cleansing project as a proxy. It also produces the confidence required to expand scope responsibly.
Phase six is governed expansion. Grow the task list and the domain incrementally, each new task triggering its own field mapping and profiling loop. The method scales because it is task-driven rather than platform-driven, and each increment carries its own bounded data work rather than an unbounded platform-wide obligation.
Governance, security, and the frame that keeps the programme defensible
Readiness is not only about data quality. A programme that treats it that way will pass its data assessment and fail its first security review, because the governance frame is what makes agentic Maximo defensible in a regulated environment, and it is what convinces an executive sponsor to sign.
The first governance element is identity. The Maximo identity the agent server operates as determines the entire blast radius of a misbehaving agent, and this is a data-adjacent decision because it constrains which records the agent can even see. A read-only identity scoped to the domain in scope is the correct starting posture. It bounds the agent's reach to the mapped fields and objects, and it produces an audit trail that ties every action to a defined principal rather than a shared service account. This single decision converts an abstract data-readiness conversation into a concrete, reviewable access control.
The second element is the security backdrop, and it must be referenced honestly. The Maximo AI Service security bulletin from early October 2026 disclosed vulnerabilities in the very layer that connects agents to the platform, remediated in later releases. Any agentic Maximo programme that does not acknowledge this is presenting a capability story without its risk story, and both sponsors and security reviewers will notice the omission. The correct posture is to state the current remediated version as a baseline requirement, to keep the agent layer on its supported patch level, and to treat the integration boundary as production infrastructure with an explicit threat model. Data readiness and security readiness advance together, and a programme that measures one without the other is only half assessed.
The third element is change control over the data the agent uses. Once an agent's recommendations carry weight, the fields it reads become operationally significant, and changes to those fields, their controlled lists, or their integration sources can silently degrade agent quality. Readiness therefore includes a lightweight monitoring obligation: track the mapped fields' fill rates and vocabulary drift over time. This is not a new platform, it is a periodic report on the same short field list from the assessment. It closes the loop between the initial readiness picture and the ongoing reality.
The fourth element is human accountability. An agent that recommends a maintenance interval change is producing an input to a decision, not making the decision, and the readiness assessment should make that boundary explicit. This is what allows a team to start with imperfect data without taking on unacceptable risk, because a human reviews the recommendation before it becomes an action. As evidence accumulates and the agent's quality proves out, the human-in-the-loop can be relaxed for narrow, well-understood cases, but the relaxation should be an explicit governance decision rather than an accidental erosion of oversight.
Together, these four elements produce a programme that can start now, on the data you have, without pretending the data is flawless and without overstating the capability. That is the posture that survives a security review, an audit, and a skeptical executive.
Practical implications
The immediate implication for a stalled Maximo AI programme is that the blocker is probably smaller than it was described as. Most teams that have concluded their data is unready have never actually measured readiness against a specific task. They have asserted it, usually based on general impressions of platform-wide data quality rather than a field-level assessment for a defined workload. The first practical step is therefore not a cleansing initiative but a single scoping conversation that produces a task definition, followed by a field-level profiling exercise on the resulting short list. That exercise typically takes days and often reframes the entire debate.
For Maximo data owners, the implication is a shift in what "readiness" means operationally. Readiness is task-relative, measured, and bounded, not absolute and unbounded. A field list of twenty keys for a defined decision is a tractable ownership object. An undefined mandate to "clean the data" is not, and it is why such mandates never finish. Data owners should expect to be asked for specific, answerable questions: what is the fill rate on this field, is it controlled or free text, does it join reliably. Those questions can be answered with targeted SQL against Maximo, and they produce an artifact the whole programme can act on.
For programme sponsors, the implication is that funding a readiness assessment is a better first investment than funding a remediation project. The assessment produces the remediation list and the evidence that the list is worth funding. Reversing that order, funding remediation before measurement, is how organizations spend heavily on fields no agent will ever read. Sponsors should also insist that the programme's governance frame, identity posture, security baseline, and human review boundary, is defined before scale, because those elements are what make expansion safe and what keep the initiative defensible when it reaches an executive review.
For architects and integration teams, the implication is that the data-readiness conversation and the security conversation are the same conversation. The identity the agent runs as, the fields it can retrieve, and the patch level of the integration layer are a single design decision set. Treating data readiness and security readiness as separate workstreams produces a programme that passes one review and fails the other. The teams that move fastest define the task, map the fields, scope the identity, take the security baseline, and run the read-only pilot as one coherent exercise.
Bottom line
The data-quality objection has stalled more agentic Maximo programmes than any genuine technical limitation, and IBM's own position, published in October 2026, is that the objection is overstated for the workloads Maximo teams are actually attempting. The reason is structural: agents need navigable, stable, vocabulary-controlled, timely, and bounded-scope data, and those requirements are narrower than the platform-wide perfection that teams reflexively scope. The conflation of the two is the mistake that produces five-year cleansing plans for twelve-field problems.
The path forward is a method, not an argument. Define a specific task, map the dozen or so fields it requires, profile those fields honestly, close the vocabulary for the domain in scope, and run a read-only pilot that uses the agent itself as the readiness test. That sequence starts from the data you already have and produces evidence rather than opinion. It also aligns naturally with the governance frame that keeps the programme defensible: a scoped identity, a supported security baseline, monitored key fields, and a human reviewing the output.
Maximo teams that wait for perfect data will not start. Teams that measure readiness against a real task will usually find the gap is small, fixable, and no reason to delay. The objection sounds like diligence, but diligence is a measurement, and the measurement is cheap. Run it, and let the data tell you what it actually needs instead of letting a room of assumptions decide the programme is not ready.