The Agentic AI Playbook for Maximo: Series Index

📺 Source credit: The concepts in this series are adapted from Cole Medin's YouTube channel (youtube.com/@ColeMedin) and the Dynamous AI Mastery community (dynamous.ai), and applied to IBM Maximo by TheMaximoGuys.
🎯 Who this is for: Maximo administrators, functional consultants, developers, architects and technical leads who want one coherent way to think about AI agents around Maximo, from "what is an agent?" to "how do we run one in production without regretting it?"

Series: 8 parts plus this index | Total read time: about 4.5 hours

🎯 Why This Series Exists

Every Maximo conversation in 2026 now has the word "agent" in it. IBM ships Maximo Assistant and a native MCP server in MAS 9.2. Vendors demo agents that triage work orders, write automation scripts and reorder spares. Your own developers are using Claude Code, IBM Bob or Codex on the customisation repo. And yet most teams still lack a shared mental model: when is an agent the right tool, what does it need to see, how does it reach Maximo data safely, and who is accountable when it is wrong?

Cole Medin has spent several years teaching exactly that mental model on his YouTube channel and in the Dynamous community, across hundreds of videos on agents, context engineering, RAG, MCP, security, local AI and agentic coding. His material is general-purpose. This series does the translation work: it takes each layer of that playbook and asks what it means for a system of record that holds your asset hierarchy, your safety plans and your maintenance history.

The result is not a product tour. It is a set of decisions, each grounded in a Maximo scenario, with the reasoning shown so you can disagree with it on your own site's facts.

🧭 How to Read It

There are three sensible paths through the series.

  • Leaders and functional consultants: read Parts 1, 5 and 7. You will come out able to say which Maximo jobs are agent-shaped, what the security risk actually is, and whether your data can leave the building.
  • Developers building runtime agents: read Parts 1 to 5 in order, then 8. Jump to the Agentic Engineering for Maximo build posts whenever you want working code.
  • Development teams adopting coding agents: start with Part 6, then read Parts 2 and 5 for the prompt and security background.

Most parts open with a short version and end with worked Maximo scenarios, a pitfalls list, five FAQs and references back to the specific Cole Medin videos that the ideas come from.

📊 The Series at a Glance

PartTitleAudienceThe decision it helps you make
1What Is an AI Agent, Really?EveryoneAgent, workflow, escalation or automation script?
2Prompts, Tools and Context for Maximo AgentsDevelopersWhat exactly the model sees on every turn
3RAG Strategies for Maximo DataDevelopersWhich retrieval method for which Maximo records
4MCP and Tool Design for MaximoDevelopersNative MCP server, Max_mcp or your own; which tools to expose
5Securing Maximo AgentsAdmins, architectsHow much autonomy, behind which guardrails
6The AI Layer for Maximo DevelopmentDev teamsHow coding agents learn your house rules and prove their work
7Local and Self-Hosted AI for MaximoAdmins, architectsWhat runs on your hardware and what may go to the cloud
8Maximo Agents in ProductionDevelopers, opsHow to deploy, observe, voice-enable and schedule agents

🗺️ What Each Part Gives You

Part 1, What Is an AI Agent, Really? defines an agent by its four components (model, instructions, tools, memory) and its reason-act-observe loop, then sets it beside the deterministic tools Maximo already has: workflow, escalations and automation scripts. The centrepiece is a decision table for "agent, workflow or autoscript?" and a list of Maximo jobs that are genuinely agent-shaped, such as service request summarisation and work order triage, against those that should stay deterministic.

Part 2, Prompts, Tools and Context is about the three things a runtime agent reads on every turn: the system prompt, the tool descriptions and the data the tools return. It shows a dynamic system prompt that carries the user's site, org and security context, tool docstrings over Maximo object structures, oslc.select diets that stop a 200-attribute work order from rotting the context window, and a structured output schema for triage.

Part 3, RAG Strategies for Maximo Data starts from a blunt rule: structured Maximo data should be queried live, not embedded. It then matches strategies to the narrative data that does deserve retrieval (long descriptions, work logs, job plans, OEM manuals, attachments): keyword search for part numbers and asset tags, hybrid search with rank fusion, hierarchical RAG for manuals, and re-ingestion when a record changes. Asset and location hierarchies stay relational: a recursive SQL or OSLC query answers most hierarchy questions, and a knowledge graph is added only when cross-entity questions earn its cost. Site, org and other metadata filters on every chunk serve as both the security model and the precision tool.

