Email context for your AI agents. Try iGPT
Agent200

200 OK Infrastructure for AI agent developers

Stop wiring tools.
Start building agents.

One secure API integration for apps, tools, authentication, discovery, skills, and context.

Book a Demo See how it works

How it works

Your agent asks.
Agent200 gets it done.

Agent200 connects to each service your agent needs, runs every step and delivers the result where it belongs.

Your app

Prep my Monday brief: Q4, churn and board items. Post it to #leadership.

Reading this week's email with iGPT via

Using Agent200

Posted. Your Monday brief is in #leadership.

Agent200
  1. iGPT Connect to iGPT
  2. iGPT Find Q4 and board threads Across email and attachments
  3. Slack Connect to Slack
  4. Slack Post the brief to #leadership
Slack

#leadership

Slack

Today

Noa Katz 8:52 AM

Anything I should know before board prep?

Dana Levi 9:00 AM

Monday brief: the Q4 forecast locks Thursday, before the board meeting. Churn is up in two enterprise accounts. Board deck comments due Wednesday.

You choose which services your agent can reach, down to every single action.

your-agent.js
Conceptual example
A conceptual Agent200 run request: a user identity, a model, instructions, an input and two available tools named igpt and slack.
const result = await agent200
  .user("user_123")
  .run({
    model: "openai/gpt-5.6-sol",
    instructions: "You are an executive assistant.",
    input: `Prep my Monday brief: Q4, churn and board items.
            Post it to #leadership.`,
    tools: ["igpt", "slack"],
  });

Illustrative result

200 OK

Posted your Monday brief to #leadership. The Q4 forecast locks on Thursday, before the board meeting; churn is up in two enterprise accounts; and the board deck needs your comments by Wednesday…

Agent200 execution

  1. run() received

    Request

    user_123 · openai/gpt-5.6-sol · 2 tools available

  2. Model reads the task

    Reasoning

    Agent200 provides the tool definitions for igpt and slack

  3. igpt

    200 OK

    Tool call → iGPT connector: this week's email on Q4, churn and the board

  4. slack

    200 OK

    Tool call → Slack connector, posting to #leadership with user_123's authorized connection

  5. Result returned to your app

    Done

    The model composes the brief from the tool results and confirms the post

One request. The model decides which tools to use; Agent200 executes them against the services your user has authorized and hands the result back to your app.

The problem

The model is the easy part.

An agent that reads Slack, searches Gmail and browses the web needs an integration, an OAuth flow, token storage, tool schemas, execution logic and a billing relationship for every single service. Then the next agent needs all of it again.

With Agent200

1 SDK · 1 API key

Your agent talks to Agent200. Agent200 talks to the providers on its behalf.

Your agent

Agent200

agent200.run()

  • OpenAI
  • Slack
  • Gmail
  • Tavily

Handled by the platform

  • Tool schemas
  • Execution logic
  • Permissions
  • Credential management
  • Usage tracking
  • One consolidated bill

Your users still authorize access to their own connectors. Agent200 manages the OAuth flow without bypassing the provider’s authorization process.

Without Agent200

4 integrations to maintain

Every provider is its own project: its own credentials, API, authentication and bill.

Your agent
  • OpenAI API key Model API
  • Slack OAuth API Tokens
  • Gmail OAuth API Tokens
  • Tavily API key Search API

Also yours to build and maintain

  • Tool schemas
  • Execution logic
  • Permissions
  • Credential management
  • Usage tracking
  • Separate billing

Every API is different

Endpoints, auth, request formats and response shapes change with each provider. Agent200 talks to them so your agent uses one SDK.

OAuth is a project of its own

Authorization screens, callbacks, token storage, refresh and user-to-account mapping are handled centrally for supported services.

Vendors multiply

Each model and paid service brings another key and another invoice. Through Agent200 it is one API key and one bill.

Integrations

One SDK reaches all of these.

Our examples lean on Slack and Gmail because everyone knows them. The same run() call reaches every service here, and the list keeps growing.

Explore integrations

iGPT Meet iGPT Premium connector Your users' email, already indexed. One request, a cited answer.
Communication
  • Slack
  • Microsoft Teams
  • Discord
  • Zoom
  • Telegram
  • WhatsApp
  • Google Meet
  • Twilio
Email and calendar
Files and knowledge
  • Google Drive
  • OneDrive
  • Dropbox
  • Notion
  • Confluence
  • Airtable
  • Obsidian
  • Miro
CRM and sales
  • HubSpot
  • Salesforce
  • LinkedIn
  • Zendesk
  • Stripe
  • Shopify
  • Apollo.io
  • Xero
Developer tools
  • GitHub
  • GitLab
  • Bitbucket
  • Jira
  • Linear
  • Sentry
  • Vercel
  • Supabase
Search and data
  • Tavily
  • Exa
  • Firecrawl
  • Brave Search
  • Perplexity
  • Google Maps
  • YouTube
  • Wikipedia
AI models
  • OpenAI
  • Anthropic
  • Google Gemini
  • Meta
  • Mistral
  • Cohere
  • xAI
  • AWS

One platform

Five jobs you no longer do yourself.

Agent200 is a single platform, not a bundle of products. Each part exists to make the others useful.

  1. 01 Integration One SDK instead of many separate integrations. Connectors communicate with each provider's API on your agent's behalf.
  2. 02 Identity One managed authorization system for supported connectors. OAuth flows, callbacks, token refresh and per-user connections, handled for you.
  3. 03 Capabilities Reusable tools built from one or more endpoints. Configure a capability such as brief once, then reference it by name.
  4. 04 Execution Model-driven tool calling, managed inside run(). The model chooses tools; Agent200 executes them and feeds results back until the task is done.
  5. 05 Commerce Unified access and billing for paid providers. Use supported models and paid services without separate provider keys or invoices.

Model-driven execution

More than a proxy.
It runs the loop.

Call run() with a model, an input and the tools you allow. Agent200 gives the model its tool definitions, executes whatever it calls, returns the results, and repeats until there is a final response.

  1. Your app

    agent200.run()

    model, instructions, input and tools: ["brief"]

  2. Agent200 · model

    AI model

    Reads the task and the tool definitions, then chooses which tools to call, if any.

    Tool definitions provided

    brief · name, description, inputs

    Repeats until complete

    Each tool result returns to the model, which may reason further or call another tool.

  3. Agent200 · tool execution

    Calls: brief

    Custom workflow
    • Slack API Retrieve relevant messages
    • Gmail API Retrieve relevant emails
    Combined result Returned to the model as one tool result

  4. Your app

    Final response

    200 OK

    Returned to your code, to use in the rest of your agent's flow.

  1. 1 /Your app calls run() with a model, an input and the tools the model may use.
  2. 2 /Agent200 invokes the model and provides the tool definitions. The model decides what, if anything, to call.
  3. 3 /The model requests brief. It only needs the capability's description and inputs, not the endpoints behind it.
  4. 4 /Agent200 executes the workflow you configured: Slack and Gmail are called with the end user's authorized connections.
  5. 5 /The combined result goes back to the model, which can keep reasoning or call another tool. The loop repeats until the request is complete.
  6. 6 /The model produces the final response and Agent200 returns it to your app.
How execution works

Custom workflows

Configure it once.
Call it by name.

Combine endpoints from one or more services into a reusable capability. A workflow named brief can pull the relevant Slack messages and Gmail emails, combine them, and hand the model one structured result.

In your run() request

tools: ["brief"]

Agent200 knows which endpoints belong to brief and executes the configured workflow whenever the model invokes it.

capability brief
Concept · planned builder
Conceptual diagram of the planned Agent200 workflow builder for the capability brief: Workflow input feeds Slack Retrieve relevant messages and Gmail Retrieve relevant emails in parallel; their responses flow into Combine results, which produces Return data to the model. This is not an existing dashboard interface.
Input

Workflow input

What the model passes when it calls brief

Slack

Retrieve relevant messages

Gmail

Retrieve relevant emails

Combine

Combine results

Apply the configured output structure

Result

