How to Use the Incident.io MCP in OpenAI Agents SDK

Q: How do I handle Incident.io rate limits in my OpenAI Agents SDK pipeline?

You set cacheToolsList=True when initializing the MCP Server connection in your Python code. This prevents the OpenAI Agents SDK from repeatedly querying the server for tool definitions like listincidents on every turn. For high-volume environments, we handle the API rate limits on our proxy layer to keep your agents running.

Q: How does the OpenAI Agents SDK handle on-call schedules from Incident.io?

The agent queries listschedules to retrieve your active rotations and matches them against listusers to find the current responder. Since the OpenAI Agents SDK allows agent-to-agent handoffs, you can have one agent detect the outage and another coordinate with the on-call engineer. This structure keeps your incident response organized and automated.

Build production-ready Incident.io triaging agents with the OpenAI Agents SDK that respect your guardrails and handle on-call handoffs.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Incident.io MCP to OpenAI Agents SDK

Create your Vinkius account to connect Incident.io to OpenAI Agents SDK and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Incident.io with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Triage production outages with OpenAI Agents SDK

This MCP Server exposes `list_incidents` and `get_incident` so your OpenAI Agents SDK system can fetch active outages and pull incident details during high-pressure events. Your agent uses these tools to read raw incident payloads, parse the current state, and make decisions without human intervention. Because the OpenAI Agents SDK supports strict guardrails, you can verify the output of `get_incident` before your agent passes the data to downstream systems. This setup prevents your LLM from acting on hallucinated outage metrics or misinterpreting critical severity levels.

Automate on-call handoffs via OpenAI Agents SDK

The `list_schedules` and `list_users` tools let your OpenAI Agents SDK agent identify who is currently active on-call and assign work directly to the right engineer. This eliminates the manual step of looking up rosters in the middle of the night. You can configure specialized agents within the OpenAI Agents SDK to pass the context of an outage from a triage agent to an on-call agent. The on-call agent receives the exact user ID from `list_users` and the schedule details from `list_schedules` to coordinate the response.

Map custom metadata with OpenAI Agents SDK

This MCP Server uses `list_custom_fields` and `list_catalog_types` to let your OpenAI Agents SDK agent query your organization's specific incident categorization schemas. The agent reads these fields to classify incoming issues according to your internal business rules. By combining `list_custom_fields` with the OpenAI dashboard's tracing features, you can monitor exactly how your agent maps incident metadata. If the agent misclassifies an outage, the trace shows you the exact tools invoked and the raw JSON returned from your server.

Setup guide

Set up Incident.io MCP in OpenAI Agents SDK

Prerequisites

Python 3.10+ installed
openai-agents package (pip install openai-agents)
Active Vinkius subscription with a valid endpoint token

1

Install the SDK

Run pip install openai-agents to install the OpenAI Agents SDK. The MCP integration is built-in — no extra dependencies needed.
2

Connect via SSE transport

Use MCPServerSse with your Vinkius endpoint URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. The SDK auto-discovers all Incident.io tools at runtime.
3

Create your Agent

Pass the MCP to Agent(mcp_servers=[server]). The agent receives Incident.io tools as native definitions — JSON schemas resolve automatically.
4

Run the agent

Call Runner.run(agent, prompt) to execute. The agent invokes the appropriate Incident.io tools and returns structured results. Copy the full example on the right to get started.

agent.py

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerSse

async def main():
    async with MCPServerSse(
        url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
    ) as server:
        agent = Agent(
            name="Incident.io Agent",
            instructions="You have access to Incident.io tools.",
            mcp_servers=[server],
        )
        result = await Runner.run(agent, "List recent transactions")
        print(result.final_output)

asyncio.run(main())

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Incident.io. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Incident.io now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Incident.io MCP in OpenAI Agents SDK

You set `cacheToolsList=True` when initializing the MCP Server connection in your Python code. This prevents the OpenAI Agents SDK from repeatedly querying the server for tool definitions like `list_incidents` on every turn. For high-volume environments, we handle the API rate limits on our proxy layer to keep your agents running.

Yes, you control this by defining specific agent schemas or using the guardrails in the OpenAI Agents SDK. You can explicitly block the agent from calling tools like `list_users` or limit its scope to read-only queries like `list_severities`. This ensures your agent only interacts with the exact endpoints you permit.

The agent queries `list_schedules` to retrieve your active rotations and matches them against `list_users` to find the current responder. Since the OpenAI Agents SDK allows agent-to-agent handoffs, you can have one agent detect the outage and another coordinate with the on-call engineer. This structure keeps your incident response organized and automated.

You use the OpenAI developer dashboard to trace every tool execution, including calls to `list_incident_types` or `list_incident_roles`. The dashboard logs the exact inputs passed to the MCP Server and the raw JSON payload returned. This makes it easy to spot if your agent is passing incorrect IDs during an active incident.

Your incident details, user rosters, and custom fields never persist on our servers. We run a zero-trust, ephemeral V8 Isolate sandbox to route requests between the OpenAI Agents SDK and the API. Your credentials are encrypted and used only to authorize direct calls to tools like `get_incident`.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript