A Workflow Process Is Now an Agent Tool: What MAS 9.2.7 Filters Out, and Why the Allow List Is the Real Governance Control

Maximo Manage 9.2 can publish an active workflow process as a tool on its MCP server, and a practitioner walkthrough from October 2026 shows the whole path from a workflow description to a tool call. The interesting part is not the publish step. It is the filter that drops the tool, and the empty…

Share

A Workflow Process Is Now an Agent Tool: What MAS 9.2.7 Filters Out, and Why the Allow List Is the Real Governance Control

There is a moment in every agentic Maximo conversation where the architecture diagram stops being useful and somebody asks the only question that matters: what is the agent actually allowed to touch? Most answers are rhetorical. They talk about guardrails, human in the loop and least privilege. Then someone opens a real deployment and finds that the real answer is a filter, a configuration record and a flag on a row in a database table.

A practitioner walkthrough published to IBM Community on 9 October 2026 puts that answer in unusually concrete form. Mohamed Chihaoui, working on IBM Maximo Application Suite 9.2.7 with Manage 9.2.4, AI Service 9.2 and Db2 12.1, publishes an existing workflow process as a Model Context Protocol tool, calls it from the Maximo Assistant, and shows what lands in the database and in an inbox. The publish mechanics take about ten minutes. The governance lesson takes longer.

Three findings in that walkthrough deserve to be treated as design constraints rather than lab notes. First, a workflow process becomes a tool through two separate artefacts, and the description a language model reads is only 100 characters wide. Second, on MAS 9.2.7 the Assistant's agent keeps only the tool types on its allow list, and that list ships holding AI configuration tools, so a tool of type WFPROCESS is silently dropped until somebody adds the type. The evidence is the agent's own log line: Filtered tools | original=19 | filtered=7. Third, a workflow tool returns an empty object unless the process names an object structure and a query template, and a model reads an empty object as nothing found, so a call that started a workflow can be reported as a failure and invite a retry that starts a second one.

Two Records Decide Whether a Workflow Becomes a Tool

Publishing a workflow to an agent is not a development task in the sense that an automation script tool is. There is nothing to write. A workflow process is already packaged business logic: it knows who reviews, who approves and what happens next. Manage 9.2 exposes that logic to an MCP client by attaching a second record to it.

The two artefacts divide the work cleanly. The active workflow process supplies the behaviour, and its description becomes the tool's description, which is the text a language model reads when deciding whether the tool is relevant. The process also supplies the object, which decides which kind of record the tool accepts. Separately, an MCP tool record supplies the switch that publishes the process, a title, and the hints an MCP client sees: whether the tool is read only, and whether it changes data.

Once both exist, Manage exposes the process as a route and as a tool named after the process in lower case with a wf_ prefix. The demo process TEST_WF_1 becomes wf_test_wf_1, which matters when you are reading a log at two in the morning and trying to work out whether the tool you expect is present under a name you did not choose.

Every workflow tool takes exactly one input, and it is required: href, the reference of the record to start the workflow on. For a work order process that is a reference such as /os/mxapiwodetail/_QkVERk9SRC8xMjcz, the same reference the REST API returns. There are no optional parameters, no free text, and no way to pass a site or a status. The tool is a trigger pointed at one record, and everything else about what happens after the trigger lives in the process definition, which is where an auditor would prefer it.

The call starts the workflow as the calling user, exactly as the Route Workflow action does in the application. That carries more weight than it appears to. From the Assistant, the calling user is the signed-in person. From an external MCP client using an API key, it is the integration user behind that key. The same tool, the same arguments, two identities, and therefore two different sets of outcomes on a record the two identities may not both be allowed to touch.

The demo process is deliberately small: TEST_WF_1 has a start, a single task assigned to the person who started the workflow, and a stop. The task has two outcomes and the negative one closes the work order. It is a good first example because starting it changes very little, one workflow instance and one task assignment. When you are proving a delegation path, the first thing you delegate should be something whose blast radius you can describe in one sentence.

Publishing It, and the Two Restarts Nobody Remembers

Workflow Designer has the same two actions that Automation Scripts have, Add/Modify MCP Tool and Delete MCP Tool, at the end of the More Actions list. The walkthrough does not use them. It applies the change as a database script instead, for a reason worth stealing: a script can be reviewed and repeated, while a click in a designer leaves no artefact a change board can read.