Return data to the model

One tool result, from two services

Illustrative The canvas above sketches how a workflow assembles a capability from several endpoints. Read it as a diagram of the idea, not a picture of the interface.

Explore workflows

OAuth and permissions

Your users' accounts.
Their authorization.
Your rules.

An API key never unlocks someone's private data. Each end user authorizes their own accounts through an OAuth flow that Agent200 manages, and you decide which endpoints your agent may touch.

Every request runs as one user

Connections belong to individual end users inside your project. A request for user_123 can only ever use user_123's authorized accounts.

How managed OAuth works
A request made for user_123 uses only the Slack and Gmail accounts that user_123 authorized. The connections that belong to user_456 in the same project are not used.

Request from your app

agent200.user("user_123").run({ … })

  1. 01 The request names the end user it runs for.
  2. 02 Agent200 looks up that user's connections in your project.
  3. 03 Tools execute with those credentials, and no one else's.
Conceptual interface

Developer project

  • user_123 Used for this request
    • Slack account A resolved for this request
    • Gmail account A resolved for this request
  • user_456 Not used
    • Slack account B isolated from this request
    • Gmail account B isolated from this request

You choose what the agent can do

Enable services, endpoints and OAuth scopes per project. Let an agent search Gmail without ever being able to send from it.

Security and data handling
Example permission configuration. Slack: search messages and retrieve messages are allowed; send messages and delete messages are blocked. Gmail: read emails is allowed; send emails and delete emails are blocked.
Endpoint permissions Concept

Slack

  • Search messages read Allowed
  • Retrieve messages read Allowed
  • Send messages write Blocked
  • Delete messages write Blocked

Gmail

  • Read emails read Allowed
  • Send emails write Blocked
  • Delete emails write Blocked

This configuration determines what Agent200 may expose to the model or execute for your app. You also select the OAuth scopes each connector requests.

Framework independent

Keep the Agent you have.

Agent200 doesn't ask you to adopt a framework or hand over your agent. Add the SDK to what you already run and call it when your agent needs the outside world.

  • LangGraph
  • OpenAI Agents SDK
  • CrewAI

You own

  • The agent and its orchestration
  • Your framework, language and app architecture
  • Business logic and the user experience
  • When the agent runs: scheduling stays in your app
  • Which services, endpoints, models and capabilities are allowed

Agent200 handles

  • Communication with each external provider's API
  • OAuth flows, callbacks, token storage and refresh
  • Per-user connections and their mapping to your users
  • The model and tool-calling loop inside each run() request
  • Access to paid models and services, with one bill

Pricing

Pay for what your agent consumes. Not for the wiring.

Eligible connector operations
No connector fee
Paid models and services
Provider-level usage price
Provider keys and invoices
One key, one bill

This is Agent200's intended pricing model. Billing details are still being finalized.

How pricing works

Use cases

What will your agent reach?

A few of the agents developers can build when external capabilities stop being the hard part.

See all use cases

  • Productivity agent

    Reads the relevant Gmail emails and Slack conversations, then has a model prepare a brief.

    GmailSlackModel

  • Sales agent

    Combines customer details from supported CRM, email and search services before a meeting.

    CRMEmailSearch

  • Operations agent

    Pulls context from supported development and communication services to investigate incidents.

    DevToolsChat

  • Research agent

    Uses a search service such as Tavily alongside AI models, with one key and one bill.

    TavilyModel

  • Multi-service automation

    Wraps an operation that spans several systems into one reusable capability.

    WorkflowConnectors

Illustrative scenarios. They describe what Agent200 is designed for, not a list of connectors available today.

200 OK

Build the agent.
Access everything it needs.

Bring the agent you already have. Agent200 provides and executes its external capabilities.

Book a Demo Read the docs (opens in a new tab)

Book a demo.
See it in action.

Tell us who you are, then pick a time for a 1:1 session with an expert from our team.

We use your details only to email you about Agent200. See the Privacy Policy.

Pick a time. We'll take it from there.

A 1:1 session with an expert from our team, about what you are building.

Open in Calendly (opens in a new tab)