MREF Is Not TRIRIGA Anymore: The Translation Table Every Maximo Manage Team Needs Before the Rebranding Bites

Maximo Real Estate and Facilities looks like Maximo Manage with different labels, and that assumption is what breaks reliability programmes during migration. This article builds the full vocabulary translation table from Manage to MREF, then shows where the mappings hold, where they silently…

Share

MREF Is Not TRIRIGA Anymore: The Translation Table Every Maximo Manage Team Needs Before the Rebranding Bites

Maximo Real Estate and Facilities occupies an unusual position in the Maximo Application Suite portfolio. It is, on paper, the product formerly known as TRIRIGA, folded into the Maximo Application Suite brand and renamed so that its family resemblance to Maximo Manage is visible at a glance. That renaming has done exactly what renamings do: it has convinced a large number of Maximo professionals that MREF is Manage with a real-estate accent, a product they can reason about using the vocabulary they already have. That assumption is comfortable, defensible in a meeting, and dangerous in a reliability programme.

The danger is specific. Reliability work depends on a chain of definitions that must survive translation intact: an asset is a thing you maintain, a location is where it sits, a work order is an authorization to spend labor, a preventive maintenance record is a schedule that generates that authorization, and a job plan is the procedural content telling a technician what a compliant job looks like. In Maximo Manage that chain is expressed in one vocabulary. In MREF it is expressed in a different one, and the differences are not cosmetic. Work orders become work tasks. Preventive maintenance records split into job plans plus PM schedules, two objects where Manage had one. Job plans become procedures. The word "job plan" means a different thing in each product, which means that any sentence containing the phrase "the job plan" is now ambiguous, and any migration script that assumes a shared meaning is wrong in a way that will not throw an error.

The community documentation arriving through October has made this collision unusually visible. A sustained IBM Community series covering MREF on MAS 9.2 sample data has walked through the Admin Console object by object, the four doors available for moving data in and out, and the maintenance model of work tasks, job plans and procedures. That series is, in effect, a free migration curriculum, and it is worth treating as the authoritative vocabulary source rather than as background reading.

This article is for the Maximo Manage team that has been told MREF is coming, or that is being asked to assess it. We will build the translation table from Manage to MREF in full, section by section, at the level of reliability semantics rather than UI labels. We will examine where the mappings are clean, where they preserve structure but not behaviour, and where the reliability guarantees that Manage teams rely on quietly evaporate. We will look at the admin model, where cron tasks become agents and the scheduling assumptions change. We will cover the four integration doors and what each one means for bulk data loading during a migration. And we will close with the re-verification checklist that a reliability engineer should run over any converted regime before it is allowed to generate work against real assets. If your organization is considering MREF on the strength of "it is Maximo," this is the article that tells you which parts of that sentence are true.

The Vocabulary Collision: Work Orders, Work Tasks, and the Job Plan Ambiguity

The first place a Manage team gets into trouble is the word "job plan," because it is the one term that appears in both vocabularies with different meanings. In Maximo Manage, a job plan is a reusable template describing how to perform a type of work: a sequence of tasks, each with labor, materials, tools, and services estimated, potentially linked to a safety plan or a set of associated documents. A preventive maintenance record in Manage references a job plan, defines a frequency, and generates work orders on schedule. The relationship is one template to many generated authorizations.

In MREF, the object that behaves most like a Manage job plan is called a procedure. A procedure holds the step-by-step content, the sequencing, and the resource estimates. The object called a job plan in MREF is the scheduling construct, the thing that defines when work recurs and what it produces, and it is paired with PM schedules rather than being a standalone template. So the Manage concept splits: the content goes to the procedure, the schedule goes to the job plan plus PM schedule. A migration script written by a team that reads the MREF documentation quickly and maps "job plan to job plan" will collapse procedural content and scheduling logic into a single object, and the resulting system will look populated while being structurally wrong.

