Some MSPs we speak to push back on the first post in this series. They have automated. They have hundreds of RMM scripts, a stack of PSA workflows, auto-remediation policies, onboarding runbooks that run themselves. How is that not industrialisation?
Look at how each of those automations came into existence. An engineer noticed a recurring problem. They worked out the fix. They wrote it down as code or as a rule, tested it against the cases they had in mind, and set a trigger. Every automation in your library is one person's judgement, captured by hand, for one situation they anticipated.
In a workshop, that is called a jig. A craftsman builds a jig so a repeated cut is faster and more consistent. It is valuable, and a workshop full of good jigs outproduces one without. But the craftsman still decides which jig to use, sets it up for each piece, and builds a new jig for every new shape. The workshop still grows by hiring craftsmen.
Why script libraries hit a ceiling
Hand-built automation has three properties that cap how far it can go.
It only handles the input it was written for. A script expects a specific OS build, a naming convention, a registry path, an API response in a known shape. MSP environments are standardised in principle and varied in practice, especially across clients you inherited or acquired. When the input differs, the script fails, or worse, does the wrong thing. So most scripts are either triggered by a person who has checked the situation first, or fired only by narrow conditions that exclude the messy cases.
Its cost grows with coverage. Every new automation costs roughly the same to build as the last one, but covers less volume. The first twenty cover your most common, most uniform ticket types. After that you are writing automations for variants of variants. Ticket volume is a long tail, and hand-built coverage of a long tail runs into diminishing returns quickly.
It has to be maintained by someone who understands it. Vendors change APIs, Microsoft renames a setting, a client moves to a new stack. Each change breaks something, and the library becomes a maintenance liability that often lives in one engineer's head. When that engineer leaves, a surprising share of your automation leaves with them in practice, even if the code stays.
The result is visible in the one number that matters. MSPs with large, mature automation libraries still plan staff as a ratio of endpoints or seats. The ratio is better than it was. It is still a ratio.
Workflows have the same problem
PSA workflow builders and if-this-then-that rules feel different because they are configured rather than coded. They are the same thing. Each rule is someone's judgement about a situation, written in advance. Rules multiply, start to interact, and eventually nobody is quite sure why a ticket was routed where it went. The system does exactly what it was told, which is precisely the limit.
What changes with an agent
The step no script can do is the one that comes before it: reading an unstructured request, working out what is actually happening in this specific environment, and deciding which action fits, with which parameters, or whether no action is safe at all.
An autonomous agent does that step. It reads the ticket, pulls context from the PSA, the RMM and the documentation platform, matches it against how similar cases were resolved for this client and others, and chooses an action. When the case does not fit anything it can do safely, it escalates with its reasoning attached rather than failing silently.
This matters for how you see your existing library. Your scripts do not become worthless. They become parts. A well-tested remediation script is exactly the kind of bounded, auditable action an agent should be allowed to use, and the agent removes the need for a person to decide when to run it. The craft work of the last decade becomes the component set of an industrial process.
The unit of automation shifts accordingly. You stop writing one automation per anticipated case. You define the actions the system may take and the policy for when it may take them, and the system handles the variance between cases. New ticket types stop requiring new code. They require, at most, a new permitted action.
The practical test
Pick any category of recurring ticket and ask two questions. When a new variant appears, does someone have to write something before it is handled? And when the automation cannot handle a case, does anything tell you why? If the answers are yes and no, you own craft tooling. Good craft tooling, probably. But it will not break your staffing ratio.
This is part of a series of 7 blog posts about the industrialization of Managed Services.
1 - In the 4th and current Industrial Revolution, AI disrupts IT operations fast and MSPs must respond faster
2 - The half-finished industrialization.
3 - What your L2 engineers do when L1 disappears
Next week: Governance as the enabling condition
Why nobody hands software the keys, and what has to be true before they will. Don't want to wait for the next blog? Binge the whole story, download our E-book:



