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
| Part | Title | Audience | The decision it helps you make |
|---|---|---|---|
| 1 | What Is an AI Agent, Really? | Everyone | Agent, workflow, escalation or automation script? |
| 2 | Prompts, Tools and Context for Maximo Agents | Developers | What exactly the model sees on every turn |
| 3 | RAG Strategies for Maximo Data | Developers | Which retrieval method for which Maximo records |
| 4 | MCP and Tool Design for Maximo | Developers | Native MCP server, Max_mcp or your own; which tools to expose |
| 5 | Securing Maximo Agents | Admins, architects | How much autonomy, behind which guardrails |
| 6 | The AI Layer for Maximo Development | Dev teams | How coding agents learn your house rules and prove their work |
| 7 | Local and Self-Hosted AI for Maximo | Admins, architects | What runs on your hardware and what may go to the cloud |
| 8 | Maximo Agents in Production | Developers, ops | How 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
| Idea | Where it comes from | What it means for Maximo |
|---|---|---|
| Agents only where judgement pays | Cole's "agents vs workflows" teaching | Keep approvals, status rules and calculations in workflow and scripts |
| Context is the product | Context engineering and context rot | Trim what Maximo returns; never dump whole records into the prompt |
| Capabilities over tools | MCP problems and tool design | A handful of well-described tools beats exposing every object structure |
| Assume hostile text | The lethal trifecta | Service request and work log text is untrusted input, always |
| Validate before you trust | The PIV loop and separate reviewers | Agents 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:
- Agentic Engineering for Maximo is the hands-on build companion. Where a playbook part says "build a typed agent" or "evaluate it on closed work orders", the agm post shows the code.
- The IBM Bob series covers one coding agent in depth; Part 6 here is tool-agnostic and links to it for Bob-specific formats.
- The MAS Security Operations series covers securing AI agents and MCP, along with identity and API keys; Part 5 here focuses on design patterns and points to Securing MAS for AI Agents and MCP for the identity, scope and audit detail.
🙏 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
- Cole Medin, YouTube channel: youtube.com/@ColeMedin
- Cole Medin AI Knowledge Base (public, cited per video in each part): github.com/coleam00/cole-medin-knowledge-base
- Dynamous AI Mastery community: dynamous.ai
- Anthropic, "Building effective agents": anthropic.com/research/building-effective-agents
- Model Context Protocol specification: modelcontextprotocol.io
- Simon Willison, "The lethal trifecta for AI agents": simonwillison.net/2025/Jun/16/the-lethal-trifecta/
Series Navigation
The Agentic AI Playbook for Maximo
- Part 0: Series Index: The Agentic AI Playbook for Maximo (you are here)
- Part 1: What Is an AI Agent, Really? A Field Guide for Maximo Teams
- Part 2: Prompts, Tools and Context for Maximo Agents: Designing What the Model Actually Sees
- Part 3: RAG Strategies for Maximo Data: Which Retrieval for Which Records
- Part 4: MCP and Tool Design for Maximo: Fewer, Sharper Tools Beat a 175-Tool Buffet
- Part 5: Securing Maximo Agents: The Lethal Trifecta, Prompt Injection and Guardrails That Hold
- Part 6: The AI Layer for Maximo Development: Rules, Commands, Hooks and Validation for Agentic Coding
- Part 7: Local and Self-Hosted AI for Maximo: A Playbook for Regulated Shops
- Part 8: Maximo Agents in Production: Deployment, Voice in the Field, and Agents That Run While You Sleep
