Agentic Data Engineering Resources

Resource

What Is Airbyte Agents? A Guide for Engineering Teams

Discover how Airbyte Agents gives AI agents typed, authenticated access to SaaS APIs with Python connectors and hosted multi-tenant credentials.

Pedro Lopez

August 24, 2026

Summarize with AI:

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 Agents exists to take that infrastructure off your plate.

TL;DR

Airbyte Agents separates two concerns: open-source Python agent connectors for typed API access and a hosted Airbyte Agents 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 Agents?

Airbyte Agents 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 Agents 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 Agents 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[&quot;GITHUB_ACCESS_TOKEN&quot;]
    )
)</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 Agents 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=&quot;&lt;your_external_user_id&gt;&quot;,
        airbyte_client_id=&quot;&lt;your-client-id&gt;&quot;,
        airbyte_client_secret=&quot;&lt;your-client-secret&gt;&quot;
    )
)</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 Agents Platform Do?

The Airbyte Agents 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 Agents, 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 Agents 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 Agents Work With MCP?

Airbyte Agents 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 Agents?

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 Agents?

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 Agents 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 Agents 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 Agents powers production AI agents with reliable, permission-aware data, or try Airbyte Agents today.

Frequently Asked Questions

What is Airbyte Agents?

Airbyte Agents 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 Agents 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 Agents support?

Airbyte Agents 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 Agents handle authentication for multiple users?

The Airbyte Agents 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.

Try Airbyte Agents

Airbyte connects your agents to all of your data and assembles context before they run. Build agents that actually know your business.

Try it free Talk to sales

What Is Airbyte Agents? A Guide for Engineering Teams

Related posts

Try Airbyte Agents