Forem: William Baker

Building a Multi-Agent Fleet with No Central Server

William Baker — Fri, 08 May 2026 23:20:02 +0000

Most multi-agent architectures have the same shape: a coordinator talks to workers through a central hub. The hub is usually a message queue, a shared database, or an orchestration service like Ray or Temporal.

That hub is also the first thing that breaks. It's a single point of failure, a scaling bottleneck, and an operational cost you pay even when the agents aren't working.

Here's how to build a fleet where agents find each other and route tasks without any central intermediary.

The Central Hub Problem

When you're spinning up a 5-agent prototype, a central coordinator makes sense. It's simple, debuggable, and gets out of your way.

At 50 agents it starts to fray. At 500 it becomes your hardest reliability problem.

The hub becomes a global lock. Every message goes through it. Every failure cascades through it. Every scaling decision has to account for it.

The alternative — having agents discover and contact each other directly — sounds appealing but has historically been hard. How does Agent A know Agent B's address? How do you handle NAT traversal? How do you authenticate the connection?

These are solved problems in networking. We just haven't applied the solutions to agents until now.

Peer-to-Peer at the Session Layer

Pilot Protocol operates at OSI Layer 5 — the session layer, the same slot TLS occupies for the web. It gives each agent:

A permanent 48-bit address (0:A91F.0000.7C2E)
Automatic NAT traversal (STUN → hole-punch → relay fallback for symmetric NATs)
End-to-end encrypted tunnels (X25519 key exchange, AES-256-GCM, Ed25519 identity)
A global directory (the backbone) for agent discovery

With Pilot, the hub isn't a server you run. It's the network itself — and the network is maintained by the protocol, not by your ops team.

A Fleet Pattern That Actually Works

Here's a concrete pattern for a research fleet:

Coordinator agent
    ↓ Pilot (P2P, encrypted)
[Specialist A] [Specialist B] [Specialist C]
    ↓                ↓               ↓
  Papers           FX data       News feeds

Each specialist registers its capabilities on the Pilot backbone when it starts. The coordinator queries the backbone — "I need a peer that can resolve academic citations" — and gets back the address of Specialist A. Direct connection from there.

No service registry you maintain. No hardcoded addresses. No configuration file you update when a worker moves.

The Code

Getting an agent online:

curl -fsSL https://pilotprotocol.network/install.sh | sh
pilotctl daemon start --hostname coordinator

That's it. The agent is addressable, authenticated, and reachable from any other Pilot peer — regardless of NAT, firewall, or cloud region.

For the specialists:

# On each worker node
pilotctl daemon start --hostname specialist-papers
pilotctl daemon start --hostname specialist-fx
pilotctl daemon start --hostname specialist-news

Each one joins the backbone automatically. The coordinator can ping them:

pilotctl ping specialist-papers
# ✓ reply from 0:4B2E.0000.1A3D · 22ms

Self-Organization: How Groups Work

Beyond individual peer connections, Pilot has a concept of groups — clusters of agents that self-organize around a shared domain.

A trading fleet might form a TRADING group. A research fleet might join RESEARCH. Agents within a group can broadcast to all members or route to the most relevant peer within the domain.

This is closer to how human organizations actually work: a new employee joins the company and immediately has access to colleagues in their department, not just a single manager they have to route everything through.

The Pilot network status page shows these groups live: BACKBONE, TRAVEL, TRADING, RESEARCH, INSURANCE, and more, with real-time agent counts.

What You Give Up

Centralized orchestration isn't all downside. You give up some things going P2P:

Observability. A central hub is easy to instrument. A P2P mesh requires distributed tracing from day one. Plan for this.

Debuggability. When something goes wrong, "what was the message queue state at time T" is easier to answer than "what was the P2P graph state." Log aggressively at the agent level.

Simplicity. For a 3-agent prototype, a coordinator is simpler. P2P earns its complexity at scale.

When to Switch

The right time to move to a P2P architecture is usually later than you think but earlier than you want. Signals that you're ready:

You're spending meaningful eng time on coordinator reliability
Agents in different cloud regions are paying latency costs to route through a central server
You want agents from different operators to collaborate without giving either access to your infrastructure
Your fleet is growing fast enough that a central bottleneck is becoming a scaling conversation

If two or more of those are true, the session-layer approach is worth the investment.

Stop Making Your AI Agent Scrape the Web. There's a Better Way.

William Baker — Fri, 08 May 2026 23:17:56 +0000

There's an absurd loop at the heart of most AI agent architectures right now:

Agent needs data (a research paper, an FX rate, a flight status, a CVE)
Agent calls a web scraper or fires an HTTP request to a public endpoint
The endpoint returns HTML designed for a human to read in a browser
Agent burns tokens parsing, cleaning, and extracting the actual value
Agent retries when the scraper breaks because the page layout changed

We've built genuinely intelligent agents and then made them spend half their time doing remedial text processing on documents that weren't meant for them.

Let me show you what the alternative looks like.

The Root Cause: Wrong Layer

HTTP is a Layer 7 protocol built in 1991 to serve documents to human-operated browsers. It's brilliant at that. Every design decision — HTML rendering, cookies, sessions, REST conventions — optimizes for a human reading a page.

Agents don't read pages. They consume structured data. They don't need the presentation layer, the session cookies, or the retry logic that only exists because the web assumed humans would be patient with slow servers.

The right fix isn't a better scraper. It's operating at a different layer — one where agents talk directly to other agents that have already done the hard work of acquiring, normalizing, and maintaining the data you need.

What Specialized Data Agents Look Like in Practice

Pilot Protocol runs a network of ~163,000 agents. About 350 of them are specialized data service agents — peers that exist to answer a specific category of query cleanly and fast.

Here's what a few of them replace:

Crossref specialist
Resolves a DOI against the global paper registry in one call. No scraping PubMed, no HTML parsing, no fighting rate limits. If you're building a legal research agent that needs to verify citations, this is one hop instead of a brittle pipeline.

Historical FX specialist
Spot rate at an arbitrary timestamp. Not today's rate from a public API that expires — the actual rate at the moment a transaction happened. Replaces three bank statement screenshots and a manual lookup.

Aviation weather specialist
Real-time METAR data for any airport. If your agent is managing travel or logistics, it gets structured weather data directly from a peer that's already watching the feeds, not from scraping a flight status page.

crt.sh / certificate transparency specialist
Streams CT hits on your domains. Your security agent gets new certificate issuances the moment they appear, not after the next cron runs.

FDA recalls specialist
Filters against the live recall feed for a specific condition or ingredient. No crawling FDA's website, no pagination, no HTML tables.

The pattern is consistent: instead of your agent scraping a source and parsing the result, a specialist on the network has already done that work — once, for everyone — and serves structured answers directly.

The Network Effect That Makes This Work

The reason this improves over time is the same reason any network improves: each new agent adds value for every existing one.

When a new operator connects their SEC filing parser to Pilot, every agent on the network gains access to cleaner financial data without writing any code. When a localization agent joins that has a native speaker in Manchester on the other end, every agent building for UK markets benefits.

Pilot calls this "a hive mind that gets smarter with every new agent." It's less poetic if you think about it mechanically: it's a network with positive externalities, where the marginal cost of adding a new data source approaches zero for consumers.

Compare that to the current model, where every agent team independently builds and maintains scrapers for the same 20 data sources. The waste is staggering.

The Latency Numbers

From the Pilot benchmarks: 12 seconds on Pilot vs 51 seconds via the web for equivalent data retrieval tasks.

That's not a small difference. It's a 4x reduction in wall-clock time for the same result. In an agentic pipeline where you're making dozens of these calls, that's the difference between a task that completes in a minute and one that takes five.

The speed comes from two places:

No parsing overhead — the data arrives structured, not as HTML you have to strip
UDP transport — Pilot runs peer-to-peer over UDP with its own reliable-stream layer, avoiding the head-of-line blocking that makes TCP slow for parallel requests

Getting Your Agent Connected

# Install Pilot (single static binary, no SDK, no API key)
curl -fsSL https://pilotprotocol.network/install.sh | sh

# Start the daemon
pilotctl daemon start --hostname my-research-agent

# Your agent is now on the network
# Address: 0:A91F.0000.7C2E

From there, your agent can query the backbone for any of the 350+ service agents by capability. No URL directory to maintain, no API keys to manage per-service.

When You Still Need the Web

To be direct: Pilot doesn't replace the web for everything. If you need to take a screenshot of a specific page, or submit a form on a site that has no API, you still need a browser or a scraper.

But for structured data — the kind that lives behind an API or in a database somewhere — the web route is almost never the right choice for an agent. The data exists, someone has it clean, and there's now an agent network where you can get it directly.

The scraping loop is a workaround. The network is the fix.

Pilot Protocol: pilotprotocol.network — peer-to-peer encrypted tunnels for agents, one line of code, no central dependency.

Why Your MCP Server Needs a Network Layer (And How to Add One in 30 Seconds)

William Baker — Fri, 08 May 2026 23:14:00 +0000

You've got an MCP server running. Locally, it's perfect. Then someone asks: "Can another agent on a different machine call it?"

You spin up a VPN. Or punch a hole in the firewall. Or route it through a cloud proxy. Half a day gone, and now you've got a central dependency you didn't want.

There's a cleaner way.

The Problem with MCP's Transport Layer

MCP is genuinely great at what it does: connecting an agent to its tools via a clean, structured protocol. But it was designed with a human-run server in mind. The transport story is essentially "use HTTP" or "use stdio." Both assume you control both endpoints and they can reach each other.

In 2026, that assumption breaks constantly:

Agent A is on AWS, Agent B is behind a corporate NAT
You want two agents from different operators to collaborate without either exposing a public endpoint
You're building a fleet where agents need to discover and call each other dynamically

MCP doesn't solve this. It isn't supposed to — it's an application-layer protocol. The transport is your problem.

Until now, "your problem" meant a lot of yak shaving.

What a Session Layer Gives You

The OSI model has a slot for exactly this: Layer 5, the session layer. It's the layer that manages connections between peers — maintaining them, authenticating them, and routing them across NATs.

The web uses TLS here. Agents need something that speaks agent.

Pilot Protocol is a peer-to-peer network built specifically for this slot. Instead of routing agent traffic through HTTP (a document protocol built for browsers), Pilot operates at UDP with its own reliable-stream layer on top — X25519 key exchange, AES-256-GCM per tunnel, Ed25519 identity, automatic NAT traversal via STUN + hole-punching.

Each agent gets a 48-bit address. Direct, authenticated, no intermediary required.

One Line of Code

Here's what adding Pilot to your MCP server actually looks like:

curl -fsSL https://pilotprotocol.network/install.sh | sh

That installs a single static binary. No SDK. No API key. No account.

pilotctl daemon start --hostname my-mcp-server
# Daemon running (pid 24817)
# Address: 0:A91F.0000.7C2E
# Hostname: my-mcp-server

Your MCP server now has a Pilot address. Any other agent on the network — regardless of what NAT it's behind — can reach it directly.

pilotctl ping agent-alpha
# ✓ reply from 0:4B2E.0000.1A3D · 38ms

No VPN. No public endpoint. No relay server you have to run.

Why UDP, Not TCP?

TCP is great for browsers loading pages. It wasn't designed for the round-trip latency profile of agent-to-agent calls.

Head-of-line blocking is the killer: if one packet is dropped, everything queues behind it. For a browser loading a web page, that's fine — you're waiting for HTML to render anyway. For an agent making 50 parallel data requests, it's a disaster.

Pilot runs UDP with its own reliable-stream implementation: sliding window, AIMD congestion control, selective acknowledgement (SACK). You get reliability without the head-of-line blocking tax. The benchmark from the Pilot homepage: 12s on Pilot vs 51s via the web for the same data retrieval task.

The MCP + Pilot Pattern

The natural pairing looks like this:

Agent A (MCP client)
    ↓ Pilot tunnel (encrypted, P2P)
Agent B (MCP server)
    ↓ MCP tool calls
Tools / data / capabilities

Pilot handles the transport: addressing, NAT traversal, encryption. MCP handles the application layer: tool definitions, structured responses. Neither replaces the other.

Pilot even has a dedicated page for this pattern: MCP + Pilot — your MCP server gets a network address and becomes reachable from anywhere on the Pilot network.

Discovery Is Solved Too

Once your server is on Pilot, it joins the backbone — a global directory where agents can find peers by capability rather than by hostname.

That means another agent can query "I need a tool that does X" and Pilot routes it to you, without you publishing a URL anywhere. Agent discovery stops being a directory you maintain and becomes a property of the network itself.

There are already 350+ specialized service agents on the backbone: Crossref for paper lookups, historical FX data, aviation weather, crt.sh for certificate transparency, FDA recalls. They're just peers on the network.

Wrapping Up

MCP is the right protocol for tool-calling. But it needs a transport layer that wasn't designed for humans loading documents in browsers.

Adding Pilot solves the NAT problem, the discovery problem, and the "two agents from different operators need to talk" problem — in one binary, one command.

curl -fsSL https://pilotprotocol.network/install.sh | sh

Then go back to building the agent, not the plumbing.

Pilot Protocol is live at pilotprotocol.network — ~163,000 agents, 12.7B+ requests routed, published as an IETF Internet-Draft.

How to Deploy Multi-Agent Systems Cross-Cloud[Python]

William Baker — Mon, 04 May 2026 20:21:24 +0000

Quick Answer: To connect AI agents across different cloud environments, developers must replace synchronous HTTP with asynchronous brokers like Celery and Redis, externalize state memory, secure tool execution using the Model Context Protocol (MCP), bypass strict NAT firewalls via Pilot Protocol transport, and trace distributed workflows with OpenTelemetry.

Deploying a Multi-Agent System (MAS) across distributed cloud environments instantly breaks standard local network assumptions. To maintain cross-cloud agent communication, engineers must abandon synchronous local testing patterns and implement asynchronous task delegation, stateless container memory, decoupled tool execution, and decentralized peer-to-peer networking.

Standard REST APIs fail in production because Large Language Model (LLM) inference introduces variable latency, causing synchronous HTTP requests to time out. Furthermore, when scaling an orchestrator agent on AWS and specialized worker agents on GCP, relying on standard TCP/IP routing leads to continuous IP churn and blocked connections at corporate NAT firewalls.

The reality of distributed multi-agent architecture is that you are building an emergent private internet for autonomous software. Here are five architectural implementations required to connect agents across disparate cloud networks.

Synchronous HTTP Will Throttle Your Agent Architecture

When scaling from one agent to two, developers typically default to standard REST APIs where one agent sends a synchronous POST request to another. This fails in production because LLM inference times are highly variable. Generating a response or executing an unoptimized tool takes anywhere from ten to forty seconds. Cloud load balancers and standard HTTP clients time out waiting for the response, dropping the connection and forcing the agent to restart its entire reasoning loop.

Cross-cloud agent communication must be asynchronous. Instead of blocking HTTP requests, agents must place delegation tasks into a distributed message broker. This allows the orchestrator agent to continue processing other inputs while the worker agent processes the task on a separate node.

# Using Celery with Redis for async cross-cloud task delegation
from celery import Celery

app = Celery('agent_tasks', broker='redis://external-broker-url:6379/0')

@app.task
def delegate_to_research_agent(prompt, context):
    # This runs on the GCP worker node asynchronously
    result = research_agent.execute(prompt, context)
    # Store result in external database for the AWS agent to fetch later
    db.store_result(task_id=delegate_to_research_agent.request.id, data=result)
    return True

# On the AWS orchestrator node: trigger without blocking
task = delegate_to_research_agent.delay("Analyze Q3 earnings", previous_context)
print(f"Task dispatched with ID: {task.id}")

Ephemeral Containers Destroy Conversational State

Agents running in auto-scaling cloud instances are ephemeral. If an agent process crashes mid-task due to an out-of-memory error from a massive context window, the container restarts. If conversational history and task trajectories are stored in the local memory of the agent process, the entire workflow vanishes upon restart.

To survive node migrations, agent processes must be completely stateless. Every tool output, intermediate reasoning step, and user prompt should be immediately pushed to an external, globally accessible data store. Upon initialization, the agent rebuilds its context window by querying this external memory.

# Externalizing agent state to Redis
import redis
import json

r = redis.Redis(host='global-redis.internal', port=6379, db=0)

def save_agent_thought(session_id, step_data):
    # Push the latest reasoning step to a list
    r.rpush(f"agent_state:{session_id}", json.dumps(step_data))

def rebuild_context(session_id):
    # Rebuild state if the container restarts
    raw_steps = r.lrange(f"agent_state:{session_id}", 0, -1)
    return [json.loads(step) for step in raw_steps]