The script makes two changes. The first is the description, because the shipped text (TEST_WF_1 a simple wf for testing) tells a language model nothing. The replacement reads: start the review workflow on a work order, creating a review task for the person who starts it. That sentence is written for a reader with no context beyond itself, which is the correct way to think about tool descriptions. The second change is the tool record, inserted into mcptool with the process name, the type WFPROCESS, read only set to 0, a title, and the flag marking it as changing data. The record is honest about what it does, and the annotations an MCP client sees include readOnlyHint: false and destructiveHint: true. Those annotations drive the approval prompt later.

Then comes the step that separates a lab note from an operational runbook. A database script goes around the running server, so nothing on the server knows about it yet. The Manage server pods have to be restarted so that the workflow cache registers the new route, and then the MCP pod has to be restarted so that it reads the new tool list. Two restarts, in that order. That single line is the most useful operational sentence in the guide, because it describes a failure mode that produces no error. Skip the MCP restart and the tool simply is not there. No exception, no partial success, no message naming the stale cache.

The 100 character limit on the process description deserves its own paragraph, because it is the tightest constraint in the design. A model deciding whether to call a tool has the name, the title and the description, and for a workflow tool the description comes from a column that holds 100 characters. That is roughly one sentence, and it has to say what starting the process does while distinguishing this process from every other one that starts on a work order. If your organisation has twelve review workflows, twelve descriptions of under 100 characters each, and a model that has to choose one, the descriptions are the routing logic. They are not documentation. They are the part of the system that decides which business process runs.

There is a second-order consequence. Because the description lives on the process, changing it changes agent behaviour with no code review. The same is true of the tool record's title and the changes data flag. An agentic deployment therefore needs the sort of change control most Maximo teams reserve for automation scripts, applied to configuration rows instead. A diff on a wfprocess row is a behaviour change with a user-visible approval prompt attached.

What the Agent Kept: original=19, filtered=7

The walkthrough's most valuable finding is not about publishing. It is about the filter that runs afterwards. The Assistant's agent keeps only the tool types that appear on its allow list. On MAS 9.2.7 that list holds the AI configuration tools, so a tool of type WFPROCESS is dropped even though the MCP server knows about it. The author added the type to the agent's allow list on the lab system, restarted the agent, and the log then listed the tool among the ones it kept, with the line Filtered tools | original=19 | filtered=7.

Read that line slowly. Nineteen tools were offered to the agent. Seven survived. The other twelve were not broken, not unauthorised at the MCP layer and not absent from the server. They were filtered, because their types were not on a list. The workflow tool is one of the seven in the post-change log, alongside an SQL query script tool and an internal textual data analyzer.

This is the allow list as the real governance boundary, and it has three properties worth naming. It is a configuration artefact in the suite rather than code in the agent, so a security reviewer can read it, diff it and own it. It is type-level rather than instance-level, which means adding WFPROCESS admits every published workflow tool, not the one you had in mind. And it fails closed in the specific sense that an unlisted type produces no error to the model, only an absence.

The walkthrough is careful about status, and the care is justified. Adding the type was a lab change. The agent deployment belongs to the suite's operator, the author found no documented option for the allow list, and the operator can restore its own value. The recommendation is to use the change to learn, and for a real environment to ask IBM Support how custom tools are meant to be enabled for the Assistant in the version you run. That is the correct posture, and it also says something about maturity: the boundary exists and is enforced, but the supported way to move it is currently a support conversation rather than a setting.

There is a distinction hiding in that gap. The tool itself is on the MCP server for any MCP client regardless of what the Assistant's agent allows. The allow list governs one consumer, the Assistant, not the server. If you build an external agent or a script with an API key, the filter does not apply to you, and what applies instead is the identity of the calling user and the rights attached to it. Teams that treat the Assistant's allow list as a control for the whole MCP surface will be surprised by the first external client that connects. The allow list is consumer-side. The server-side control is the caller's security profile.

The practical reading is that a MAS 9.2 deployment now has at least three places where tool exposure is decided: which tool types the MCP server publishes, which types the Assistant's agent accepts, and which records and processes the calling user may act on. A governance review that inspects one of the three is inspecting a third of the question. The log line is the audit evidence for the middle layer, and it is worth capturing on every agent restart as a baseline, because a count that moves from seven to nineteen without a change ticket should page somebody.

