How to Use the Lindy (Autonomous AI Employees) MCP in OpenAI Agents SDK

Q: How does Lindy (Autonomous AI Employees) handle task execution inside the OpenAI Agents SDK?

Your SDK calls triggerlindy to spin up a task asynchronously. From there, the SDK polls the run state using getrun to check if the autonomous employee requires manual human intervention or external API inputs before completing.

Q: Can I stop runaway loops when using Lindy (Autonomous AI Employees) with the OpenAI Agents SDK?

Yes, you can. The OpenAI Agents SDK invokes cancelrun to send an immediate hard stop to any active execution loop. This prevents your agents from wasting API credits when a run gets trapped in an infinite logical loop.

Q: How do I debug reasoning failures in Lindy (Autonomous AI Employees) using the OpenAI Agents SDK?

You pull the raw execution history directly. Call getrunlogs through the OpenAI Agents SDK to isolate the exact LLM reasoning steps and debug why a specific run failed or stalled.

Q: How does this MCP Server handle agent configurations?

The server exposes getlindy to feed configuration mappings and prompt templates directly to your agent. Your SDK uses this data to understand what tools each autonomous employee has access to before delegating work.

Run autonomous Lindy employees with built-in safety guardrails and full tracing using the OpenAI Agents SDK.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Lindy (Autonomous AI Employees) MCP to OpenAI Agents SDK

Create your Vinkius account to connect Lindy (Autonomous AI Employees) 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 Lindy (Autonomous AI Employees) with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Run Lindy tasks securely via the OpenAI Agents SDK

The `trigger_lindy` tool allows OpenAI Agents SDK to connect to this MCP Server and initiate asynchronous task runs by passing raw JSON payloads directly into your workspace. Once fired, your agents watch execution loops using `get_run` to block on human approvals or wait for third-party API payloads. If an execution spins out of control, the SDK uses `cancel_run` to kill the process immediately. This tight loop control ensures your production agents never burn through your API budget on runaway recursive tasks.

Inspect agent reasoning and workspace configurations

The `get_run_logs` tool dumps literal LLM reasoning logs so your OpenAI Agents SDK can trace the exact decision paths of your autonomous employees. You get direct visibility into how a specific agent handled a task, making debugging production runs straightforward. Your SDK discovers custom agents using `list_lindies` and grabs their core configurations with `get_lindy`. This lets you verify custom system prompts and tools before your OpenAI Agents SDK routes a task to a specialized autonomous employee.

Map integrations across organizational boundaries

The `list_integrations` tool exposes active third-party connections like Gmail or Slack directly to your OpenAI Agents SDK. Your agents verify active communication channels before attempting to execute multi-step workflows. Isolation is maintained by using `list_workspaces` to partition teams, while `list_triggers` tracks how your autonomous employees wake up. This MCP Server setup ensures your OpenAI Agents SDK keeps data strictly separated across your entire organization.

Setup guide

Set up Lindy (Autonomous AI Employees) 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 Lindy (Autonomous AI Employees) tools at runtime.
3

Create your Agent

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

Run the agent

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

Your SDK calls `trigger_lindy` to spin up a task asynchronously. From there, the SDK polls the run state using `get_run` to check if the autonomous employee requires manual human intervention or external API inputs before completing.

Yes, you can. The OpenAI Agents SDK invokes `cancel_run` to send an immediate hard stop to any active execution loop. This prevents your agents from wasting API credits when a run gets trapped in an infinite logical loop.

You pull the raw execution history directly. Call `get_run_logs` through the OpenAI Agents SDK to isolate the exact LLM reasoning steps and debug why a specific run failed or stalled.

The server exposes `get_lindy` to feed configuration mappings and prompt templates directly to your agent. Your SDK uses this data to understand what tools each autonomous employee has access to before delegating work.

Your Slack and Gmail connections remain protected because this MCP Server only exposes active connection metadata through `list_integrations` without storing your credentials. Vinkius runs the server in an ephemeral sandbox, ensuring your private workspace structures remain isolated.

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