Work orders present the second collision, and here the mapping is cleaner in structure but has a reliability consequence. A Manage work order is a single object carrying the authorization, the plan, the labor, the materials, the status history, and the reporting. MREF's equivalent object is the work task, and it sits inside a work-task hierarchy. The hierarchy is the important detail. In Manage, a multi-task job expresses its structure through the relationship between a work order and its tasks, with the work order remaining the primary accounting and closure object. In MREF, the hierarchy is more explicit and the parent-child arrangement carries more of the semantic load. A reliability programme that measured schedule compliance by counting closed work orders now has to decide, explicitly, which level of the work-task hierarchy counts as one unit of completed work.

The third collision is the one most likely to be missed because the vocabulary does not change at all: locations. Both products have locations, and the word is the same, so nobody audits it. But MREF is a real-estate and facilities product at its core, and its location model reflects buildings, floors, rooms and spaces as first-class concerns in a way that a plant-centric Maximo Manage deployment does not. A reliability programme that modelled functional locations as a maintenance hierarchy now finds a location model optimized for space management. The mapping is not impossible, but it must be deliberate. In practice, teams need to decide early whether the reliability hierarchy will live in locations, in the asset hierarchy, or in a hybrid, because the preventive maintenance logic hangs off that decision.

Three collisions, then: job plan meaning, work order versus work-task hierarchy, and location semantics. Each one is discoverable in advance. Each one, if missed, produces a system that passes a data-count check and fails a reliability audit.

Where the Mapping Holds and Where It Silently Diverges

Having named the collisions, it is worth being precise about which parts of the Manage model survive translation intact, because over-warning is as harmful as under-warning. A team that decides MREF shares nothing with Manage will rebuild from scratch, waste months, and discard a mature maintenance regime that could have been carried over with targeted work.

Asset records map well. The core notion of an asset, with its identifiers, its status, its location, its parent-child relationships and its classification, is recognizable in MREF and can be carried over with a well-constructed data load. Classification matters here: a Manage deployment that used classification hierarchies to drive maintenance strategy has the information needed to preserve that strategy in MREF, provided the classification values are loaded before the maintenance records that depend on them. Order matters more than most teams expect, and it matters for exactly the reason reliability engineers care about: a preventive maintenance schedule that lands before its classification is available will either fail to generate or generate against the wrong asset set.

Meters and condition-based triggers are where the divergence begins in earnest, and it is a divergence of degree rather than of kind. Manage supports meters, meter readings, and the use of those readings in maintenance logic, and MREF supports measurement in its own idiom. The question a reliability team must ask is not whether the capability exists but whether the specific trigger pattern they built still evaluates the same way. A Manage configuration might generate a preventive maintenance record when a meter crosses a threshold, or when a rolling average of readings crosses a threshold over a window. Those are different reliability semantics. When migrating, each trigger must be re-expressed and re-tested, and the test must include the case where the meter reading is missing, because the behavior of an unknown reading in a trigger expression is exactly the kind of detail that differs between products.

Failure codes and failure reporting deserve separate attention, because they are the data foundation of any reliability improvement programme. Both products accommodate structured failure reporting, and a Manage deployment that invested in failure code hierarchies has real intellectual property in that structure. The risk in migration is not loss of the codes but loss of the relationships between codes and the maintenance records that used them. If failure data lands in MREF disconnected from the work history it was meant to explain, the reliability programme loses its trend lines and starts again from zero. The mitigation is sequencing again: load failure code structures first, map every historical record that carried a failure code, and verify the counts match on both sides before declaring the load complete.

The honest summary of this section is that structure carries, semantics need verification. Assets, classifications, and inventory-like reference data travel well. Schedules, triggers, hierarchies, and failure relationships are the categories where a converted record can be structurally valid and behaviorally wrong, which is the worst possible failure mode because it does not announce itself.

The Admin Model Shift: Cron Tasks, Agents, and Scheduling Assumptions