The Empty Answer Is the Real Design Defect

The tool worked, the workflow started, and the chat said it found nothing. That is not a paraphrase; it is what the screenshots show, and the author flags it himself. The first call returns {} with no error, in about seven seconds, and the database shows the intended result: one active workflow instance on the work order, one active task assigned to the caller, instance 106 on the demo system with originator and assignee both set to the integration user.

The cause is documented in the same paragraph as the feature. If the process names an object structure and a query template, the tool returns the record in that shape after starting the workflow. If it does not, it returns an empty object, and the proof is in the record's workflow history. For a process that predates the tool, that is the default state. The demo database ships a default work order template, so the fix is one statement: set the object structure to MXAPIWODETAIL and the template name to DFLTWOVIEW on the process. After the restarts, the same call returns the record: work order number, site, description, status and status description, asset, location, failure code and priority.

Then the interesting part. The model was given an empty object and produced a closing sentence saying no information was found, even though the workflow had started. The author's note on the screenshot says the run predates the response template and that the closing sentence is misleading. This is the most transferable lesson in the walkthrough, and it generalises beyond Maximo: an empty success and a genuine absence are indistinguishable to a model that only sees the payload. The model did not hallucinate. It read the only signal it had.

Consider that in production. A planner asks the Assistant to start a review on a work order. The workflow starts, an approval task lands in somebody's inbox, and the chat reports that nothing was found. The user, reasonably, asks again. The second call fails, because starting the same process twice on one record is not allowed, and now the agent reports an error. The user's mental model is that the tool is broken. The workflow history says otherwise. Somewhere in between, an approval task nobody expected is sitting in an inbox, and the work order is in a state the conversation never mentioned.

There are two fixes and they are not equivalent. The first is the response template, a configuration change that makes success legible. The second is discipline in the tool description, which can warn a model and a user about what a successful call looks like. The first is reliable, the second is hopeful. The advice to give the process a response template before letting people use it from the chat belongs in a publish checklist, not a footnote.

There is a broader pattern here that will recur as more of Manage becomes tool-addressable. The MCP layer is honest about actions, with annotations that say a tool changes data, and it is not yet expressive about outcomes. A tool either returns a record or returns nothing, and the meaning of nothing has to be inferred. Until that changes, the burden falls on the people configuring tools to make success visible, which means response templates on workflow tools and deliberate response bodies on script tools.

Approval, Attribution and the Limits of Undo

The Assistant sequence is worth reading as a governance trace. A user types a sentence containing a work order number and a site. The agent plans three steps, uses its query tool first to turn the number into a reference, stops, asks for approval, and after approval runs the tool, with reasoning steps reading approval received, the tool's title, and preparing answer. The database then shows a new active instance on the work order, started by the administrative user in that run, and the review task appears in the Start Center inbox.

Two things in that trace come from the platform rather than the process. The approval prompt comes from the changes data flag on the MCP tool record, not from the workflow definition. Marking the tool honestly is therefore what buys the prompt. A team that marks a write tool as read only to avoid a click has removed its own control. The second is the record lookup. A person supplies a work order number; the tool wants an href. The agent bridged that gap with its query tool, and the advice to test that chain on your own objects is well placed, because the chain has more failure modes than the call itself: site ambiguity, a numbering scheme the query does not handle, or a record the calling user can open in the application but not reach through the object structure the query uses.

Attribution has a subtlety worth emphasis. From the Assistant, the workflow starts as the signed-in user. From an external MCP client, it starts as the integration user behind the API key. The workflow history records the originator, and the assignment goes to that originator when the process is built that way. The audit trail therefore differs depending on which door the call came through, and a review workflow that assumes a human originator will attribute agent-initiated work to a service account. That is not a defect, but it is a decision that should be made explicitly rather than discovered during an audit.

The limits are stated plainly. Starting a workflow is an action: it creates assignments, can send notifications and can change status. The tool cannot undo it. A started workflow is stopped from Workflow Administration, a different application with a different permission set and a different mental model from the chat window. And the record must not already be in that process, because starting the same process twice on one record fails.

Put those limits next to the empty answer and the shape of a support incident becomes clear. A user starts a review twice because the first attempt looked like a failure. The second attempt errors. Somebody stops the duplicate from Workflow Administration, or does not, and the work order carries two instances of a process designed for one. None of that is a platform bug. It is the accumulated cost of an honest write tool with an unexpressive response, used by a person who was told nothing had happened.

Script Tool or Workflow Tool: The Decision That Comes First

The walkthrough includes a comparison that is easy to skim and worth internalising, because it frames the decision that precedes any tool-building work. An automation script tool requires a script, its variables and a tool record. A workflow tool requires a tool record on an existing active process. The script tool is named script_<name> and the workflow tool wf_<process>. The script tool takes whatever variables you declare; the workflow tool always takes one input, the record reference. The script tool answers with whatever the script puts in its response body; the workflow tool answers with an empty object or the record through a query template. The script tool suits reads, calculations and anything custom. The workflow tool suits starting a governed process with assignments and approvals. The security row is the one to read twice: for a script tool, security is whatever the script checks, and for a workflow tool, it is the caller's rights on the record and the process.

That last row is the whole argument. A workflow tool inherits an authorisation model that already exists, has been tested by the application for years, and is visible to the security team where it has always been visible. A script tool inherits nothing. Its authority is the authority of the code, and if the code forgets a check, the tool is a hole. Teams that reach for scripts because scripts feel more like engineering are choosing to rebuild authorisation from scratch and to own every mistake in it.

The corollary is that the workflow tool's narrowness is a feature. It cannot compute, aggregate, transform or query. It starts a named process on a named record as a named user, and the process does the rest. If the requirement is that the agent should be able to do what the Review action does, the workflow tool is the direct expression of that requirement and the smallest possible grant of authority. If the requirement is a summary of the last six months of failures on an asset, no workflow should be involved.

The closing checklist is short enough to use as a gate. The process is enabled and active and can be routed from the application. Its description says what starting it does within 100 characters. An MCP tool record of type WFPROCESS exists and the wf_ name appears in the server's tool list. A direct call with a record reference succeeds and leaves an active instance and an assignment. The agent is allowed to use the tool type, evidenced by its log listing the tool after filtering. Five checks, each with an artefact behind it. The fifth is the one a team will skip, because it means reading a log rather than clicking a page, and it is the one that catches the silent drop.

Practical Implications

For a Manage team standing this up, the sequence that avoids both traps is short. Decide whether the capability is a governed process or a computation, then pick the tool type. Write the 100 character description as routing logic. Mark the tool as changing data and accept the approval prompt as the cost of honesty. Set an object structure and query template before anyone uses the process from chat, so success returns a record instead of an empty object. Restart the Manage pods, then the MCP pod, and verify by direct call before involving the agent. Then read the agent's filtered tool list and record the counts as a baseline.

For security and audit, the control to own is the allow list, and it is type-level and consumer-side. Adding WFPROCESS admits every published workflow tool to the Assistant, so the question is not only which types are allowed but which processes carry a tool record at all. The supported way to change the list is currently an IBM Support conversation, so the change belongs in a change record with a date, an owner and a reason. The external-client path bypasses that control and lands on the calling user's security profile, so any MCP client outside the Assistant needs its own review.

For programme owners, agentic capability in Manage is now expressible as configuration rather than a development project. That is good for cost and bad for discipline, because configuration changes are cheap and easy to make carelessly. A workflow tool costs one row and one description, and it creates a delegated write path a person can trigger with a sentence, audited as a workflow instance attributed to whoever was signed in or to the service account holding the key. Publishing is a decision about delegation, so take it with the process owner, not only the cluster owner.

Bottom Line

Manage 9.2 makes it genuinely easy to hand a workflow to an agent: one tool record, one description under 100 characters, two restarts and a filter to clear. The ease is the reason to be careful. On MAS 9.2.7 the Assistant's agent kept seven of nineteen offered tools because of a type-level allow list that ships holding AI configuration tools, and the only evidence of the drop is a log line. A workflow tool without a response template returns an empty object, and a model reads an empty object as nothing found, so a started workflow can be reported as a failure and retried into a duplicate. Neither problem is exotic. Both are configuration. Both are cheaper to fix before the first user types a sentence than after an approval task appears in an inbox nobody was expecting. The publish is a ten minute job. The decisions around it are the ones that decide whether the delegation is safe.