Frequently Asked Questions

SuperIT is an AI agent that resolves real IT incidents and service requests for your end users — autonomously, safely and around the clock. It is not a ticketing tool, a chatbot or an RMM. It sits alongside your existing stack as your "system of intelligence", cutting across the traditional tool silos so it can actually do the work an engineer would, rather than just triage or summarise it. We are ex-MSP operators, and we built SuperIT to scale the kind of exceptional, personal support that gets harder to deliver as a team grows.

Your PSA is your system of record: tickets, time, billing, the history of what happened. Your RMM and the rest of your stack are systems of action: they run scripts, push patches, change settings. A system of intelligence is the layer that sits across all of them — it perceives the whole environment, reasons about what is actually wrong, decides the right action, then uses the systems of record and action to carry it out and document it. That is what SuperIT is. We do not replace your PSA or RMM; we make them part of something that can think. It is also why the value compounds: the Digital Twin, the memory and the Skills library keep getting richer, where a tool that just runs workflows is the same on day 500 as it was on day 5.

Managed Intelligence Provider (MIP) is the name the industry is settling on for where the MSP model goes next: from managing infrastructure and tickets to managing the intelligence layer of a client's business — deploying AI safely, governing what it can and cannot touch, and helping people get real value from it. We think the shift is real because clients are driving it: every MSP we speak to is being asked about AI by their customers. SuperIT is the system of intelligence underneath that move. It does the day-to-day resolution work autonomously, which gives your engineers their hours back for the advisory work clients are asking for — and it gives you the credential that actually wins those conversations: agentic AI running safely in your own production environment, with the policies, approvals and audit trail to show for it.

By making your own service desk the proof. When a client asks what they should be doing with AI, the provider who answers from production experience leads the conversation; the one who answers from a slide deck does not. Running SuperIT means you have already done the hard parts yourself: deployed agentic AI into real environments, set the allowlists and approval workflows, watched the audit trail, and measured the results against your own ticket history. That is exactly the operating knowledge your clients need, from someone who has lived it. And because SuperIT absorbs the routine resolution work, your senior people have the hours to do the advisory work those conversations create, instead of being buried in the queue while a competitor leads the discussion.

SuperIT is built for two kinds of team. The first is growing MSPs — typically around 30 to 150 staff, supporting a few thousand to tens of thousands of end users — where day-to-day IT support is a huge share of the work and the real challenge is scaling it without letting quality slip. The second is internal IT and service desk teams at larger organisations with the same shape of problem: a large and growing volume of everyday support requests, real pressure to hit SLAs like time to first response and first-contact resolution, and a need to keep quality and end-user satisfaction high as the organisation grows. The common thread is the same in both: support volume is large, hiring and retaining great people is hard and slow, and consistency gets harder to hold the more you scale. That is exactly what we built for.

No — and that is not what our customers want. Almost every MSP we speak to is growing and struggling to hire, so they use SuperIT to take on far more than level-one: it resolves the repetitive requests and genuinely complex incidents alike, so you can grow without adding another tech for every new client. That frees your engineers for the human, high-value work software can't do — building relationships, improving your clients' businesses and, increasingly, guiding their AI adoption. And the tail of issues that still needs a person? SuperIT hands those over with full context.

We have watched owner-led AI purchases fail because the techs were never in the room, so we designed for the engineers first. Management sets the policies and controls what the agent can and cannot do; for the engineers, the payoff is in the day-to-day. Escalations arrive fully investigated — hypothesis, evidence, commands already run — instead of as one-line handoffs. The agent writes clean notes instead of creating more work to check. And engineers use SuperIT for their own issues too; it knows it is talking to an engineer and answers accordingly, diagnosis first, no hand-holding. Our advice for the demo: bring your most skeptical senior tech. Make sure they are part of the conversation and have their concerns addressed as part of the process.

