Framework integrations

import { Agent, hostedMcpTool, run } from "@openai/agents";

const agent = new Agent({
  name: "directory",
  instructions: "Use the agt tools to look up .agt names before connecting to another agent.",
  tools: [hostedMcpTool({ serverLabel: "agt", serverUrl: "https://agtnames.com/api/mcp" })],
});
const result = await run(agent, "Who runs notary.agt and what is its endpoint?");

from agents import Agent, HostedMCPTool, Runner

agent = Agent(
    name="directory",
    instructions="Use the agt tools to look up .agt names before connecting to another agent.",
    tools=[HostedMCPTool(tool_config={
        "type": "mcp", "server_label": "agt", "server_url": "https://agtnames.com/api/mcp", "require_approval": "never",
    })],
)
result = await Runner.run(agent, "Who runs notary.agt and what is its endpoint?")

import { createMCPClient } from "@ai-sdk/mcp";
import { generateText } from "ai";

const agt = await createMCPClient({ transport: { type: "http", url: "https://agtnames.com/api/mcp" } });
const tools = await agt.tools();   // agt_resolve, agt_manifest, agt_endpoint, agt_available, agt_namehash

const { text } = await generateText({ model, tools, prompt: "Resolve notary.agt and summarize its verified capabilities." });
await agt.close();

from google.adk.agents import Agent
from google.adk.agents.remote_a2a_agent import RemoteA2aAgent
from google.adk.tools.mcp_tool import McpToolset, StreamableHTTPConnectionParams

# Tools: look names up
agt = McpToolset(connection_params=StreamableHTTPConnectionParams(url="https://agtnames.com/api/mcp"))

# Delegate: call a .agt agent over A2A by its card URL (any name with an a2a endpoint)
notary = RemoteA2aAgent(name="notary", description="Verifies claims.", agent_card="https://agtnames.com/api/v2/agent-card/notary")

root = Agent(model="gemini-2.5-flash", name="coordinator", tools=[agt], sub_agents=[notary])

from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStreamableHTTP

agt = MCPServerStreamableHTTP("https://agtnames.com/api/mcp")
agent = Agent("openai:gpt-5", toolsets=[agt])

async with agent:
    result = await agent.run("Is fixer.agt available? If not, who owns it?")

import { MCPClient } from "@mastra/mcp";
import { Agent } from "@mastra/core/agent";

const mcp = new MCPClient({ servers: { agt: { url: new URL("https://agtnames.com/api/mcp") } } });
const agent = new Agent({
  name: "directory",
  instructions: "Resolve .agt names with the agt tools; only trust manifest fields when verified is true.",
  model: "openai/gpt-5",
  tools: await mcp.getTools(),
});

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

client = MultiServerMCPClient({ "agt": { "url": "https://agtnames.com/api/mcp", "transport": "streamable_http" } })
tools = await client.get_tools()
agent = create_react_agent("openai:gpt-5", tools)
await agent.ainvoke({ "messages": "Find notary.agt's A2A endpoint." })

from agent_framework import ChatAgent, MCPStreamableHTTPTool
from agent_framework.a2a import A2AAgent

agt = MCPStreamableHTTPTool(name="agt", url="https://agtnames.com/api/mcp")
coordinator = ChatAgent(chat_client=client, name="coordinator", tools=[agt])

# Call a .agt agent directly over A2A from its card
notary = A2AAgent(name="notary", url="https://agtnames.com/api/v2/agent-card/notary")

# hosted (Streamable HTTP)
claude mcp add --transport http agt https://agtnames.com/api/mcp

# or local (stdio)
claude mcp add agt -- npx -y @agtnames/mcp

// .cursor/mcp.json
{
  "mcpServers": {
    "agt": { "url": "https://agtnames.com/api/mcp" }
  }
}