For a Maximo Manage administrator, the MREF Admin Console is the section that produces the strongest sense of dislocation. Manage administrators understand their system's background behavior as a set of cron tasks: database-level jobs, escalation routines, scheduled integration processing, and application-level timers, all of which can be inspected in familiar administrative interfaces and reasoned about in terms of database time, application server time, and cluster behavior. The mental model is a set of timers attached to a database.

MREF's admin model is described in terms of agents. There are agents responsible for workflow, for data connectivity, and for other aspects of background processing, and they are managed as distinct components rather than as database rows in a task table. The practical consequence for an administrator moving from Manage to MREF is that familiar questions acquire new answers. Where in Manage you would ask which cron task is responsible for a behavior, in MREF you ask which agent owns it. Where in Manage you would troubleshoot by looking at the task history table, in MREF you troubleshoot by inspecting agent state. The knowledge transfers at the level of "something schedules things and it can be inspected," and it does not transfer at the level of specific tooling.

This has a reliability consequence that is easy to underestimate during a migration project. Preventive maintenance generation is a scheduled activity. If the mechanism that generates work from schedules behaves differently, or is scheduled on a different cadence, or is subject to different failure modes, then the reliability team's assumption that "PMs always generate on their due date" is no longer safe. The right response during migration is to observe the generation behavior directly, in a test environment, over a period long enough to see several generation cycles, and to compare the observed pattern against what Manage delivered. A one-day smoke test will not reveal a cadence difference that only manifests weekly or monthly.

There is also a version and upgrade dimension that reliability leads should track. The MREF deployment referenced across the community series is running Application 9.2.2 on platform 9.2.6, having been upgraded from 9.1.2 in mid-September. That upgrade history is informative: MREF is on the same upgrade treadmill as the rest of the Maximo Application Suite, and its behavior can change under you between patch cycles. For a reliability programme that depends on generation cadence, that means the admin model is not a one-time migration concern but an ongoing operational one. Any converted MREF deployment needs generation monitoring added to the operational runbook, with an alert when the expected volume of generated work deviates from the historical baseline.

The broader point for administrators is that MREF should be treated as a product with its own operational discipline, not as a Manage instance with different screens. Budgeting the admin learning curve explicitly is the difference between a migration that stabilizes in weeks and one that limps for a quarter.

The Four Doors: Getting Data In and Out During a Reliability Migration

Bulk data movement is where migration projects succeed or quietly produce corrupted hierarchies, and MREF offers four distinct routes for getting data in and out. Understanding them as four doors, each with its own suitability and its own failure modes, is more useful than the common practice of picking whichever one the team used last time.

The first door is the Data Integrator, which is the loading mechanism intended for bringing data into the product in bulk. It is the natural route for large one-time loads during migration: assets, locations, classifications, reference data. Its strength is volume. Its risk is that a bulk load expresses structure perfectly and semantics not at all: you can load ten thousand assets that are individually valid and collectively nonsense if the hierarchy relationships were not resolved in the staging data before loading.

The second door is integration objects, which provide the object-level interface used for programmatic data movement. This is the route that integration developers will recognize, and it is the right door for ongoing synchronization once the initial load is complete. During migration it is often used for incremental reconciliation: load the bulk in the first pass, then use integration objects to close gaps and to keep the two systems aligned during a parallel-run period.

The third door is DataConnect, the connectivity component that handles the plumbing between MREF and external systems. In a reliability migration this door matters most when the organization is running a period of dual operation, with maintenance records being created in both the old and the new system. Keeping the two coherent is a data-connectivity problem, and the failure mode is divergence: records updated in one system and not the other, producing a work history that reconciles to neither.

The fourth door is OSLC, the standards-based interface that exposes MREF resources in a way external tools can query. In the Manage world, the analogous route is the REST and OSLC API surface. For reliability teams, OSLC has a specific value during migration: it is the cleanest way to extract existing maintenance history for analysis and re-load preparation, because it exposes the data model without requiring direct database access. It is also, importantly, the door that third-party tooling most often uses, which connects this section to the broader ecosystem question of what else is querying your system.

