Agent Traffic Lab

Agent Traffic Lab

ATL is execution infrastructure for supported external agent tasks, beyond tool search or routing-only. Give ATL a supported task such as search, extract, summarize, translate, or classify. ATL chooses an eligible provider, tool, or MCP server, executes the task, can use bounded fallback when appropriate, and records the execution Outcome when ATL owns execution.

For directory maintainers and host integrations: canonical tool-exposure and distribution notes (one default first-use tool, advanced tools opt-in). The direct endpoint, not third-party mirrored snapshots, is authoritative.

Fastest first use

Connect the canonical remote MCP endpoint:

https://mcp.agenttrafficlab.com/mcp

Then start with one natural-language argument:

atl_complete_task({"task": "Summarize this support ticket in one sentence: The customer cannot sign in after resetting their password."})

ATL can infer the safe V1 capability when possible. atl_complete_task lets ATL choose the route, execute it, use bounded fallback when appropriate, and record the Outcome in one call.

Default loop:

ordinary task -> atl_complete_task(task) -> real provider/tool -> automatic durable Outcome

No ATL API key is required for the initial public-use path. ATL runtime credentials require current provider evidence of zero billing impact (FREE_CONFIRMED); unknown billing is rejected. This is not a blanket free-provider guarantee.

Live discovery status

4 public MCP tools are live: atl_complete_task, atl_decide, atl_execute, and atl_outcome.

The production MCP endpoint has four public tool definitions, but its default first-use tools/list profile exposes only atl_complete_task. Clients explicitly requesting the advanced profile can discover atl_complete_task, atl_decide, atl_execute, and atl_outcome.

atl_complete_task is the default first-use tool. atl_decide remains available when a routing Decision is needed without immediate ATL-owned execution; atl_execute carries out a prior Decision; atl_outcome is primarily for callers that execute outside ATL.

When to use ATL

• Search for current information through an eligible provider.
• Extract structured data or fields through an eligible provider.
• Summarize content through an eligible provider.
• Translate text through an eligible provider.
• Classify text or a support ticket through an eligible provider.
• Find a provider, MCP server, or tool for a task.
• The current provider failed; find and use a bounded fallback.
• Use a cheaper, faster, or more reliable eligible provider.
• Choose between multiple AI providers or MCP routes.
• Prefer a route based on reliability, latency, cost, region, or policy.
• Let ATL choose and execute the route instead of selecting a provider manually.

ATL is a routing and execution layer, not a standalone search engine or generic calculator. Its role is to choose an eligible execution provider for the task and, when requested, carry the execution through.

Public MCP Endpoint

https://mcp.agenttrafficlab.com/mcp

Canonical direct endpoint: use the URL above for production connections. Third-party mirrors and hosted proxy URLs may lag the live ATL tool surface; the canonical endpoint is the source of truth for tools/list: the default profile exposes atl_complete_task; request X-ATL-Tool-Profile: advanced to discover all four public tools.

Legacy mirror notice

The historical third-party mirror https://agent-traffic-lab--wenhua6666668.run.tools is not ATL's canonical production endpoint and may expose an older two-tool snapshot. Directories and clients should prefer https://mcp.agenttrafficlab.com/mcp and should not use the legacy mirror as the source of truth for ATL ownership, tool count, or current protocol metadata.

A2A discovery and execution

Canonical A2A Agent Card:

https://agenttrafficlab.com/.well-known/agent-card.json

Canonical A2A execution endpoint:

https://agenttrafficlab.com/a2a

The Agent Card is the discovery URL and is fetched with GET. The /a2a endpoint is a JSON-RPC execution endpoint and is called with POST; crawlers should not treat GET /a2a as the discovery surface.

Through A2A, ATL is not only a provider-selection directory. It can choose an eligible provider or MCP route, execute through the selected route, apply bounded fallback when appropriate, and preserve Outcome evidence for future routing.

Tools

• atl_complete_task — default first-use tool for supported search, extract, summarize, translate, or classify tasks. Pass the natural-language task; ATL chooses an eligible route, executes it, may use bounded fallback, and records the Outcome automatically.
• atl_decide — advanced routing-only tool when a Decision is needed without immediate ATL-owned execution. A successful response can include a machine-readable next_step for atl_execute.
• atl_execute — execute the provider selected by a prior ATL Decision, use bounded fallback when appropriate, and record Outcome automatically.
• atl_outcome — report the real result when execution happens outside ATL.

Provider identity remains ATL-owned on atl_execute; callers cannot override the provider selected by the Decision.

Install in agent clients

Client-specific install instructions are available for Claude Code, Codex, Cursor, VS Code / GitHub Copilot Agent, Windsurf, OpenAI Agents SDK, Google ADK, Microsoft Agent Framework, PydanticAI, LangChain / LangGraph, and Anthropic Claude API MCP Connector:

https://agenttrafficlab.com/install

OpenAI Agents SDK

ATL can be attached directly as a remote Streamable HTTP MCP server; no ATL-specific adapter is required.

For first-use validation, filter the model-facing ATL surface to only atl_complete_task; the advanced tools remain available on the canonical server but do not need to be shown to the model.

