Plaid for AI: why agents need a connect button
Technical users wire their agents together by hand. Everyone else needs a button or two.
Configure · · 6 min read
In short
- Plaid for AI means one embedded flow where a person connects the agents and apps they already use to a new AI product.
- Most people will not build their own agent setup. Mass adoption needs something that takes a button or two.
- Like payments and banking, connecting counterparties works when a neutral party runs the layer in between.
- Unlike a bank link, context has no fixed format, changes with every conversation, and has to flow both ways.
"Plaid for AI" describes one embedded flow that lets a person connect the agents and apps they already use, such as ChatGPT, Claude and Gmail, to a new AI product. They approve on a hosted page, and the product's agent can then read their context through a single integration. It is the neutral layer for context across agents, the way Plaid is for bank accounts across apps.
The comparison is useful because it tells you what to build. It also breaks in a few places that matter. We build Configure, which is our version of this layer, so the examples below come from that work.
What problem are people solving by hand today?
Technical users who are ahead of the curve already live in this future. They build their own personal agent setup, connect their tools to it, and sync memory between the assistants they use. They spend hours building it and more hours maintaining it.
Most people will not do this. Most people need something easy that only asks them to click a button or two to authorize a connection. That gap, between what a determined engineer can wire up over a weekend and what everyone else will tolerate, is the same gap fintech had before embedded bank connections.
What did Plaid actually solve?
Before it, a budgeting app that wanted your transactions had two bad options. It could ask you to download a statement and upload it, or it could build and maintain an integration with every bank its users might have.
The fix was a small module the app drops into its own screen. The user picks their bank from a grid, signs in and approves. The developer writes one integration and reaches thousands of banks. The user never leaves the app they were trying to use.
Two things made it work. The flow lived inside the product, at the moment the user wanted the feature. And a neutral company sat in the middle, so no bank and no app had to negotiate with each other directly.
Why does AI have the same shape of problem?
People will use many agents by default. Some companies offer a personal agent tied to an ecosystem they already own. Individual services build specialized agents for the tasks inside their own products, and those will usually be the best at their own work. Even someone with a favorite assistant will end up talking to several others in a normal week.
Each of those agents starts from nothing. The person has spent time explaining something to one assistant, and they want that context to continue somewhere else. Today the ways to carry it over are a chat export, a long copy and paste, a browser extension, or an onboarding quiz that most people abandon.
The developer has the mirror image of the problem. They cannot integrate with every assistant one at a time, any more than a budgeting app could integrate with every bank. Both sides need the grid: one screen where the user taps the agents they use, approves, and returns to the product with their context attached. We describe the category that results in What is context as a service?
Why does it have to be a neutral party?
Connecting information across counterparties has historically been done by someone in the middle who is not one of them. Card networks, bank-connection providers and payment processors all serve as intermediaries that connect otherwise fragmented data across systems. Expecting fair coordination directly between counterparties, whether they are large banks or large AI labs, is a non-starter.
For context across agents, that means the layer should not belong to anyone with a frontier model or a consumer platform to favor. An independent operator that favors no single party is the arrangement all of them can accept. Think of it as the Switzerland of the system.
The argument gets stronger with scale. If we end up with more agents than people, building compatibility and user control for each of them separately becomes very hard. Connecting to thousands of agents through one integration becomes the reasonable way to do it.
What carries over from Plaid, and what does not?
| Bank connection | Context connection | |
|---|---|---|
| Where the flow lives | Embedded in the app | Embedded in the app |
| Who approves | The account holder | The user, for each product |
| Who runs the layer | A neutral intermediary | A neutral intermediary |
| Developer effort | One integration, many banks | One integration, many agents and apps |
| How the source is reached | Sign in to the bank | Depends on the agent: a native connector, MCP tools, or an API call |
| Shape of the data | Structured: balances, transactions | Unstructured: preferences, plans, history |
| Direction | Mostly read | Read and write; each agent adds what it learns |
The first four rows are why the name is worth using. The last three are where the engineering is.
There is no single way in
Agents are reached in different ways. Some have a native connector. Any agent that can call an API or use MCP tools can connect without a first-party integration at all, and a user can start that from inside a chat. The layer's job is to hide those differences behind one flow, the way a bank-connection flow hides the differences between banks.
The data has no fixed format
A transaction has an amount, a date and a merchant. A person's context is a half-planned trip, a note that they dislike long answers, a calendar that says Thursdays are full. The receiving agent wants the parts that bear on the task in front of it. So the layer has to record where each piece of context came from, keep each agent's contributions separate, and check every read against what the user allowed.
It flows both ways
A budgeting app reads your balance and that is the end of it. An AI product learns things while you use it, and those are worth carrying forward too. With the user's permission, each connected agent can add memories from its own interactions to the same profile. A layer that only pulled memory out of one place would be a one-way pipe. This one serves and syncs, which is why it gets more useful the more places a person uses it.
What keeps the user in control?
People need to be able to bring their context in and out, or the whole thing breaks consumer trust. So control cannot be an afterthought. In Configure, a user approves each product separately and can change or revoke access inside the flow itself. Afterwards they manage every connection from their profile, much like the page where you review the apps linked to your bank accounts. Our hosted flow reference lists exactly what the page asks for and why.
Put plainly, it is the difference between explicit user consent and passive exfiltration.
Why would a platform add it?
Platforms want to give the best experience they can. A new product normally has to learn about a person before it can serve them well. With a connect button, an agent begins with relevant context the person has already built, before the first turn. That means lower switching cost for someone arriving from another product, shorter onboarding and less drop-off. Over time it means people stay longer and get to the valuable part sooner.
Personalization by itself is no longer a differentiator, since every agent asks for inbox access now. It has become an expectation. What still sets a product apart is how intelligent it is and how good the experience feels, and context is what lets both show up on day one.
Is "Plaid for AI" the right name?
It is a good first sentence. In four words it tells a developer what they get: an embedded flow, user approval, a neutral layer, one integration. It undersells the parts that are new, and a team that copies the bank model too literally will build a read-only import that is stale by the next conversation.
We use the phrase to open the conversation, then describe Configure as what it is: infrastructure to connect agents, apps and chats, so a person can carry their identity and context across AI. The quickstart gets a connect button into your product in one page.
Add a connect button to your product
The quickstart takes one page, end to end: a chip in your app, Configure's hosted page, and your agent reading the user's context on the first turn.
Read the quickstartNext: AI onboarding without the questionnaire