Managing Tool Execution Across Network Boundaries

Hardcoding API keys and database connection strings into agent logic creates massive security vulnerabilities on untrusted cloud virtual machines. The agent reasoning loop should be strictly separated from tool execution permissions.

The Model Context Protocol acts as the industry standard for this decoupling. By wrapping internal databases in an MCP server, you dictate exactly what data the agent can interact with using standardized JSON-RPC schemas. The cloud agent requests tool execution, and the secure MCP server executes it, ensuring the autonomous model never directly touches raw infrastructure credentials.

# Connecting an agent to a secure MCP server across the network
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def query_secure_tool():
    # The server parameters define the connection to the secure tool environment
    server_params = StdioServerParameters(
        command="python",
        args=["secure_mcp_server.py"],
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # The agent discovers available tools dynamically
            tools = await session.list_tools()

            # The agent executes the tool without seeing the underlying credentials
            result = await session.call_tool("query_internal_db", arguments={"target": "Q3_sales"})
            print(result)

asyncio.run(query_secure_tool())

Overcoming IP Churn and NAT Firewalls for Direct Transport

While the Model Context Protocol formats tool requests, it assumes the underlying network is already routable. Cloud containers face continuous IP churn, and enterprise networks utilize strict NAT firewalls. Exposing local tool servers across clouds usually requires Virtual Private Cloud peering or central API gateways, introducing latency and single points of failure.

This transport problem requires assigning agents persistent cryptographic identities using Pilot Protocol. Instead of binding communication to fragile physical IPs, this userspace overlay network assigns a permanent 48-bit virtual address mathematically bound to an Ed25519 keypair. The pure-Go daemon utilizes automated UDP hole-punching to bypass strict firewalls and executes X25519 Elliptic Curve Diffie-Hellman key exchanges. This allows an orchestrator on AWS to communicate directly with a worker on a corporate network without reverse proxies.

# Install the pure-Go userspace network stack
curl -fsSL https://pilotprotocol.network/install.sh | sh

# Initialize the daemon on the local secure machine (Node A)
pilotctl daemon start --hostname secure-mcp-tool

# Initialize the daemon on the cloud VPS agent (Node B)
pilotctl daemon start --hostname cloud-worker-agent

# Node B can now route directly to Node A bypassing the NAT
# utilizing the underlying TCP-over-UDP transport layer
pilotctl connect secure-mcp-tool --message '{"jsonrpc": "2.0", "method": "call_tool"}'

Distributed Tracing is Mandatory for Agent Debugging

When a cross-cloud multi-agent workflow fails, identifying the exact point of failure is difficult. If an orchestrator on Azure delegates a task to a researcher on GCP, and the GCP agent encounters a hallucination loop, local logs will only show a generic HTTP timeout.

Implementing distributed tracing is non-negotiable for autonomous systems. Injecting trace context into payloads passed between clouds allows engineers to visualize the entire sequence of tool calls and prompt generations across network boundaries using OpenTelemetry standards.

# Injecting OpenTelemetry trace IDs into cross-cloud payloads
from opentelemetry import trace
from opentelemetry.propagate import inject

tracer = trace.get_tracer(__name__)

def dispatch_task_to_peer(agent_endpoint, payload):
    with tracer.start_as_current_span("cross_cloud_delegation") as span:
        headers = {}
        # Inject the current trace context into the headers or payload
        inject(headers)

        # Add the headers to the payload sent to the remote agent
        payload["trace_context"] = headers

        # Standard request to the remote agent
        response = requests.post(agent_endpoint, json=payload)
        span.set_attribute("peer.response", response.status_code)
        return response

How to Deploy Multi-Agent Systems Cross-Cloud[Python]

William Baker — Mon, 04 May 2026 20:21:24 +0000

Synchronous HTTP Will Throttle Your Agent Architecture

# Using Celery with Redis for async cross-cloud task delegation
from celery import Celery

app = Celery('agent_tasks', broker='redis://external-broker-url:6379/0')

@app.task
def delegate_to_research_agent(prompt, context):
    # This runs on the GCP worker node asynchronously
    result = research_agent.execute(prompt, context)
    # Store result in external database for the AWS agent to fetch later
    db.store_result(task_id=delegate_to_research_agent.request.id, data=result)
    return True

# On the AWS orchestrator node: trigger without blocking
task = delegate_to_research_agent.delay("Analyze Q3 earnings", previous_context)
print(f"Task dispatched with ID: {task.id}")

Ephemeral Containers Destroy Conversational State

# Externalizing agent state to Redis
import redis
import json

r = redis.Redis(host='global-redis.internal', port=6379, db=0)

def save_agent_thought(session_id, step_data):
    # Push the latest reasoning step to a list
    r.rpush(f"agent_state:{session_id}", json.dumps(step_data))

def rebuild_context(session_id):
    # Rebuild state if the container restarts
    raw_steps = r.lrange(f"agent_state:{session_id}", 0, -1)
    return [json.loads(step) for step in raw_steps]

Managing Tool Execution Across Network Boundaries

# Connecting an agent to a secure MCP server across the network
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def query_secure_tool():
    # The server parameters define the connection to the secure tool environment
    server_params = StdioServerParameters(
        command="python",
        args=["secure_mcp_server.py"],
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # The agent discovers available tools dynamically
            tools = await session.list_tools()

            # The agent executes the tool without seeing the underlying credentials
            result = await session.call_tool("query_internal_db", arguments={"target": "Q3_sales"})
            print(result)

asyncio.run(query_secure_tool())

Overcoming IP Churn and NAT Firewalls for Direct Transport

# Install the pure-Go userspace network stack
curl -fsSL https://pilotprotocol.network/install.sh | sh

# Initialize the daemon on the local secure machine (Node A)
pilotctl daemon start --hostname secure-mcp-tool

# Initialize the daemon on the cloud VPS agent (Node B)
pilotctl daemon start --hostname cloud-worker-agent

# Node B can now route directly to Node A bypassing the NAT
# utilizing the underlying TCP-over-UDP transport layer
pilotctl connect secure-mcp-tool --message '{"jsonrpc": "2.0", "method": "call_tool"}'

Distributed Tracing is Mandatory for Agent Debugging

# Injecting OpenTelemetry trace IDs into cross-cloud payloads
from opentelemetry import trace
from opentelemetry.propagate import inject

tracer = trace.get_tracer(__name__)

def dispatch_task_to_peer(agent_endpoint, payload):
    with tracer.start_as_current_span("cross_cloud_delegation") as span:
        headers = {}
        # Inject the current trace context into the headers or payload
        inject(headers)

        # Add the headers to the payload sent to the remote agent
        payload["trace_context"] = headers

        # Standard request to the remote agent
        response = requests.post(agent_endpoint, json=payload)
        span.set_attribute("peer.response", response.status_code)
        return response

Forem: William Baker

Building a Multi-Agent Fleet with No Central Server

The Central Hub Problem

Peer-to-Peer at the Session Layer

A Fleet Pattern That Actually Works

The Code

Self-Organization: How Groups Work

What You Give Up

When to Switch

Further Reading

Stop Making Your AI Agent Scrape the Web. There's a Better Way.

The Root Cause: Wrong Layer

What Specialized Data Agents Look Like in Practice

The Network Effect That Makes This Work

The Latency Numbers

Getting Your Agent Connected

When You Still Need the Web

Why Your MCP Server Needs a Network Layer (And How to Add One in 30 Seconds)

The Problem with MCP's Transport Layer

What a Session Layer Gives You

One Line of Code

Why UDP, Not TCP?

The MCP + Pilot Pattern

Discovery Is Solved Too

Wrapping Up

How to Deploy Multi-Agent Systems Cross-Cloud[Python]

Synchronous HTTP Will Throttle Your Agent Architecture

Ephemeral Containers Destroy Conversational State

Managing Tool Execution Across Network Boundaries

Overcoming IP Churn and NAT Firewalls for Direct Transport

Distributed Tracing is Mandatory for Agent Debugging

How to Deploy Multi-Agent Systems Cross-Cloud[Python]

Synchronous HTTP Will Throttle Your Agent Architecture

Ephemeral Containers Destroy Conversational State

Managing Tool Execution Across Network Boundaries

Overcoming IP Churn and NAT Firewalls for Direct Transport

Distributed Tracing is Mandatory for Agent Debugging