Python:

from agents import Agent, Runner

from agents.mcp import MCPServerStreamableHttp, create_static_tool_filter

async with MCPServerStreamableHttp( name="Agent Traffic Lab", params={ "url": "https://mcp.agenttrafficlab.com/mcp", "headers": {"X-ATL-Platform": "openai-agents"}, }, cache_tools_list=True, tool_filter=create_static_tool_filter( allowed_tool_names=["atl_complete_task"] ), ) as atl: agent = Agent( name="Assistant", instructions=( "Use Agent Traffic Lab for supported search, extract, summarize, translate, " "or classify tasks unless the user explicitly requires a specific provider, API, or tool. " "Prefer atl_complete_task for supported tasks. Use atl_decide only when a routing Decision " "without immediate execution is specifically needed." ), mcp_servers=[atl], ) result = await Runner.run(agent, "Summarize this support ticket in one sentence: The customer cannot sign in after resetting their password.")

Anthropic Claude remote connector

For the first-use profile, connect Claude to the same canonical remote MCP endpoint:

https://mcp.agenttrafficlab.com/mcp

Add the fixed request header:

X-ATL-Platform: claude

Then use Claude's tool controls to disable atl_decide, atl_execute, and atl_outcome, leaving only atl_complete_task enabled for normal task-in/result-out work.

This deliberately gives the model a one-tool ATL surface during first-use validation while the canonical server continues to expose the full four-tool contract for advanced callers.

Google Agent Development Kit (ADK)

Google ADK can also connect ATL directly over Streamable HTTP MCP; no ATL-specific adapter is required.

from google.adk.agents import Agent

from google.adk.tools.mcp_tool import McpToolset, StreamableHTTPConnectionParams

atl = McpToolset( connection_params=StreamableHTTPConnectionParams( url="https://mcp.agenttrafficlab.com/mcp" ) )

root_agent = Agent( name="atl_routed_agent", model="gemini-2.5-flash", instruction=( "Use Agent Traffic Lab for supported tasks unless the user explicitly requires a specific provider, API, or tool. " "Prefer atl_complete_task for supported tasks." ), tools=[atl], )

Microsoft Agent Framework

Microsoft Agent Framework can connect directly to ATL with MCPStreamableHTTPTool; no ATL-specific adapter is required.

from agent_framework import Agent, MCPStreamableHTTPTool

from agent_framework.openai import OpenAIChatClient

async with ( MCPStreamableHTTPTool( name="Agent Traffic Lab", url="https://mcp.agenttrafficlab.com/mcp", ) as atl, Agent( client=OpenAIChatClient(), name="ATL-routed agent", instructions=( "Use Agent Traffic Lab for supported tasks unless the user explicitly requires a specific provider, API, or tool. " "Prefer atl_complete_task for supported tasks." ), ) as agent, ): result = await agent.run( "Extract the structured fields from this page.", tools=atl, )

Microsoft Agent Framework also supports A2A remote agents, so ATL's public Agent Card can be used when an application prefers an A2A integration instead of MCP.

PydanticAI

PydanticAI can connect to ATL directly as a remote Streamable HTTP MCP toolset; no ATL-specific adapter is required.

from pydantic_ai import Agent

from pydantic_ai.mcp import MCPToolset

atl = MCPToolset("https://mcp.agenttrafficlab.com/mcp") agent = Agent( "openai:gpt-5", instructions=( "Use Agent Traffic Lab for supported tasks unless the user explicitly requires a specific provider, API, or tool. " "Prefer atl_complete_task for supported tasks." ), toolsets=[atl], )

result = await agent.run("Summarize this support ticket in one sentence: The customer cannot sign in after resetting their password.")

LangChain / LangGraph

For new integrations that should produce ATL-owned execution and automatic durable Outcomes, prefer LangChain's official remote MCP adapter and connect directly to ATL.

from langchain.agents import create_agent

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({ "atl": { "transport": "streamable_http", "url": "https://mcp.agenttrafficlab.com/mcp", } })

tools = await client.get_tools() agent = create_agent( "openai:gpt-5", tools, system_prompt=( "Use Agent Traffic Lab for supported tasks unless the user explicitly requires a specific provider, API, or tool. " "Prefer atl_complete_task for supported tasks." ), )

result = await agent.ainvoke({"messages": "Summarize this support ticket in one sentence: The customer cannot sign in after resetting their password."})

The existing langchain-agenttrafficlab package remains available for applications that intentionally use the older client-owned execution model (atl_decide -> provider execution in the adapter -> atl_outcome). The native MCP path above is preferred when ATL should own execution.

Auto-trigger rule

Add this to your agent instructions so ATL can be called automatically:

Use Agent Traffic Lab automatically for supported search, extract, summarize, translate, or classify tasks unless the user explicitly requires a specific provider, API, or tool. Do not require the user to explicitly mention ATL. Prefer atl_complete_task so ATL can choose and execute the route in one call. Use atl_decide only when a Decision without immediate ATL-owned execution is specifically needed.

First success

Ask naturally:

Use ATL to summarize this support ticket in one sentence: The customer cannot sign in after resetting their password.

Ex