AI agent integration is the work of connecting an AI agent to the business systems it needs to finish a real job: reading records, updating them and taking actions inside those systems, within limits you set. Without those connections, an agent can only write text. With them, it can do the whole job from start to finish.
Integration is what separates a demo from something your team relies on. The AI itself is rarely what holds a project back. What usually holds it back is whether the agent can reach your inbox, your CRM, your project board and your accounting software, with the right permissions, at the volume your work requires.
This guide is for the person who has to answer that question before anything gets built. It covers the five ways an agent can connect to a system, where your data probably lives today, six checks that tell you whether a given system is ready, a scorecard you can run on your own software in an afternoon, where the agent's logins end up, and the problems that show up most often.
Why does integration decide whether an AI agent is useful?
Integration decides usefulness because every task worth handing to an agent already lives inside software you use. The agent has to get into those systems to notice the work, gather what it needs and record the result. If it cannot, a person still does the part that takes the time, and the agent becomes one more place to paste things.
Take a concrete example. "Follow up on a stalled lead" sounds like a writing task, but it has six steps: notice the lead has gone quiet, read the last three contacts, check whether a meeting was already booked, draft something that reflects all of it, send it from the right person's account, and record it where the next person will see it. Only the drafting is writing. The other five depend on integration.
This is also where having an agent built for you differs most from a do-it-yourself platform. Signing up for an agent tool takes minutes. The real work is getting that agent approved to use your systems, limited to the right access and reliable at your volume. We cover that tradeoff in more depth in Build Your Own AI Agents or Buy a Managed Service?, and the wider set of options in AI agents for business.
What are the five ways an AI agent can connect to a system?
Most software connects to other software through an API, the official doorway a vendor provides so outside programs can read and update your data. An agent can reach a system in five ways, and they are not interchangeable. From most to least useful, they are an official API, a partner or restricted API, a notifications-only feed, a file export, and clicking through the screens with no API at all. Which of these a system offers sets the limit on what the agent can do there.
| Connection type | What it means | What the agent can do | What it costs you |
|---|---|---|---|
| Official public API | A documented doorway with published sign-in rules that do not change without notice | Read and update the records the API allows, whenever needed | Getting access approved, and planning around usage limits |
| Partner or restricted API | The doorway exists but sits behind an application, a higher plan, or a vendor review | Same as above, once approved | A wait you do not control |
| Notifications only | The system sends out an alert when something changes but accepts nothing back | React to changes, but record the results somewhere else | A second system has to hold the results |
| File exchange or export | A scheduled spreadsheet export, a file drop or a report download | Work from a snapshot, not live data | A delay, and a step to match things back up |
| Screen-level only | No API, so the agent has to click through the screens like a person | Narrow tasks that break when the vendor redesigns a page | Ongoing upkeep, and higher risk |
Most systems are a mix. The API often covers most of what you need, while the last action you care about is only available on screen. Keep in mind too that the connection type belongs to the system, not the agent, so no vendor can give the agent a doorway the system does not offer. One wrinkle the connection type hides: the same system often holds several accounts for one person, and an agent that reads only the first of them looks like it succeeded. That is the problem behind reading six calendars for one person.
Where does your business data actually live, and how does an agent reach it?
Most companies keep the information for one task in five or six different places, each with its own connection type and its own likely sticking point. The table below lists the places we find data most often, how an agent normally reaches each one, and the readiness check that tends to fail there first. Use it to predict where a task will stall before you score anything.
| Where the data lives | How an agent usually reaches it | The check most likely to fail there |
|---|---|---|
| Email and calendar | Official API, with access the provider reviews | Getting access approved, and the sign-in method your company account allows |
| CRM | Official API, often only on a higher plan | Whether your plan includes API access at all |
| Accounting software | Official API, often read-only in practice | Permission to make changes, and somewhere to test |
| Help desk or ticketing | Official API with change alerts alongside it | Usage limits, usually during the first read of past records |
| Shared spreadsheets | Official API, but the sheet's own layout is the only structure | A reliable way to match records, since anyone can rename a column |
| Databases | A direct connection or a query API, read-only by default | Who can approve a login, and whether a read-only copy exists |
| Document storage | Official API, with permissions that vary per file | Per-file permissions, which are not the same as account-level access |
| Internal or custom apps | Whatever your own team built, which is sometimes nothing | Whether anyone still looks after the code |
| Old desktop software | Clicking through the screens, if anything | All six, and this is the one to work around |
Spreadsheets are the row that surprises people. They look like the easy case and are usually the fragile one, because their structure is a habit rather than a rule the software enforces, and nothing stops a colleague from inserting a column. Internal apps go the other way. They sound hard, but your own team can add the doorway the task needs, which no outside vendor will do for you.
What makes a system ready for an AI agent?
A system is ready when six things are true. The API covers the actions your task needs. The agent can have its own login. Someone can approve its access. The usage limits fit your volume. Records carry a reliable way to match them up. And there is a place to test that is not your live system. If one is missing, the connection usually still happens, but later and smaller than planned.
1. The API covers each action in the task
Most API documentation leads with the kinds of records it exposes, such as contacts, invoices, tickets and tasks. What you need to know is narrower: whether the API supports each step of your task. Walk through the task step by step and check. Reading a deal is usually supported. Moving it to a specific stage, adding a note a particular person will see and triggering the notification that follows may each have a different answer.
2. The agent can have its own login
An agent that signs in as a person inherits all of that person's access, leaves a history of changes with the wrong name on it, and stops working the day that person changes their password or leaves. You want a service account, its own paid seat, or an app login limited to what it needs. Google describes a service account as a special kind of account typically used by an application or compute workload rather than a person, which is exactly the distinction to ask your own vendors about. Some systems support it well, some charge for an extra seat, and a system that only offers shared logins has a real readiness problem.
3. Someone can approve the access
Granting access is often as much a vendor decision as yours. Google may require an app that reads Google users' data to pass a verification review before it is published. Its own guidance is to ask for the minimum access an app needs, partly because the more sensitive kinds of access require extra verification and security reviews. Find out early whether your task needs one of those, because that review sits outside your project plan.
There is a second approval people miss, and it is about how the agent signs in, not what it can do. Microsoft's security defaults block older sign-in methods, including one where you type a code on a second device, and Microsoft says those defaults are switched on for every new company account when it is created. A connector that signs in that way will fail on a recent Microsoft account no matter how carefully its permissions are set, because the block is a company-wide setting, not an app setting. Ask which sign-in method a connector uses before you plan a date around it.
Deciding how much access to grant is its own exercise, and we cover it separately in What Access Should an AI Agent Have to Your Business Systems?.
4. The usage limits fit your volume
Every major platform limits how many requests an app can make. Microsoft says that when an app goes over its limit, Microsoft's systems turn further requests away for a while with an error numbered 429 and a suggested wait time, that the limits vary by type of request, and that heavy updating is more likely to be cut off than reading. Slack publishes limits that differ by action, with most actions allowed at least 20 times a minute and message posting generally allowed once per second per channel.
Limits also change. Slack's own limits page records that from May 29, 2025, newly created apps that are sold to other businesses but not approved for the Slack Marketplace face new limits on reading channel history and thread replies. A change like that affects how much past history an agent can read, so plan around current limits and expect to revisit them.
5. Records carry a reliable way to match them up
An agent that cannot tell whether two records are the same customer will create a third. Before connecting a system, check what uniquely identifies a record, whether that same identifier exists in the other systems the task touches, and how many duplicates are already there. You do not need perfect data, only one dependable link between the systems the agent has to cross.
6. There is somewhere to test that is not your live system
Test accounts, developer accounts and practice workspaces exist so that a first connection does not learn on live customer records. Where there is no test account, the fallback is a first phase where the agent can only read, plus a small set of test records. Make that decision before the build starts.
The AI agent integration readiness scorecard
Score each system you are considering on the six checks above, from 0 to 3. Multiply each score by its weight, add up the six results, then divide by three. You get a number out of 100 that tells you whether to connect the system in the first phase, sort out a blocker first or work around it.
| Check | Weight | Score 0 | Score 1 | Score 2 | Score 3 |
|---|---|---|---|---|---|
| API covers the task's actions | 25 | No API | Read-only | Most actions | Every action |
| Agent can have its own login | 15 | Shared login only | A named person's seat | Extra paid seat available | Service account supported |
| Access can be approved | 15 | Nobody can approve | Approver unclear | Approver known, review needed | Approved and granted |
| Usage limits fit the volume | 15 | Unknown or clearly too low | Tight, needs batching | Comfortable | Generous and published |
| Records have a reliable match | 20 | No stable identifier | Identifier exists, many duplicates | Clean inside one system | Clean and shared across systems |
| Test setup exists | 10 | Live system only | Test records in the live system | Developer account | Full test copy |
Use the bands below to read the result. They are a planning rule of thumb we use to sequence work, not a validated industry benchmark.
| Score | What it means | What to do |
|---|---|---|
| 80 to 100 | Ready | Connect it in the first build |
| 60 to 79 | Ready with one known blocker | Connect it, and make that blocker a named task with an owner |
| 40 to 59 | Not ready for the first phase | Keep the system in the task but have the agent work around it for now |
| Below 40 | Not connectable yet | Leave it out, and revisit only if the task truly depends on it |
The scorecard matters most when your most valuable system gets the lowest score. That result still tells you something useful: start where the agent can work today, and come back to that system later.
Where do the agent's logins live, and who can revoke them?
An agent's access to your systems is a stored login sitting somewhere, and the four places it can sit have different consequences for checking what happened and for the day you want access to stop. Ask any vendor which of the four rows below describes their setup, because the answer tells you how you get your access back.
| Where the login sits | What that means day to day | How you revoke it |
|---|---|---|
| The vendor's shared cloud | You approve their app to use your systems, and their platform holds the login for every customer | Remove the app's access in your own system's admin settings |
| Your own company's cloud account | The app is registered in your own company directory, so your admins can see and check it | Remove the registration or the approval yourself |
| The machine running your agent | The login is stored where that one agent runs, so nothing central can reuse it | Revoke it at the provider, then confirm the machine holds no working login |
| A person's browser session | The agent acts as that person for as long as they stay signed in | Change their password, which ends the agent's access too |
Microsoft draws the same line in its own permissions model. It describes delegated access, where an app calls on behalf of a signed-in user, and app-only access, where the app calls with its own identity and no signed-in user. Those leave different records of who did what, and the choice is usually made for you by whichever connector you pick.
Here is how we handle it on our own service, since it is a fair question to ask before signing anything. Our setup is the first row of the table above. You connect each app yourself and approve the request on the provider's own approval screen, where you see everything being asked for and can decline it. The connection service we use then holds the login, in an account set up for your business alone, not one shared with other customers. You can revoke access from that app's own settings at any time, so cutting it off does not depend on us.
Which systems should you connect first?
Connect the system where the work starts and the system where it finishes. Those two make the agent's work visible and complete. Add the channel where the responsible person already works, so approvals and exceptions reach them. Everything else, including reporting, can wait for a later phase.
| Priority | The system that holds | The question it answers |
|---|---|---|
| 1 | The starting point | How does the agent know there is work to do? |
| 2 | The finish line | Where does the result have to land to count as done? |
| 3 | The person's channel | Where does the agent ask questions, and where does it hand off problems? |
| 4 | Background sources | What does the agent need to read to do the work well? |
| 5 | Reporting | How do we see whether it is working? |
For VantaSoft customers, the person's channel is the messaging app the team already works in, whether that is Slack, Microsoft Teams or something else. How approvals work inside it matters as much as the connection itself, and that is the subject of Human in the Loop for AI Agents.
There is also a commercial point to plan for. On our own Agent Service, small in-scope setting changes are included in the subscription, while new integrations are quoted separately as a change order. That is a good reason to name the systems you expect to need during discovery, not after launch, since integrations are one of the six things that move AI agent development cost.
What usually blocks an AI agent integration?
The blockers are predictable. These are the ones we see most often, with the realistic response to each.
A vendor review stands between you and the access you need
Start the application on day one of the project, not after the build. In the meantime, design the first phase around the access you already have.
The one action you need is not available
Split the task. Let the agent do everything up to that action, then hand a prepared item to a person for the final click. That often keeps most of the time saved without the risk of the agent taking that action itself.
Usage limits do not fit the volume
Group requests, spread them out over time and reuse results instead of asking again. Treat the first read of past records as a separate one-time job, not something the agent repeats on every run.
Records cannot be matched across systems
Pick one system as the master record for who is who, and have the agent copy its matching ID into the others as it works. Matching then improves over time, and you do not need a cleanup project first.
Everyone shares one login
Ask what a separate seat costs. It is almost always cheaper than the record-keeping and offboarding problems that shared logins create.
The API only comes with a higher plan
Price the upgrade honestly against what the task is worth before you treat it as a blocker. Sometimes it is one plan up and a small monthly difference. Sometimes it changes the business case, and then the right move is to put the number into your AI agent ROI worksheet rather than drop the idea.
Do you need an integration platform to connect an AI agent?
An integration platform is a service that sits between your agent and your systems and offers one way to reach all of them. It is a real category and it removes real work, mostly the custom connection work for each system, plus one place to handle sign-ins, retries and errors. What it cannot do is change the answer to any of the six readiness checks.
An integration platform will not create a doorway your system does not offer, approve access your vendor has to review, merge your duplicate records or raise a published usage limit. Those are facts about your systems, and they stay true whatever you put in front of them.
The decision comes down to counting systems. If one task touches two or three systems that all have good APIs, a platform adds another dependency and another bill for little gain. If you are connecting the same dozen systems again and again, across departments or customers, standardizing starts to pay. Score your systems first, then decide, because the scores do not change either way.
Does the Model Context Protocol remove the integration work?
No. The Model Context Protocol, often shortened to MCP, describes itself as an open-source standard for connecting AI applications to external systems, and compares itself to a USB-C port for AI applications. It standardizes how an agent talks to a tool, which is useful. It cannot create an API where a system has none, grant access you have not been approved for, fix duplicate records or raise a usage limit.
The protocol means less of the connection work has to be custom than it used to. The six readiness checks still apply.
Frequently asked questions
How many systems does a first AI agent need?
Usually two or three: the system where the work starts, the one where it finishes, and the channel where the responsible person can be reached. An agent that touches seven systems in its first week is harder to test, slower to get approved and much harder to troubleshoot when something goes wrong. Add systems once the first version has earned trust.
Do we have to clean our data before we start?
No, and waiting for clean data is a common reason projects never start. What you need is one dependable way to match a record across the systems in the task. Everything else can improve while the agent runs.
How does this work if each of our business units uses different software?
Score each unit's software separately and build for one unit first. An agent designed to work across several different sets of software at once inherits every weakness in all of them, and you cannot tell which one caused a failure. Pick the unit whose task and systems score highest, prove it there, then reuse the approach rather than the exact setup.
Can an agent just use the browser if a system has no API?
It can, and sometimes that is the right answer for a narrow, stable task. Understand the tradeoff first. Clicking through screens breaks when the vendor redesigns a page, and it is harder to limit precisely and harder to check afterward. We treat it as a deliberate exception, never a default. For a screen task that runs every day at volume, an RPA bot is often the steadier tool, and when to keep an RPA bot and when an AI agent should replace it walks through that choice.
Who owns the connection, us or the vendor?
You own the account and the data. An agent built for you should be approved to use your systems only within limits you agreed to, in a setup specific to your company, with a written way to revoke access. Ask any vendor exactly where logins are stored and how you disconnect.
What if we need to add a system after launch?
Expect to, and ask how it is handled commercially before you sign. On our service, small in-scope setting changes are included and a new integration is quoted as a change order, so naming the likely systems during discovery keeps the plan realistic.
Do we have to build these integrations ourselves?
No. That is the main difference between a platform you set up yourself and a service built for you. Our delivery sequence starts with discovery. We then build and set up the agents, their connections and the managed environment they run in, test together with you, launch, and keep coaching and maintaining from there. We cover the rest of that sequence in How to Implement an AI Agent in Your Business, and how to judge the firm doing it in How to Choose an AI Agent Development Company.
Score your systems before the first build call
The quickest way to move an agent project forward is to stop debating features and start scoring systems. Take your most important task, list the systems it touches, run each one through the six checks and bring the scores to your first conversation. You will know right away which parts of the task an agent can own now and which parts need a decision first.
If you want us to look over that list with you, start with a workflow discovery session. It takes 30 minutes, and you come away with a clear view of what can be connected, what has to be worked around and what it would take to change that.




