Skip to content
be-human.ai
← Back to the journal

Personalized AI infrastructure

Superintelligence Readiness for Small IT Teams: A First-Pass Checklist

A first-pass checklist for small IT teams: check accounts, identity, logging and backups before agents gain more access to company systems and data.

Be Human typographic cover with the title: Superintelligence Readiness for Small IT Teams: A First-Pass Checklist
Conceptual illustration created with AI · Be Human

Superintelligence readiness for a small IT team means getting accounts, identity, logging and backups right before AI agents receive broader access to company systems. Start by listing every account, key and connector an agent could use, tie each one to a named human owner, and confirm that you can see and reverse what it does. The checklist below is a first pass, meant to be worked through in a handful of focused sessions, not a full audit.

Key takeaways

  • Inventory every identity an agent could use before you grant any new access.
  • Give each agent its own account, with a named human owner and the smallest permission set that does the job.
  • Write agent actions to logs that a person can search, explain and act on.
  • Restore-test the configuration, memory and records an agent depends on, not only the server backups.
  • Put approval boundaries in writing so that expanding access is a decision, not a side effect.

Why the basics come before the agent

An agent does not need a special door into your systems. It uses the same doors your staff use: API keys, service accounts, connectors, shared logins and delegated tokens. When an agent is only answering questions, a weak account setup is an inconvenience. When it can update records, send messages or change settings, the same weakness becomes the easiest path for a mistake or an attacker to take.

