What is context as a service?
People will use many agents. Context as a service is how what one of them knows about you can follow you to the next, with your permission.
Configure · · 6 min read
In short
- Context as a service is infrastructure that lets an AI product read the context a user has already built with other agents and apps, with the user's permission.
- It exists because people will use many agents by default, and each one currently starts from nothing.
- It needs three things underneath: knowing the same person across services, keeping connections alive, and enforcing what each agent can access.
- The line that matters is explicit user consent versus passive exfiltration.
Context as a service is infrastructure that lets an AI product start from the context a user has already built with other agents and apps, with the user's permission. The product does not collect that context again. The user approves a connection on a hosted page, and the product's agent can read what they approved from the first message.
We build Configure, which is infrastructure to connect agents, apps and chats, so we have a stake in this definition. It holds whether you buy the layer or build it.
Why does this category exist now?
The impact of AI is much larger if intelligent applications can operate as an ecosystem. An AI product should understand you and connect to your other services, with your permission. Most of what would help it is spread across your email, your apps, your documents and, most of all, the conversations you have already had with other agents.
A few years ago, connecting the world's services sounded structurally implausible. Everyone had a different data model and different auth requirements, and standardizing all of it for universal compatibility was a ridiculously tall order. Agents changed that. They do not need bespoke wiring for every pair of services, because they work in natural language. What they still need is infrastructure underneath: something that can identify the same person across services, maintain the connections, and enforce what each agent is allowed to access.
That infrastructure is what "context as a service" names.
Why will people use many agents and not one?
More companies now offer a personal agent tied to an ecosystem they already own: one inside a social network, one inside a messaging app, one connected to your mail and calendar. At the same time, individual services are building specialized agents for the work inside their own products. A food delivery app has an agent for ordering. A shopping site has its own assistant. A travel site has one for booking.
Those specialized agents will likely always have priority inside their own platforms. They have extra capabilities there, and they will be the best at their own product's tasks. So we expect people to use many agents by default, even if they have a favorite. A travel plan may begin in your preferred assistant and end inside an airline's or a hotel's product.
Making that seamless requires some form of user-controlled continuity between the services involved. It is hard to imagine a future where that continuity is not the default. It is also simply not how the world worked before.
How does context as a service work?
The solution has to work at the infrastructure level, and it has to be simple enough for most people at the product level. With Configure, the flow has five parts.
- Meet the user where they are. The product shows a connect step in onboarding, in chat, or at sign-in.
- A Plaid-like connection flow. On a hosted page, the user picks the agents and apps they already use and approves the product. It takes a button or two.
- One profile. Everything the user connects is linked to a single profile that belongs to them. Configure records where each piece of context came from and keeps each agent's contributions in its own namespace.
- Read at runtime. The requesting agent reads the user's approved context through an SDK or over MCP. Every read is checked against the user's permissions first.
- It keeps flowing. As the user works with connected agents, each one can add memories from its own interactions, so the profile gets more useful over time.
Any agent that can call an API or use MCP tools can take part. A first-party integration is not required, and a user can start a connection themselves from inside a chat.
What does that look like for a real task?
The value shows most clearly when a task spans several services. Someone who has planned a trip with an assistant could let a travel site use the dates and budget they already agreed on. They could then share the itinerary with the airline, the hotel and a restaurant booking app as they go. Each service receives only the information the user approves, and all of them work from the same plan as it develops.
Without that, the person retypes the plan four times, or pastes a chat export into each product and hopes it is read correctly.
How is it different from a memory layer or RAG?
| Memory layer | RAG over your data | Context as a service | |
|---|---|---|---|
| Whose data | The user's, inside your product | Your company's documents | The user's, across products |
| Where it comes from | Your own agent's conversations | Your knowledge base | Other agents and apps the user already uses |
| Who approves access | Nobody; you already hold it | Your company | The user, for each product |
| What it fixes | Forgetting between sessions | Answers that ignore your docs | Starting from nothing with a new user |
A memory layer is the right tool when your agent forgets what the user said yesterday. It cannot help with a user you met ten seconds ago, because it has nothing about them yet. Context as a service is for that moment. If forgetting inside your own product is your only gap, a memory layer is simpler and you should use one.
Who should run this layer?
Connecting information across counterparties has historically been done by a neutral party. Card networks and bank-connection providers sit between institutions that would never coordinate fairly with each other directly. The same logic applies here. An AI lab has a model to favor, and a platform has an ecosystem to favor. An independent operator with no frontier model and no platform of its own is the arrangement everyone else can accept.
It also matters more as the number of agents grows. If there end up being more agents than people, building compatibility and user control for each of them one at a time stops being possible, and connecting to all of them through one integration becomes the practical choice.
Where is the line between consent and exfiltration?
This is the question to ask of any provider. A tool whose only purpose is to pull a person's memory out of one assistant is a one-way pipe, and it breaks trust on both ends. A context layer has to work differently: it serves and syncs context with explicit user permission, each agent sees only what the user approved for that agent, and the user can change or revoke access at any time.
In Configure, approval is per product. Finishing the hosted flow approves one agent and only that agent. On their profile, a user can narrow what an agent reads, disconnect an app, revoke the agent, or delete the profile. A revoked agent's next read is refused, and it does not quietly get stale data. The details are on our trust page. That is the difference between explicit user consent and passive exfiltration.
Why would a platform want this?
Personalization is now a default expectation for consumer products, and control over your own data is becoming one too. A new product normally has to learn about a user before it can serve them well. That is what onboarding is. Starting with context the user already built means less onboarding, less drop-off, and a first session that is already specific to the person.
There is a second reason. We think platforms will compete on the intelligence of their models and on the experience they build, and not on holding facts like someone's favorite color or shoe size. Keeping that information locked in does not make a product better. Using it well does.
Is the phrase also used for enterprise data?
Yes. Some companies use "context as a service" for supplying a model with company data such as catalogs, documents or live web data. That is closer to RAG. This article is about user context: what one person has shared with the tools they use, moved with their consent. When you compare vendors, ask whose data they move.
How do you add it with Configure?
npx configure setup
import { Configure } from "configure";
const configure = new Configure({
apiKey: process.env.CONFIGURE_API_KEY,
agent: process.env.CONFIGURE_AGENT,
});
app.get("/configure/start", async (req, res) => {
const profile = configure.profile({ externalId: req.user.id });
const connect = await profile.connect({ returnUrl: RETURN_URL });
res.redirect(connect.connect_url);
});
The user lands on Configure's page, picks what to bring, and returns to your product. From then on your agent can read their approved context. The quickstart covers the whole loop on one page. For the thinking behind the flow itself, see Plaid for AI: why agents need a connect button.
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