A concrete lesson from community documentation of real MREF loads is instructive: a load of a moderate number of rooms, in a facilities context, is enough to expose ordering problems in the staging data. The reliability analogue is direct. If a migration of a few dozen rooms takes careful sequencing, a migration of tens of thousands of reliability-significant assets cannot be done in a single unplanned pass. The practical method is phased: reference data, then hierarchies, then assets, then maintenance records, with a verification count and a spot-check at each phase boundary. Each phase must be verified independently, because a defect in phase two will make phase four look correct while it generates work against the wrong structure.

Re-Verifying a Converted Maintenance Regime Before It Generates Real Work

Everything above converges on a single operational question: how does a reliability engineer decide that a converted MREF maintenance regime is safe to turn loose on real assets. The answer is a structured verification pass, run deliberately and documented, rather than an acceptance test that checks that records exist.

The first verification is hierarchy integrity. Load the asset and location structures, then walk a representative sample of paths from the top of the hierarchy to a leaf, in both the source and target systems, and confirm they match node for node. Sampling must be stratified: pick paths in dense branches, in sparse branches, and at the boundary where the location model and the asset model meet, because that boundary is where the Manage and MREF models diverge most.

The second verification is schedule semantics. For a sample of preventive maintenance records, compare the generation behavior between source and target over a full interval of the schedule, not over a shortened test interval. Confirm that the generated unit of work is the same unit of work, in the work-task hierarchy sense, and that the procedural content attached to it is the same content. This is where the job plan and procedure split either proves correct or exposes a mapping error.

The third verification is trigger behavior for condition-based maintenance. Exercise each trigger pattern with real, plausible data, including the boundary cases: reading exactly at the threshold, reading absent, reading stale. Record the resulting behavior for both systems and compare. Divergence in a boundary case is a genuine finding, not a nitpick, because production data lives at boundaries.

The fourth verification is failure-data integrity. Count failure codes in the source, count mapped failure codes in the target, and reconcile. Then follow a sample of historical records that carried a failure code all the way into the target and confirm the relationship survived. A reliability programme's trend analysis depends entirely on this link, and it is the single easiest thing to lose in a bulk load that prioritizes record counts over relationships.

The fifth verification is generation monitoring, set up before go-live rather than after. Establish the expected volume of generated work per cycle from historical Manage data, configure an alert in MREF when the observed volume deviates materially, and confirm the alert fires in a test. A reliable migration is one whose failures are visible, and this step is what makes them so.

Building the MREF Competency Instead of Borrowing It

The pattern across every section above is the same: MREF is legible to a Maximo Manage team, which is precisely what makes it risky. Legibility invites assumption, and assumption during a reliability migration produces systems that look complete and behave incorrectly.

The constructive response has three parts. First, treat the vocabulary translation as a deliverable in its own right. Write the Manage-to-MREF mapping down, object by object, including the definitions that change and the ones that do not, and make it the reference document for the whole migration. Second, sequence the data movement deliberately through the four doors, verifying at each phase boundary rather than at the end, because end-of-project verification cannot distinguish a hierarchy defect from a loading defect. Third, build internal competency rather than importing it wholesale, because the community material now available, from the Admin Console walkthrough to the maintenance model and the integration guide, is genuinely sufficient to make a Maximo team self-sufficient in MREF if they take the time to read it as a specification rather than as a summary.

For reliability engineers specifically, the operative principle is that a maintenance regime is a set of claims about how assets fail and how work prevents failure. Migrating between products does not change those claims, but it does change how they are expressed, and any expression error invalidates the claim. The translation table is not administrative housekeeping. It is how the claims survive.

Maximo Real Estate and Facilities may carry the Maximo name, but it is its own product, with its own object model, its own administrative mechanics, and its own integration surface. Teams that respect that will find a capable platform and a manageable migration. Teams that treat it as a rebranded Manage will find out, eventually, in a work order that generated against the wrong asset for the wrong reason. The translation table is cheap. Discovering it after go-live is not.