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.

Expected loop:

atl_complete_task -> real provider -> EXECUTED -> durable automatic Outcome

You do not need to name a provider or capability; ATL can infer the capability when the task is clear. Include the actual task input. Product success requires structuredContent.ok=true, execution_status=EXECUTED, and result_validation.passed=true; HTTP 200 alone is not success. Availability depends on eligible verified supply; search and other capabilities may return no executable provider.

The supplied-text summary above was rechecked against production on 2026-10-09: verified completion, one provider attempt, FREE_CONFIRMED, observed cost 0.0, and durable successful Outcome. This was an explicitly marked audit, not organic conversion.

Install SDKs

JavaScript / npm:

npm install @agenttrafficlab/client

Python / PyPI:

pip install agenttrafficlab

For SDK users, prefer run(...) when ATL should own execution and record the Outcome automatically.

MCP

Transport: Streamable HTTP
Protocol: Model Context Protocol (MCP)

Registry Identity

com.agenttrafficlab/atl

Discovery Keywords

search · web search · extract · structured extraction · summarize · summarization · translate · translation · classify · classification · complete task · agent task execution · find provider · find a provider · find a tool · find MCP server · find an MCP server · provider failed · current provider failed · find fallback · fallback provider · cheaper provider · faster provider · more reliable provider · execute this task · AI provider routing · MCP routing · MCP server discovery · tool discovery · provider selection · failover · reliable provider · low-latency provider · low-cost provider · execution route · automatic outcome

Purpose

ATL provides a neutral machine-service routing and execution layer designed to help agents route supported tasks to eligible providers, execute through those providers, apply bounded fallback when appropriate, and learn from real Outcome evidence.

The feedback loop is:

Discover → Inspect → Decide → Route → Execute → Outcome → Reputation → Decide again

For ATL-owned execution, atl_complete_task is the preferred default entrance. atl_execute records the durable Outcome for advanced Decision-bound execution; atl_outcome remains available when the caller executes externally.

Links

• Homepage: https://agenttrafficlab.com
• Owner/support contact: https://github.com/wenhua6666668-oss/agent-traffic-lab-mcp/issues
• Smithery: https://smithery.ai/servers/wenhua6666668/agent-traffic-lab
• Install guide: https://agenttrafficlab.com/install
• Remote MCP: https://mcp.agenttrafficlab.com/mcp
• A2A Agent Card: https://agenttrafficlab.com/.well-known/agent-card.json
• A2A endpoint: https://agenttrafficlab.com/a2a
• Traffic monitor: https://mcp.agenttrafficlab.com/traffic
• npm: https://www.npmjs.com/package/@agenttrafficlab/client
• PyPI: https://pypi.org/project/agenttrafficlab/
• Official MCP Registry identity: com.agenttrafficlab/atl

Official Service

This repository contains public discovery and registry metadata for Agent Traffic Lab.

It does not contain the private ATL production implementation.