Overview

When you're working a ticket, you often need to dig up related information, write up a resolution, or update a few fields — all before you can move on. Neo is a chat-based AI assistant, built into the Neo panel on every data card, that can do some of that legwork for you. Ask it a question in your own words, and it can look things up and even make changes to Pro ESM data on your behalf — always showing you what it's doing, and always asking for your approval before it creates or changes anything.

What you can do with Neo

• Ask in your own words. No need to remember exactly which button to click — just describe what you need, like "create a KB article related to this ticket" or "update this ticket's status."
• Get things done without switching screens. Neo can look up related tickets, people, or knowledge articles, and take action directly from the chat — drafting a resolution, filing a KB article, or updating a field.
• Stay in control. Neo never creates or changes anything without showing you exactly what it plans to do first and waiting for your approval.
• Keep using what you already know. The existing one-click AI Actions (Summarize, Next Steps, Create resolution, and so on) are still there in the chat box — they help users to trigger common actions and get started quickly

Use case examples

Preparing and Resolving Incidents

Open a new incident — for example, a customer reporting that their laptop keeps crashing with a blue screen — click Ask Neo, and type a single request: "Prepare and resolve ticket." In under a minute, Neo reads the ticket, looks through the knowledge base, and finds a published article that matches the symptom (here, a blue-screen crash caused by an outdated display driver). It then does the preparation work an agent would normally do by hand across several fields.

Neo shows what it wants to change on an approval card before saving anything:

• Routing — moves the ticket from Service Desk Level 1 to Service Desk Level 2 and picks an assignee.
• Priority and classification — sets the priority (here, High) and confirms the ticket type and service.
• Related solution — links the matching knowledge article to the ticket.
• Resolution — drafts the resolution text (symptom, cause, and fix steps) from that article, so the agent doesn't start from a blank field.

The changes are applied only once you approve the card. Neo then leaves an internal comment on the ticket summarizing what it did and why. In this example it also explains that it did not mark the ticket as resolved, because nothing yet confirms that the suggested fix applies. The next person to open the ticket can see exactly where things stand and what is still needed.

Change impact analysis — what does this change actually touch?

Ask Neo about the blast radius of a change before it goes to CAB, and it doesn't stop at the assets listed directly on the change record. It follows those assets outward through however many dependencies they have — what runs on them, what they depend on, what's connected to them — and comes back with a ranked picture: which systems are most likely to feel this change, and why, not just a flat list. It also checks whether this exact impact has already shown up as a problem or a related change, so a CAB reviewer sees confirmed fallout ahead of merely predicted fallout. This is the example that shows Neo doing something a person could do too, but only by opening a dozen records and drawing the connections by hand — Neo does it in one turn, and shows its reasoning at each step so it's checkable, not just trusted blindly.

Problem candidate discovery — turning a pattern of tickets into a documented problem

Point Neo at a stack of open tickets and ask "does this look like a pattern to you?" It looks for tickets that share both a real symptom and the same underlying system — not just a loosely similar topic — and if it finds a genuine cluster, it proposes creating a problem record from it, with the likely root-cause system already identified and every contributing ticket linked. Nothing gets created without the agent's go-ahead. This is the clearest example of Neo doing something across a lot of data that a single-ticket view could never surface — the pattern only exists once you look at several tickets side by side — and it's also the clearest example of Neo writing, not just answering: propose, confirm, create, link, in one flow instead of an agent manually opening and cross-referencing five tickets to build the same problem record by hand.

Change-risk briefing across a whole CAB agenda

Instead of running the change-impact walk one change at a time, ask Neo to brief an entire week's worth of upcoming changes at once. It runs the same blast-radius reasoning across every change on the list, then does something a change-by-change review misses entirely: it flags when two unrelated changes happen to touch the same underlying system in the same window — a combined risk that's invisible if you only ever look at one change record at a time. A CAB reviewer gets one ranked briefing instead of opening every change individually and trying to hold the overlaps in their head.

Finding a hidden single point of failure

A step further in the same direction: ask Neo to look across many services or systems at once for a shared dependency — a piece of infrastructure, a vendor, a platform — that quietly sits underneath more of the business than anyone tracking it one service at a time would notice. Neo surfaces it ranked by how many independent services would be affected if that one thing failed, turning a question that would otherwise take a spreadsheet and a CMDB export into a single conversational ask.

Root-cause suggestion, starting from a ticket instead of a change

The mirror image of change impact analysis. Instead of "what will this change affect," the question is "why is this happening" — starting from a reported problem and working backward through what it's connected to, to find a recent change that plausibly explains it. Neo shows the chain that led to its suggestion (this system, connected to that one, changed two days ago) rather than a bare guess, so an agent can verify it before acting on it.

Faster answers on the single ticket in front of an agent

Alongside the multi-record examples above, Neo also does the everyday, single-record version of "help me with what's in front of me right now": summarizing a ticket for a handover, suggesting a resolution grounded in a real knowledge article or a genuinely similar past ticket (never inventing one that sounds plausible), drafting a customer update in plain language, or turning a resolved ticket into a new knowledge base article. These are the quick wins that make Neo useful every day — the change and problem examples above are what make it useful for the harder questions that used to require pulling up a dozen records and connecting the dots by hand.

Getting started

Open any data card (a ticket, request, etc.) and click the Neo button to open the panel. Type your request into "Ask anything…" at the bottom, or click one of the pre-built AI Actions above it. Once you've triggered an action, you can keep the conversation going — ask follow-up questions or trigger another action without starting over.

The list of Actions isn't fixed — it reorders itself based on how your team actually uses it. Whichever action was used most yesterday rises to the top today. Actions that haven't been used don't get shuffled or reset; they just keep their existing order relative to each other, so the list stays predictable even as it adapts.

Note: Neo's chat is only available when your organization's AI Provider is set to AI Core. If you don't see the chat box, your existing AI Actions still work exactly as before — check with your admin about AI Core availability.

How it works

See what Neo is doing, step by step

While Neo works, the panel shows you a live, expandable list of the steps it's taking — for example "Searched Ticket," "Read template knowledge," "Searching Person" — so you always know what information it looked at. Once it's done, those steps collapse into a short summary (e.g. "Worked for 9 seconds") that you can expand any time to review exactly what happened.

Approve before anything changes

Before Neo creates or updates anything, it shows you an approval card laying out exactly what it wants to do. For example, before creating a Knowledge article, you'll see the proposed title, keywords, and full article text — so you can review it just like you would review your own work before saving. Nothing happens until you approve it, and if you'd rather not go ahead, you can tell Neo why before canceling.

Good to know: the built-in Classification Actions (e.g. automatically categorizing a ticket) work a little differently under the hood, so they don't show this approval step even though they also update data — that's expected, not a bug.

Actions help users get started with Neo

An Action (Summarize, Categorization, Create resolution, and so on) isn't a separate mechanism from Neo — it's a preconfigured way to prompt or invoke Neo, set up in advance by an admin (or provided as one of our example configurations), so users don't have to type the request themselves. That's also why Actions can offer the same three response modes as free-form chat:

• Off — a plain AI response (direct LLM query), same as a basic request with no extra context.
• Use predefined data sources — the response is grounded in your organization's configured knowledge base (knowledge discovery using Retrieval Augmened Generation, RAG).
• Use predefined data sources with AI agent — grounded, and the action can also use tools to look up extra context before responding, the same tool use Neo's chat relies on.

Your existing AI Actions keep working exactly as they do today unless your admin changes this setting.

Things to know

• No conversation history yet. Refreshing the page starts a new conversation with Neo (closing and reopening the panel without refreshing keeps it, though).
• No sharing conversations with teammates yet.
• No deleting via chat or tools yet — only creating, updating, and looking things up.
• Occasionally, an approved update may not immediately take effect. If a change doesn't seem to have gone through after you approve it, refresh the data card to check, and try again if needed.
• One connected AI agent per Pro ESM tenant, for now. Pro ESM can only connect to a single AI Core agent at a time. If your organization needs different tool sets for different purposes, your AI Core admin can work around this today by using AI Core's agent-as-tools capability to combine multiple tool sets under that one connected agent.

Related articles

• M42 Intelligence Actions Admin Manual — configuring the AI Actions Neo's prompts are built from.
• MCP Server — the underlying tool/permissions system Neo and AI Actions call into.