It depends on your environment and how much autonomy you switch on, and we set a clear bar — agreed up front with you — and measure against it. We define "resolved" strictly: fixed, verified and documented in your PSA with no human intervention; escalations and deflections don't count. What surprises most people is that SuperIT is often strongest on the hard, long-tail problems — one customer had a laptop freezing for four months that even a factory reset could not fix; SuperIT root-caused a deep registry permissions issue and resolved it in about five minutes. And we stand behind the results with a 3-month money-back guarantee: if SuperIT is not delivering against the success criteria we agreed up front, you get your fees back.

No — SuperIT is the opposite of a ticket-deflection tool. End users already try to solve their own problems before they reach out; they Google it, they ask ChatGPT, and they only contact you when they are stuck and frustrated. SuperIT gives them a genuinely capable way to get unstuck fast, and the moment it cannot help — or the user asks for a person — it escalates straight to your team with everything it has gathered. You can name it, brand it as your own, and keep the human touch front and centre.

We recommend it, and the evidence backs it: end users take to a capable assistant far better when nobody is pretending it is a person, and one discovered deception costs more trust than a hundred disclosed AI interactions. That said, the call is yours — SuperIT carries your brand, your name for the agent, and your tone. What matters most to end users in practice is not whether it is AI; it is whether they get unstuck fast and can always reach a human when they want one. Both of those are design requirements for us, not afterthoughts.

Yes — SuperIT works the same at 3am Sunday as 10am Tuesday, which is exactly when the value is highest: the password reset that would otherwise wake your on-call engineer just gets resolved. For the issues that genuinely need a human after hours, escalation follows whatever process you already run — your on-call roster, your overflow partner — with the investigation already done by the time your engineer picks it up.

ChatGPT and Copilot can tell an engineer what to check; SuperIT does the work. We are a harness over the leading frontier models that gives them what a raw chatbot does not have: a live Digital Twin of the device and environment, your curated knowledge and Skills, and the ability to safely run commands and take action. So instead of copy-pasting commands back and forth, the agent diagnoses and resolves end-to-end.

Most tools in the category are either chat-and-triage layers (a bot asks questions, then a human takes over) or workflow/RPA tools that only run the pre-scripted automations you build first. SuperIT is built to resolve the long tail of issues you cannot pre-script: it works out the right action in the moment using the Digital Twin and your Skills, then runs it safely. The other big difference is that we are platform-agnostic. Unlike a bundled stack like Atera — where the AI only works if you run their RMM and PSA — SuperIT plugs into the tools you already have, whichever PSA and RMM that is. We are not trying to replace your PSA or RMM; we are the intelligence layer on top, and we will happily integrate with workflow tools like Rewst and Pia where you already use them.

It does not replace your RMM — it runs side-by-side with it. Our own AI agent (lightweight and available on Windows, Mac and Linux) gathers rich technical detail in an AI-friendly way, which is what feeds the Digital Twin and lets SuperIT safely see and help fix things on the actual machine. It also lets SuperIT run commands on the device in real time, protected by our security pipeline — not pre-defined scripts, but the right command for the exact moment, chosen by the agent and checked before it runs.

The Digital Twin is a live knowledge graph of your environment — users, devices, hardware, applications, networks and how they all relate — with key metrics snapshotted over time. It is how the agent perceives the environment the way a seasoned engineer would, so it can reason about the real issue instead of guessing. Because it tracks patterns over time, it can answer things like "what changed" or "what was running when this started".

On top of the frontier models' general IT knowledge, SuperIT builds a living library of "Skills" from the highest-signal source we have found: your tickets. We have learned that resolved tickets and their notes are often a more accurate picture of how your environment really works than a knowledge base that has gone stale. Every night it "dreams" — distilling new learnings from conversations and tickets back into the knowledge, and flagging anything outdated. It does not need to be 100% perfect to be effective, because the agent can only ever do what you have allowed it to.

Uncertainty handling is designed in, because an AI that always has an answer is an AI you cannot trust. When SuperIT is not confident, it does not guess: it gathers more signal, asks a clarifying question, or escalates to your engineers with everything it has found so far. Every fix is verified after it is applied — SuperIT checks the issue is actually resolved before telling anyone it is, and a ticket is never closed on an unverified answer. And if something does go wrong, the blast radius is bounded by design: the agent runs with the permissions of the user it is helping, higher-risk actions sit behind approvals, and the audit trail shows exactly what was proposed, approved and executed — so you are never reconstructing events from memory.

