The hardest part of building an AI agent isn't the agent. It's everything between the agent and the data: authentication flows, schema handling, token refresh, credential isolation per customer. That infrastructure consumes more development time than the reasoning logic it supports. A proof of concept with two integrations works fine, but a production app with twenty data sources and a hundred end users turns your team into an OAuth maintenance crew instead of an AI engineering team.
Airbyte's agentic platform exists to take that infrastructure off your plate.
TL;DR Airbyte's agentic platform separates two concerns: open-source Python agent connectors for typed API access and a hosted Airbyte's agentic platform platform for multi-tenant credential management.Agent connectors work as standalone Python packages inside any framework (Pydantic AI, LangChain, MCP) without the Airbyte platform. Hosted mode handles OAuth flows, token refresh, and per-customer credential isolation so your team doesn't build auth infrastructure per provider. Start with open-source agent connectors for single-environment work, then add the platform when you need multi-customer authentication and data isolation. What Is Airbyte's Agentic Data Platform? Airbyte's agentic platform is Airbyte's platform for giving AI agents typed, authenticated read and write access to SaaS APIs. It wraps authentication, type safety, and error handling into two components that serve different stages of product development.
The first is a library of agent connectors: open-source Python packages that let AI agents call third-party APIs through strongly typed, well-documented tools. Each agent connector works as a standalone package you install with pip or uv and import into your Python app, agent framework like Pydantic AI or LangChain , or Model Context Protocol (MCP) server.
The second is the Airbyte's agentic platform platform, a subscription-based cloud service that manages credentials, customer isolation, and data replication for multi-tenant applications where each customer connects their own SaaS accounts. It handles OAuth (Open Authorization) flows, token refresh, and credential storage so your engineering team doesn't build this infrastructure per provider.
What Are Agent Connectors? Agent connectors are open-source Python packages that let AI agents call SaaS APIs in real time and get back typed responses. Unlike Airbyte's data replication connectors, which move data from sources to destinations on a schedule, agent connectors run inside your application and return results directly as the agent reasons.
Dimension Data Replication Connectors Agent Connectors Purpose Batch extract-load-transform / extract-transform-load (ELT/ETL): build a full historical dataset in a warehouse or data lake Operational AI: answer a question, fetch fresh data, or perform an action while an agent reasons Topology Source-to-destination pairing managed by the Airbyte platform Standalone Python packages imported into your app or agent; no pairing or sync pipeline Execution Jobs orchestrated by the platform with schedules and state tracking Runs inside your Python app or agent loop and returns results immediately Data flow Writes data into destinations; maintains state for incremental sync Streams typed responses back to the caller and supports write actions (create, update). Optional Context Store replicates a data subset for search operations. Platform required Yes (Airbyte Cloud or Self-Managed) No, works as regular Python packages. Platform optional for multi-customer credential management Relationship Complements agent connectors; use for building historical datasets Complements replication connectors; use for on-demand agent data access
Each agent connector lives in the Airbyte Agent Connectors repository and ships with a Python client with typed methods generated from Airbyte's agent connector definitions, documentation specific to each agent connector covering supported operations and authentication requirements, and built-in input validation.
The typed interface matters because it reduces hallucination risk. When an agent calls an agent connector, it gets back typed response objects, not raw JSON that needs parsing and validation. The agent works with structured data that matches a defined schema, which also eliminates the engineering work of writing custom response parsers for each API.
Each agent connector exposes a unified interface through the execute method. It takes an entity (like "customers"), an action (like "list" or "create"), and optional parameters. Results stream back as typed Python objects, and the agent connector handles authentication, schema validation, and error handling consistently regardless of which SaaS API it wraps. Beyond read operations, agent connectors also support write actions, letting agents create records, update fields, and trigger workflows in connected systems.
Airbyte publishes a growing library of agent connectors covering CRMs, marketing platforms, developer tools, support systems, and more, with new agent connectors added weekly. For the full list of available agent connectors and their documentation, see the agent connectors page .
Every agent connector shares a single interface, which means the real question isn't whether your agent can talk to these APIs. It's how you manage credentials when each of your customers needs their own connection.
How Do Agent Connectors Work? Each agent connector supports two execution modes, and the choice depends on whether you are building for a single environment or managing data access for multiple customers.
Dimension Open Source Mode Hosted Mode Credential storage You store API credentials locally (e.g., .env file) Airbyte Cloud stores credentials securely Authentication You provide credentials directly to the agent connector You provide Airbyte client_id and client_secret; platform handles provider auth Multi-customer support You manage credential isolation yourself Each customer gets an isolated environment with separate credentials, agent connectors, and data Platform dependency None (pure Python package) Requires Airbyte's agentic platform platform Best for Single-environment development, prototyping, personal tools Multi-tenant applications where customers connect their own SaaS accounts Setup complexity Lower: install agent connector package, provide API key, call operations Higher: set up platform account, enable agent connectors, implement managed authentication
Open Source Mode Install the agent connector package, provide API credentials, and call operations directly. A GitHub agent connector in open source mode looks like this:
<pre > <code > from airbyte_agent_github import GithubConnector
from airbyte_agent_github.models import GithubPersonalAccessTokenAuthConfig
connector = GithubConnector(
auth_config=GithubPersonalAccessTokenAuthConfig(
token=os.environ[" GITHUB_ACCESS_TOKEN" ]
)
)</code > </pre > You then register the agent connector's execute method as a tool in your agent framework. With Pydantic AI, this looks like:
<pre><code >@agent .tool_plain
@GithubConnector.tool_utils
async def github_execute(entity : str, action : str, params : dict | None = None):
return await connector.execute(entity, action, params or {})</code ></pre>This is the fastest path from zero to a working agent-API integration.
Hosted Mode When your application serves multiple customer environments, each with its own Salesforce account, Stripe keys, and HubSpot instance, managing credentials locally doesn't scale. In hosted mode, you provide your Airbyte client_id and client_secret plus an identifier for the customer environment. The Airbyte's agentic platform platform stores each customer's provider credentials securely and handles token refresh. For example, a Linear agent connector in hosted mode looks like this:
<pre > <code > from airbyte_agent_linear import LinearConnector, AirbyteAuthConfig
connector = LinearConnector(
auth_config=AirbyteAuthConfig(
external_user_id=" < your_external_user_id> " ,
airbyte_client_id=" < your-client-id> " ,
airbyte_client_secret=" < your-client-secret> "
)
)</code > </pre > The difference between modes is where credentials live and who manages them. In hosted mode, API calls proxy through Airbyte rather than going directly to the vendor. This gives the platform a central point for audit trails and automatic token rotation. Sensitive API credentials never leave Airbyte's infrastructure.
That convenience comes with a tradeoff. The proxy adds a network hop. For most use cases the latency is negligible, but teams with strict performance requirements should test with their specific agent connectors before committing to hosted mode for latency-sensitive paths.
What Does the Airbyte's agentic platform Platform Do? The Airbyte's agentic platform platform adds infrastructure that multi-tenant applications need but teams rarely want to build themselves. Customer isolation, managed authentication, and a context store each address a distinct production requirement.
Customer Isolation In Airbyte's agentic platform, a "customer" represents an end user of your service who connects their own data sources. Each customer gets an isolated environment with separate credentials, separate agent connector configurations, and separate data. When you build a customer support agent that accesses each customer's Zendesk instance, Airbyte's agentic platform keeps Customer A's tickets completely isolated from Customer B's. The API uses the terms workspace and external_customer interchangeably to refer to a customer environment.
The platform enforces this isolation through a token hierarchy. Operator tokens provide organization-wide access with a 15-minute expiration. Scoped tokens restrict access to a single customer's data with a 20-minute expiration. This two-tier system scopes each API call to exactly one customer's environment, and the short expiration windows limit exposure if a token is compromised.
Managed Authentication Managed authentication separates organization-level Airbyte credentials from provider credentials stored for each customer environment. Your backend scopes operations to the correct customer environment without handling OAuth tokens directly.
Context Store The Context Store is Airbyte-managed storage that copies a subset of data from connected agent connectors for search actions. It selects data it considers relevant to search, maintains isolated data stores per source, and refreshes hourly. Agents can query the Context Store with sub-second latency, which avoids the processing time and cost of complex queries against live vendor APIs.
The Context Store populates automatically during initial setup. Initial population time depends on the volume of data in your connected sources, and you can't run search actions until the first full population completes. The refresh rate is fixed at hourly and can't be configured, but you can disable the Context Store entirely. When you disable it, Airbyte removes cached data from storage. Re-enabling requires a full re-sync from scratch.
Engineers who have configured their own object storage can skip the Context Store and make that data available to agents through self-implemented tools instead.
How Do Airbyte's agentic platform Work With MCP? Airbyte's agentic platform provides Agent MCP for agent development. Agent MCP connects AI agents to business data through MCP, giving authenticated access to platforms like CRM, support desk, and analytics tools so the agent can read and write on the user's behalf.
Through the MCP Gateway , an AI agent's tool calls and data fetches route through one place rather than dozens of individual MCP servers for every tool in your stack. Airbyte hosts and manages this endpoint, and it works with MCP clients including Claude, Claude Code, ChatGPT, Codex, Cursor, VS Code, and Windsurf.
Agent MCP also gives teams a central point for governance and observability. Every tool call is logged, including which agent connector was used, which entity was queried, what action was taken, and when. MCP gives agents a protocol-level way to discover and call agent connectors, but the harder problem, managing which credentials each customer's agent is allowed to use, still requires the platform layer.
When Should You Use Airbyte's agentic platform? Agent connectors fit when your agent calls SaaS APIs during its reasoning loop and needs consistent behavior across providers.
Live API Access During Agent Reasoning Your agent needs to query SaaS data mid-reasoning rather than work from a pre-loaded dataset. If an agent reads from a CRM system, billing platform, or analytics tool while deciding what to do next, agent connectors give it direct access with guardrails against malformed responses.
Frequent Integration Expansion You're adding new SaaS integrations regularly and need your agent orchestration code to stay stable. Because every agent connector shares a common interface, adding a data source means installing a package, not rewriting framework integration code.
Multi-System Coordination in a Single Agent A single agent coordinates across GitHub, Jira, Salesforce, or other systems in one reasoning loop. Each agent connector is a standard Python dependency, so composing them requires no adapter code or custom abstraction layers.
Add the platform when your application goes multi-tenant and you need managed credential infrastructure. If your use case is batch data replication to a warehouse or data lake, use Airbyte's data replication connectors instead. Agent connectors are for operational AI access with sub-second response times, not historical data consolidation.
How Do You Get Started With Airbyte's agentic platform? Start with the open-source agent connectors. Install an agent connector package, provide an API key, and call operations from your agent in minutes. The Agent SDK fits this path, and the Pydantic AI tutorial walks through building a Pydantic AI agent with a GitHub agent connector from scratch. You create a project with uv, add the agent, and build a command-line chat interface for natural language data interaction. The MCP tutorial shows how to expose agent connectors to Claude Code through natural language.
When your application needs multi-customer credential management, add the Airbyte's agentic platform platform. The hosted execution tutorial covers setting up platform credentials, creating customer-scoped tokens, and running agent connector operations through Airbyte's infrastructure. The sooner you validate the agent connector interface in a single-tenant prototype, the less rework you face when multi-tenant requirements arrive.
What's the Simplest Way to Productionize Agent Data Access? The gap between a working agent prototype and a production multi-tenant application is almost entirely infrastructure. Airbyte's agentic platform closes that gap by separating typed API access from multi-tenant credential management, so teams adopt each layer only when they need it.
For agents that need relevant context before taking action, Context Store adds a search-optimized layer over connected business systems. It pre-materializes context before runtime, which helps reduce live-query latency, token consumption, and context bloat. Together with typed agent connectors and managed credentials, it gives engineering teams a path from single-environment prototyping to production multi-tenant deployments without rebuilding integration infrastructure at each stage.
Get a demo to see how Airbyte's agentic platform powers production AI agents with reliable, permission-aware data, or try Airbyte's agentic platform today.
Frequently Asked Questions What is Airbyte's agentic platform? Airbyte's agentic platform is Airbyte's platform for giving AI agents typed, authenticated read and write access to SaaS APIs. It includes open-source Python agent connectors that agents import and call directly, and a hosted platform that manages credentials and data replication for multi-tenant applications. The agent connectors work as standalone packages without the Airbyte platform, or through the platform for multi-customer credential management.
How are agent connectors different from Airbyte's data replication connectors? Data replication connectors move large volumes of data from sources to destinations on a schedule. Agent connectors are lightweight Python packages that let AI agents call SaaS APIs on demand and return typed responses immediately. These agent connectors and replication connectors complement each other.
Do I need the Airbyte's agentic platform platform to use agent connectors? No. Agent connectors are regular Python packages you install and use without any Airbyte platform. In open source mode, you provide API credentials directly and manage them yourself. The platform is needed when your application serves multiple customers who each connect their own SaaS accounts.
What SaaS tools does Airbyte's agentic platform support? Airbyte's agentic platform provides a growing library of agent connectors for SaaS tools including Salesforce, HubSpot, Slack, Jira, Notion, Google Drive, Stripe, and GitHub, with new agent connectors added weekly. See the full list on the agent connectors page.
How does Airbyte's agentic platform handle authentication for multiple users? The Airbyte's agentic platform platform manages OAuth flows, token refresh, and secure credential storage for connected SaaS accounts. Each customer gets an isolated environment with separate credentials and data, and your agent provides a customer identifier to scope operations to the correct environment.