The practical question shifts from what the system can say to what it can touch. That is why identity, permissions, logs and recovery come first. Tools that connect models to business systems, such as those described in the [Model Context Protocol introduction](https://modelcontextprotocol.io/docs/getting-started/intro), make these connections easy to add, which is exactly why each one needs an owner and a boundary. For the wider governance structure that decides who signs off, the committee charter for small companies is a useful companion to this checklist.

Accounts and identity: who is the agent, really?

Every agent should be traceable to a specific identity that is not borrowed from a person. Work through these items with your directory and admin consoles open.

  • List every human account with administrator rights, and confirm each one still belongs to a current employee or contractor.
  • Find shared logins used for finance, customer, or admin systems, and replace them with individual accounts or managed service identities.
  • Turn on multi-factor authentication for email, file storage, source control, and every admin console.
  • Give each agent a distinct identity. Never copy a person's login or session into an agent's configuration.
  • Record the owner, purpose and renewal date for every service account and API key.
  • Confirm that offboarding removes access from connectors and tokens, not only from the company directory.

When an agent acts on behalf of a user through a delegated connection, check which scopes that connection grants. The [Google OAuth 2.0 documentation](https://developers.google.com/identity/protocols/oauth2) explains how scoped access tokens work, and the same principle applies to most business platforms: a token should carry only the access the task needs.

Permissions and approval boundaries

Least privilege is the working rule. An agent that summarizes support tickets should not be able to edit billing records. Separate read access from write access, and separate both from any action that sends something outside the company or changes who can do what.

OWASP's [authorization guidance](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html) recommends checking permissions on every request and denying by default. Applied to agents, that means the default answer to a new capability is no until someone approves it. Use this decision guide to set the first boundaries:

  • Read-only access inside one system: the agent may act on its own, and the access is logged.
  • Write access to a reversible record, such as a draft or a note: the agent may act, with a log entry and a way to undo.
  • Sending a message outside the company, issuing a refund, or changing a price: a named person approves each action or each batch.
  • Creating accounts, granting permissions, or deleting data: this is never delegated to the agent.

Write these boundaries down for each agent role. The permission review guide walks through how to check them against the access that actually exists, which often differs from the access that was intended.

[figure]

Logging you can use when something goes wrong

A log is useful only if it answers the questions an operations lead will ask after an unexpected change: who acted, through which tool, on which record, with what input, and with what result. The [OpenTelemetry observability primer](https://opentelemetry.io/docs/concepts/observability-primer/) describes the core idea, that a request can be followed through every step it touches if each step records a shared identifier. That same idea works for agent runs.

Illustrative scenario: a customer record changes overnight, and the sales operations lead wants to know why. If the agent's run identifier links the request, the tool calls and the final write, the lead can see the connector used, the field changed and the account it acted under within minutes. Without that trail, the team compares exports for a morning and still may not know the cause.

Check these items for every agent role:

  • Every agent action is written to a log that the agent itself cannot edit.
  • Each entry includes the acting identity, the tool name, the target record and a timestamp.
  • A run identifier connects the original request, the tool calls and the output.
  • Tool inputs are logged, so you can see whether untrusted text, such as an email or a web page, steered an action. The [OWASP prompt injection cheat sheet](https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html) explains why this matters.
  • Retention follows your records policy, and only named people can read the logs.
  • Alerts fire on permission changes and on unusual volumes of write actions.

Backups: the agent's memory is data too

Server backups do not protect an agent if its instructions, tool definitions, approval rules and memory sources are lost or quietly changed. Treat those as records in their own right. The data readiness audit is a good next step once the backup scope is clear, because an agent is only as reliable as the records it reads.

Retries are a second concern. If an agent's write fails partway and is retried, the target system may create a duplicate. Some providers defend against this with idempotency keys, which let a repeated request be recognized as the same request. The [Stripe documentation on idempotent requests](https://docs.stripe.com/api/idempotent_requests) is a clear example of how a provider defines this behavior. Check whether each write path you plan to use offers something similar, and add a duplicate check where it does not.

  • Back up the agent's configuration, instructions, tool definitions and approval rules, not only its data.
  • Version the memory and knowledge sources so an earlier state can be identified.
  • Restore a sample into a separate environment at least once before you rely on the backup.
  • Write down who can trigger a restore and which systems are rolled back first.
  • Confirm that writes to finance or customer systems are idempotent or protected by duplicate checks.

A first-pass order of work

The items above can be sequenced so that each step makes the next one safer. This order fits a team of a few people who also have other duties.

  • Inventory accounts, service identities, API keys and connectors that touch company data.
  • Assign a human owner to each one, and retire anything that has no owner.
  • Enforce multi-factor authentication and remove shared logins from admin and finance systems.
  • Define the permission set and approval boundary for the first agent role, and keep it narrow.
  • Turn on logging for that role, then confirm you can reconstruct one test run from start to finish.
  • Back up the agent's configuration and memory sources, and restore-test them.
  • Review the results with the business owner and decide what to widen, and when. The governance and steering guidance can help set who makes that call.

Be Human handles this work inside managed operations. An engagement starts by defining one useful role, the memory and tools it needs, its approval boundaries and an observable success criterion. Identities, permissions and logs are set up for that role, and monitoring, permission review and integration maintenance continue afterward, so the foundation keeps matching what the agent can actually reach. The first months with a managed agent describe how this period usually unfolds.

If you want to find the first task worth handing to an agent, the free Be Human AI diagnostic is a practical place to start.

Frequently asked questions

Do we need to finish every item on this checklist before we test an agent? You do not need a perfect environment, but you should finish the items that touch the first role: its identity, its permissions, its logs and its backup. Anything outside that scope can follow in later sessions. Testing without those items in place makes it hard to tell what the agent did.

Is a shared admin login acceptable for a small team? It is common, and it is the first thing to fix. A shared login makes it impossible to tell who did what, and it weakens offboarding. Replace it with individual accounts for people and distinct service identities for automation, starting with finance and admin systems.

How often should we review agent permissions? Review them on a fixed schedule, and also whenever an agent gains a new tool, a new connector or a new write capability. Compare the access that exists with the access the approval boundary allows. Record what changed and who approved it.

Do we need an outside partner to do this work? A small team can complete a first pass internally if someone has the time and the authority to make decisions. Outside help is most useful for ongoing monitoring, recurring permission reviews and incident response, which are easy to neglect once the initial setup is done.

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.

Less busywork. More room for you.

Bring us the work you wish you had time for.

Book a call to try a personalized AI agent free for 7 days ↗Or take the free AI diagnostic →