That is the right question to ask, because confident answers from stale documentation is how AI tools lose a room. Three things protect against it. First, SuperIT grounds its troubleshooting in the Digital Twin — the live state of the actual device and environment — rather than what a document says should be true. Second, the Skills it executes are curated and validated, not improvised from whatever a search index returns; if no skill fits the situation cleanly, it escalates rather than freelancing. Third, the knowledge is continuously maintained: resolved tickets feed back into the library every night, and anything that looks outdated is flagged for review rather than silently reused. Knowing when not to answer is part of the design.

This is make-or-break for any tool in our category, and we treat it that way. SuperIT works inside your PSA from the first message: it picks up or creates the ticket, keeps status and priority current, writes proper notes as it works, records what was run and what the outcome was, and closes with documentation your engineers would be happy to find six months later. Escalations land as fully-investigated tickets with the evidence attached. Your PSA stays the system of record — we just make what is in it more accurate.

You decide, and it ramps up as you get comfortable. Pilots usually start conservative — internal notes only, engineer-driven — then progressively enable more autonomy. Sensitive actions run behind an approval matrix (for example, a password reset on a global-admin account must be approved by a named group), and if there is any risk of going in circles, it escalates to an engineer rather than wasting the user's time.

Through the channels they already use — directly via your ticketing system, a web chat, a Microsoft Teams or Slack bot, or embedded in your existing customer portal (CloudRadial, Desk Director). We deliberately do not make people learn a new tool or change how they ask for help. The agent adapts its tone too: concise and non-technical for an end user, more technical for an engineer.

Security is the one thing we never compromise on, and it is built in layers, like an onion. There is a hard, system-level filter of dangerous commands that nobody — not an engineer, not the agent — can override; static analysis of every command before it runs; an allowlist and blocklist you control (we ship read-only and non-mutating by default); and, most importantly, the agent inherits the permissions of the person it is talking to, so it can never do something that user could not do themselves. Anything beyond that requires explicit human approval.

Yes. Beyond the allowlist you control, certain system-level commands are hard-blocked and cannot be enabled, even if a human explicitly asks. Credentials and sensitive configuration — like passwords in your documentation tool, or Microsoft 365 global-admin — are kept out of the agent's reach, and higher-risk actions route through approvals with alerting.

We assume it can be tried — by a crafted ticket, a malicious email, or a clever end user — and we design so that manipulation cannot escalate. The key insight: it does not matter why the model proposes a command, because every command passes the same checks regardless. The syntactic layer parses what a command actually does (catching injection tricks, encoded payloads and dynamically-assembled commands), the policy layer resolves it against your allowlists with "needs approval" as the fail-safe default, and execution runs with the permissions of the user being helped — so even a fully "jailbroken" agent could not do anything that user could not already do themselves. Locked credentials stay out of reach, and the audit trail records every proposal, including the blocked ones.

SuperIT runs on Google Cloud's Vertex AI in an isolated tenant, with data encrypted in transit and at rest. We are a model-agnostic harness over the leading frontier models (Anthropic, Google and OpenAI), and we can change which models we use as their performance changes.

Strict multi-tenancy is built into the architecture, not bolted on. Every customer environment is an isolated tenant; every device connects with its own scoped credentials; and the agent only ever reasons over the client context the conversation belongs to, so one client's data can never bleed into another client's responses. Every action — who or what did it, when, against which endpoint, under which policy — is in the audit trail, so you can answer "who touched this machine" with evidence, not trust.

We host in Australia and the United States, and because we run on Vertex AI we can pin inference to a specific region where you need it. If you have strict residency requirements — for example regulated, government or law-enforcement clients — tell us and we will configure the right endpoints. For us that is a configuration change, not a major engineering lift.

