How to Use the Conductor (Netflix OSS) MCP in OpenAI Agents SDK

Q: How do I register the Conductor (Netflix OSS) MCP tools inside my OpenAI Agents SDK project?

Install the SDK via pip first. Instantiate MCPServerStreamableHttp pointing to your Vinkius endpoint, then pass that server instance into the Agent constructor within your async context manager.

Q: Can my OpenAI Agents SDK agent recover failed tasks automatically in Conductor (Netflix OSS)?

Yes, it can. The agent uses retryworkflow or rerunworkflow to recover from transient failures, and you can program guardrails to ensure it only retries specific task types.

Q: How does this Conductor (Netflix OSS) integration handle high-frequency polling with OpenAI Agents SDK?

The server handles long polling natively. Your agent calls polltask or pollbatchtasks to fetch work items from queues, while getqueuesize monitors queue depth to prevent overloading your workers.

Manage complex distributed jobs from your OpenAI Agents SDK pipelines with zero-config MCP tool discovery.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Conductor (Netflix OSS) MCP to OpenAI Agents SDK

Create your Vinkius account to connect Conductor (Netflix OSS) 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 Conductor (Netflix OSS) with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Run and track workflows with OpenAI Agents SDK

This MCP server exposes `execute_workflow` and `start_workflow` directly to your python runtime. Your agent triggers asynchronous runs or waits for synchronous execution results without you writing boilerplate API wrappers. If a job gets stuck, the agent inspects the failure by calling `get_workflow_tasks` or `get_task_logs`. It diagnoses the exact step that failed and appends a log entry via `add_task_log` to keep your history clean.

Bulk operations for high-throughput pipelines

This execution server handles massive scale through bulk operations. The server hands your agent tools like `bulk_pause`, `bulk_retry`, and `bulk_terminate` to manipulate state across your entire cluster in one shot. Finding specific runs is straightforward. The agent runs `bulk_search` or `search_workflows_v2` to isolate failing runs, then applies `bulk_restart` to kick off recovery procedures without manual intervention.

Dynamic task and definition updates

This workflow server manages system schemas and execution topologies. Your agent modifies active topologies on the fly when business logic changes using `create_workflow_definition` and `create_task_definitions`. Before saving any changes, the agent runs `validate_workflow_definition` to catch syntax errors early. It updates existing paths using `update_workflow_definitions` or updates individual steps with `update_task_definition`.

Setup guide

Set up Conductor (Netflix OSS) 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 Conductor (Netflix OSS) tools at runtime.
3

Create your Agent

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

Run the agent

Call Runner.run(agent, prompt) to execute. The agent invokes the appropriate Conductor (Netflix OSS) 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="Conductor (Netflix OSS) Agent",
            instructions="You have access to Conductor (Netflix OSS) 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 Conductor (Netflix OSS). 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 Conductor (Netflix OSS) 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 Conductor (Netflix OSS) MCP in OpenAI Agents SDK

Install the SDK via pip first. Instantiate `MCPServerStreamableHttp` pointing to your Vinkius endpoint, then pass that server instance into the `Agent` constructor within your async context manager.

Yes, it can. The agent uses `retry_workflow` or `rerun_workflow` to recover from transient failures, and you can program guardrails to ensure it only retries specific task types.

The server handles long polling natively. Your agent calls `poll_task` or `poll_batch_tasks` to fetch work items from queues, while `get_queue_size` monitors queue depth to prevent overloading your workers.

You configure tool access at the Vinkius gateway level. This limits the agent to read-only actions like `get_workflow` if you want to prevent it from executing or deleting definitions.

Your workflow definitions and execution logs remain strictly inside your Conductor cluster. Vinkius runs the adapter in an ephemeral, zero-trust sandbox that never persists your task payloads or credentials.

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