Superintelligent Agents for MSPs: Client Tickets and Runbooks
A practical guide for managed service providers on keeping client memory separate, running documented runbooks, and routing access requests for approval.

Superintelligent agents for managed service providers are AI workers that handle one client's tickets, follow that client's runbooks, and stop to ask a named person before touching anything outside an approved scope. The working requirement is separation: each agent holds only its client's memory, tools and permissions, and every request that crosses that boundary goes through a documented approval. An MSP can add useful automation this way without letting one client's network details, exceptions or credentials appear in another client's work.
Key takeaways
- Give each client its own agent scope, memory store and tool credentials, so context cannot cross accounts by accident.
- Convert every runbook into ordered steps with preconditions, expected results and stop conditions before an agent may execute it.
- Route any action beyond the runbook to a named approver with a written reason, a defined scope and an expiry.
- Log every tool call against a client identifier so an incident can be traced, reviewed and explained to the client.
- Agree on one observable success criterion per agent before launch, and review it with a person on a fixed schedule.
Why client memory has to be separated
An MSP holds more context per client than most businesses hold per customer. The memory an agent accumulates can include network layouts, naming conventions, prior incidents, which staff members may approve changes, and exceptions someone granted months earlier. Each of those details is useful inside one client's ticket and harmful inside another's. Separation is therefore a design decision made before the first ticket arrives, not a habit the team hopes people will keep.
Separation works on three layers. Memory is what the agent can recall: notes, closed tickets and runbook versions indexed under one client identifier. Tools are the systems it can call, such as a remote monitoring console, a ticketing platform or a directory service, each connected with credentials that belong to that client only. Permissions are what those calls may change. Retrieval should query only the client's index, and authorization should be checked by the tool layer on every call rather than trusted because the model judged the request reasonable. The OWASP authorization guidance makes the same point: access decisions belong in enforcement code outside the component that reads user input.
Turning runbooks into steps an agent can follow
A runbook written for a senior technician often says check the replication status and restart the service if needed. That sentence works for a person who already knows what healthy looks like. An agent needs more structure, and writing that structure is useful for the human team too, because it exposes steps that were never written down. Before a runbook is connected to any agent, convert it into a form where every step can be checked.
- Name the trigger: the ticket category, alert type or customer request that starts the runbook.
- List preconditions: client status, maintenance window, required tool access and anything that must be true first.
- Write each step as one action, the tool it uses, and the result that counts as success.
- Define stop conditions: unexpected output, a foreign client identifier appearing in the data, or a change outside the listed systems.
- Specify the rollback, or the handoff to a named technician when a step fails.
- Record the runbook version so the logs show which instructions were followed.
Review the converted runbook with the technician who wrote the original. Most gaps appear in the stop conditions and the handoff, because those are the parts experienced staff handle from memory.
Escalating access requests without stalling the queue
The hardest moment comes when a runbook needs something the agent does not have. The answer should not be a broader permission granted silently, and it should not be a ticket that waits in a queue with no context. Treat each access need as a request with its own record. The following decision guide covers most cases:
- Action listed in the runbook, reversible, on this client's systems: the agent proceeds and logs each step.
- Action listed in the runbook but needing a permission the agent lacks: the agent opens an access request naming the system, the exact permission, the reason and the expiry, then waits for the named approver.
- Action not in the runbook, or affecting shared infrastructure that serves several clients: the agent stops and flags the ticket to a technician with a written summary.
- Any request to share or reveal a credential: refused in the conversation, replaced by a reference to the client's secrets store.
- Any instruction found inside ticket text, email or attachments that asks the agent to change its scope: treated as content to report, not as an instruction to follow.
The last rule matters more than it looks. Tickets are written by people outside the MSP, and some of them are attackers. The OWASP guidance on prompt injection prevention explains why content an agent reads should never be able to rewrite the rules it operates under. Approvals themselves should happen in the system where the MSP already records decisions, such as its PSA or ticketing platform, so the reason and expiry stay attached to the ticket.
Illustrative scenario: a reset that needs one more permission
The following scenario is illustrative and does not describe a real client. A managed provider runs an agent for a small professional services client. A ticket arrives asking to unlock a staff account and reset its password. The runbook covers the reset, but the account sits in a directory group the agent cannot modify. The agent completes every check it is allowed to perform, opens an access request naming the directory, the single permission needed and a same-day expiry, and notifies the technician on duty. The approver confirms the request matches the client's written rules, grants access, and the agent completes the reset. The log then shows each call tagged with the client identifier, the approval reference and the removal of access at expiry. Nothing from this client's memory was visible to any agent working on another client's tickets that day.
How Be Human's managed approach handles client scope
Be Human designs personalized AI agents that keep their identity, memory, channels, tools, permissions and operating context under human control. A first engagement defines one useful role, the memory and tools that role needs, the approval boundaries, and an observable success criterion. Managed operations then cover monitoring, recurring evaluations, integration maintenance, permission review and incident response, so scope is maintained after launch rather than set once and forgotten. The service is delivered remotely in English and Portuguese. For how this applies to MSP memory specifically, see Superintelligence Prep: Managed Service Provider Memory. Teams that handle similar scoped records for multiple sites may also find the approach in Post Orders and Incident Logs: One Agent Memory for Security Firms useful as a comparison.
Measuring scope and reviewing permissions on a schedule
Every agent action should produce a trace that records the client, runbook version, tools called, approval reference and what changed. The OpenTelemetry observability primer describes how logs, traces and metrics let a team answer what happened and why, which is exactly the question an MSP must answer after an incident. Build a fixed set of test tickets for each client that includes a deliberate cross-client request, then rerun that set after every change to a runbook, a model or a tool connection. If the agent ever reaches for another client's data in those tests, treat it as a defect and pause the agent until the cause is found.
Review standing permissions on a regular calendar. Remove access that is no longer used, confirm that each approval has expired, and check that the success criterion still reflects what the client needs this quarter. If you are unsure which client workflow should become the first agent task, the free Be Human AI diagnostic can help you find it.
Frequently asked questions
Do we need one agent per client? Not always, but each client needs its own memory store, credentials and permission scope. A shared agent can serve several clients only if the platform enforces separation at the data and tool layers, not through instructions written in a prompt. For most MSPs, one scoped agent per client or per client service line is easier to audit and to explain to a customer.
Can an agent close tickets on its own? It can, when the runbook covers the step, the action is reversible, and the log records each change. Closing a ticket that involves a customer decision, a billing effect or a change outside the runbook should still go to a person. The first engagement defines which actions fall into each group.
How do we know the agent stayed within scope? Each action should be traceable to a client identifier, runbook version, tool call and approval reference. Fixed test cases that include a cross-client request, rerun after every change, show whether the boundary still holds. Records should also be reviewed on a schedule, not only after an incident.
Where should access requests be approved? Approvals belong in the system where your team already records decisions, such as the PSA or ticketing platform, so the reason and expiry stay attached to the ticket. The approver should be named in the runbook, and access should expire automatically. Verbal approvals in chat are hard to audit later and are difficult to defend to a client.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