We are working toward ISO 27001, and also toward SOC 2 compliance — our controls and documentation are in place and we are progressing to formal audit. In the meantime we are happy to share our security and trust documentation and walk your team through the architecture, and we run a bug-bounty program because we would genuinely rather you try to break it.

We are vendor-agnostic and integrate across PSA and ticketing (ConnectWise, Autotask, HaloPSA and more), identity and cloud (Microsoft 365, Entra ID, Google Workspace), documentation (IT Glue, Hudu), RMM, networking and security tooling, and the portals your users already live in. We have built a framework that lets us ship a new integration in about a week — and if a connection does not exist yet, the agent simply gets out of the way and escalates rather than guessing.

Less than you would expect, and we do the heavy lifting. It starts with a read-only API key to your PSA so we can run a ticket analysis — no disruption to production. From there we build your knowledge base and Digital Twin in the background, deploy the agent to a test customer, and expand from there. Most partners are testing within a few hours, and are fully up and running in about one week with their first customers — with a dedicated engineer and a shared Slack channel the whole way.

Yes — per-client control is built into the multi-tenant design, not bolted on. Most MSPs start with one test client, then expand client by client as confidence grows. Policies, autonomy levels and the agent's scope are all set per managed organisation, so a cautious client can run with internal-notes-only while a trusting one runs with full autonomy, at the same time, from the same console. If a client never wants AI touching their environment, exclude them entirely — their tickets simply route to your engineers as they do today.

Less than a typical RMM deployment, and you control the pace. The agent is lightweight, runs on Windows, macOS and Linux, and deploys with the tooling you already use to push software. We stage the rollout — a test client first, then expand as you get comfortable. And the value does not wait for full coverage: the ticket analysis, PSA integration and cloud-side context all work before a single endpoint is enrolled. The agent deepens what SuperIT can see and safely do on each device as it lands.

Yes — it is the best way to see the value with zero risk. With a read-only key we analyse a sample of your closed tickets from the last few months and estimate, ticket by ticket, what SuperIT could have resolved end-to-end or shaved off in triage time. You get a tangible report — and a dollar figure — before anything touches production.

Pricing is a fixed monthly fee plus usage-based "AI work credits" — not per-seat and not per-device — because a small MSP using it heavily can get more value than a large one barely touching it, and our real cost scales with the work done. The fixed fee gives you budget certainty; credits are consumed by valuable outcomes like resolving a ticket end-to-end. Our philosophy is simple: you should keep the large majority of the value SuperIT creates.

A short, low-risk evaluation — typically 30 to 90 days — where we agree up front what success looks like and hold ourselves to it, with no security surprises. We do the onboarding, you shape the product to your team, and it is backed by a 3-month money-back guarantee: if SuperIT is not delivering against the agreed success criteria, you get your fees back.

Yes. SuperIT comes with a 3-month money-back guarantee: we agree the success criteria up front, and if SuperIT is not delivering against them, you get your fees back. We would rather earn the renewal than hold you to a contract, so the risk of trying us sits with us, not you. Combined with no auto-rollover, no lock-ins and full data portability, there is very little downside to finding out whether it works on your queue.

We hold ourselves to the strictest definition, because the industry has burned people with softer ones. Resolved means the issue is fixed end-to-end and verified, the ticket is documented and closed in your PSA with clean notes, and no human had to intervene. A ticket the agent merely replies to, deflects, triages or escalates does not count towards any resolution number we quote — and during a pilot you can audit every resolution we claim, ticket by ticket.

Two ways. Before you commit, the ticket-analysis report shows what SuperIT could have automated across your real history, in hours and dollars. Then we measure against that baseline during the pilot. The ROI is in leverage: your engineers handle more without you hiring the next level-one — which matters, because labour is the largest cost in most MSPs.

It leaves with you. Full data portability is a standing commitment: export your data at any time, in usable formats — including the Skills library that codifies how your service desk resolves issues, which we consider yours, not ours. Contracts are simple: no auto-rollover, no multi-year lock-ins. We think the context an AI system builds up about your business should be an asset you own, not a rental that disappears the day you switch vendors.