Part 4, MCP and Tool Design explains the Model Context Protocol in Maximo terms, compares the MAS 9.2 native MCP server with TMG's Max_mcp and a home-grown server, and makes the case for fewer, sharper, read-mostly tools. It covers tool naming, input schemas, safe oslc.where handling, pagination, idempotent writes and when skills or code execution beat MCP.

Part 5, Securing Maximo Agents maps the lethal trifecta (private data, untrusted content, a way to send data out) onto work orders, service requests, vendor email and communication templates. It walks through a prompt injection that arrives in a service request and builds an eight-layer defence, from one identity per agent to approval enforced inside Maximo workflow and audit.

Part 6, The AI Layer for Maximo Development turns to coding agents. It shows how a team builds rules, commands, skills and hooks on top of a Maximo customisation repo so that Claude Code, IBM Bob or Codex writes automation scripts, Java extensions, DBC scripts and MAF apps the house way, and validates them against a development Manage instance before a human reviews them.

Part 7, Local and Self-Hosted AI is for utilities, nuclear operators, defence and public-sector teams. It maps privacy tiers onto Maximo data, gives a per-component local-versus-cloud decision tree, sizes GPUs next to MAS on OpenShift, explains the context-window trap with long work order histories, and models when self-hosting becomes cheaper than paying per token.

Part 8, Maximo Agents in Production closes the loop: packaging an agent as a container and API next to MAS, per-user identity, observability and cost per run, a hands-free voice agent for technicians reading job plans and safety plans, proactive agents triggered by schedules and publish channels (including Kafka-backed publish channels), long-running agent loops with fresh context, durable state and a human gate, and a production readiness checklist. It ends with a learning path for what to study next.

🧱 Five Ideas That Hold the Series Together

IdeaWhere it comes fromWhat it means for Maximo
Agents only where judgement paysCole's "agents vs workflows" teachingKeep approvals, status rules and calculations in workflow and scripts
Context is the productContext engineering and context rotTrim what Maximo returns; never dump whole records into the prompt
Capabilities over toolsMCP problems and tool designA handful of well-described tools beats exposing every object structure
Assume hostile textThe lethal trifectaService request and work log text is untrusted input, always
Validate before you trustThe PIV loop and separate reviewersAgents propose; tests, reviewers and Maximo workflow decide

The same five ideas appear in every part, viewed from a different layer of the stack.

🔗 How This Fits With Our Other Series

This playbook sits between three existing TMG series:

🙏 Credits

The agentic concepts in this series (the agent loop, context engineering, the PIV loop, the AI Layer, agentic RAG, the problems with MCP servers, the lethal trifecta as Cole presents it, local AI cost crossover and many more) are Cole Medin's teaching, from his public YouTube channel and the Dynamous AI Mastery community. We explain them in our own words, credit the specific videos in each part, and add the Maximo translation. Any mistakes in applying them to Maximo are ours.

Key Takeaways

  • Most Maximo work should stay deterministic; use an agent only where judgement over messy text pays for the risk.
  • What the model sees decides what it does: lean prompts, sharp tool descriptions and trimmed OSLC payloads matter more than model size.
  • Query structured Maximo data live, embed only narrative text, and filter every retrieval by site, org and security group.
  • Expose few, sharp, read-mostly tools, whatever MCP route you choose.
  • Treat Maximo text as potentially hostile, and keep approvals inside Maximo workflow with full audit.

References

  1. Cole Medin, YouTube channel: youtube.com/@ColeMedin
  2. Cole Medin AI Knowledge Base (public, cited per video in each part): github.com/coleam00/cole-medin-knowledge-base
  3. Dynamous AI Mastery community: dynamous.ai
  4. Anthropic, "Building effective agents": anthropic.com/research/building-effective-agents
  5. Model Context Protocol specification: modelcontextprotocol.io
  6. Simon Willison, "The lethal trifecta for AI agents": simonwillison.net/2025/Jun/16/the-lethal-trifecta/

Series Navigation

The Agentic AI Playbook for Maximo