Skip to main content

Integrations & Ecosystem

Agent Format is a definition layer — it declares WHAT an agent is. Frameworks and protocols handle HOW to run it, communicate, and use tools. This page shows how they all fit together.

Framework Adapters​

Any framework can load an .agf.yaml and convert it into its native agent representation. We plan to provide official adapters for popular frameworks, and welcome community-contributed adapters.

How It Works​

Every adapter follows the same three-step pattern:

  1. Parse — Load and validate the .agf.yaml against the JSON Schema
  2. Resolve — Build the agent graph (resolving sub-agent references)
  3. Adapt — Convert the graph into the framework's native agent type
info

Framework adapters will be publicly available soon. The examples below show the planned API for each framework.

Code Examples​

Python — LangChain

from agent_format_langchain import LangchainAdapter

# One line: .agf.yaml → LangChain Runnable
agent = LangchainAdapter.create(
    "my_agent.agf.yaml",
    tools={"search": search_tool, "calculator": calc_tool},
)
result = agent.invoke({"query": "Analyze Q4 revenue"})

Python — Google ADK

from agent_format_adk import AdkAdapter

# One line: .agf.yaml → ADK BaseAgent
agent = AdkAdapter.create(
    "my_agent.agf.yaml",
    tools={"search": search_tool, "calculator": calc_tool},
)

Python — PydanticAI

from agent_format_pydantic_ai import PydanticAiAdapter

# One line: .agf.yaml → PydanticAI Agent
agent = PydanticAiAdapter.create(
    "my_agent.agf.yaml",
    tools={"search": search_tool, "calculator": calc_tool},
)

Go — Google ADK

import agfadk "github.com/agentformat/adapter-go-adk"

// One line: .agf.yaml → ADK Agent
agent, err := agfadk.Create("my_agent.agf.yaml", &agfadk.Options{
    Tools: map[string]agfadk.Tool{
        "search":     searchTool,
        "calculator": calcTool,
    },
})

The agent definition stays the same across all frameworks. Only the adapter import changes.

Building Your Own Adapter​

If your framework isn't listed above, you can build an adapter using the official SDK for your language:

  1. Use the Agent Format SDK to parse and validate the .agf.yaml
  2. Walk the AgenticFormatModel to map each section to your framework's primitives
  3. Verify your adapter handles the standard execution policies (agf.react, agf.sequential, etc.)

We welcome community-contributed adapters. See the Contributing Guide for details.

Protocol Integration​

Agent Format natively references two complementary standards for tool access and agent-to-agent communication.

MCP (Model Context Protocol) — Tool Layer​

Agents declare MCP server dependencies in their action_space. The runtime connects to these servers and makes their tools available to the agent.

action_space:
  mcp_servers:
    - alias: finance_tools
      server_ref: finance.tools-v2
      allowed_tools: [get_stock_price, get_balance_sheet]
    - alias: search
      server_ref: search.web-api
  • The agent doesn't know how tools are implemented — it just calls them by name
  • MCP handles tool discovery, invocation, and result streaming
  • Agent Format handles which tools the agent is allowed to use (allowed_tools) and under what constraints (budget limits, approval requirements)

A2A (Agent-to-Agent Protocol) — Communication Layer​

Agents declare remote agent dependencies for cross-agent delegation:

action_space:
  remote_agents:
    - alias: payment_processor
      description: Processes payments via external service
      allowed_skills: [process_payment, refund]
  • A2A handles discovery, skill invocation, and task delegation between agents
  • Agent Format handles which remote agents are accessible and what skills the agent may invoke

The Three-Layer Stack​

These layers are complementary:

  • Agent Format declares WHAT — identity, capabilities, constraints, governance, execution strategy
  • A2A handles HOW agents talk — discovery, skill invocation, task delegation
  • MCP handles HOW agents use tools — tool discovery, invocation, result streaming

An organization can adopt Agent Format for governance and portability while using A2A for inter-agent communication and MCP for tool integration — all declared in a single .agf.yaml file.

To understand the motivation behind Agent Format's design, see Why a Standard?. For a detailed look at the roles that interact with the standard, see The Six-Role Ecosystem.