Foundation Protocol: A Coordination Layer for Agentic Society - Summary

Summary (Overview)

• Core Contribution: Introduces the Foundation Protocol (FP), a graph-native coordination layer designed to unify heterogeneous entities (agents, tools, humans, organizations) in an emerging human-AI society.
• Key Design Goals: Provides native support for multi-party organization, event-based collaboration, economic primitives (metering, receipts), and first-class policy, provenance, and audit capabilities.
• Architectural Approach: Adopts a plane-based architecture (Entity & Trust, Transport & Routing, Interaction & Organization, Regulation & Oversight) to keep the core protocol small and extensible via profiles and bridges.
• Philosophy: Aims to wrap and bridge existing protocols (e.g., MCP, A2A, DIDComm) rather than replace them, enabling composable agency with non-negotiable accountability.
• Motivation: Addresses the coordination bottleneck as autonomous agents scale from tools to social infrastructure, requiring reliable relationships, value exchange, and governance.

Introduction and Theoretical Foundation

The paper argues that autonomous agents are evolving from simple tools into persistent social and economic actors that browse, purchase, deploy software, and interact with each other. This shift creates a new coordination challenge: agents need to form relationships, organize work, exchange value, and remain accountable under real-world oversight. The existing protocol landscape (MCP, A2A, A2UI, DIDComm, etc.) is fragmented, leading to semantic drift, broken provenance, and a patchwork of logs and controls when workflows cross protocol boundaries.

The theoretical foundation is built on two historical lenses:

1. Intelligence Density: Industrial revolutions are viewed as steps in increasing a society's capacity to gather and coordinate intelligence. The next phase involves systematizing coordination among intelligent actors (human and AI), for which a common substrate (FP) is essential.
2. Evolution of the Web: Lessons from Web 1.0 to 4.0 show that capability often arrives before the governance primitives needed to manage it. As the web distributes agency, identity, policy, and provenance must become part of the communication substrate itself.

The core design objectives for FP are derived from the need for behavioral closure in autonomous systems—enabling them to exchange information, coordinate work, exchange value, and negotiate conflicts. FP aims to standardize the shared substrate that existing ecosystems re-create in different forms.

Methodology

FP is conceptualized as a graph-native protocol. The methodology is architectural and design-focused, centered on a plane-based model:

1. Core Vocabulary: FP defines a minimal set of seven semantic objects to describe all interactions:

   • Entity: An addressable participant (agent, human, tool, org).
   • Session: A scoped multi-party context with roles and policies.
   • Activity: A unit of work within a session.
   • Envelope: A signed wrapper for intent and routing.
   • Event: An append-only observation for streaming and replay.
   • Receipt/Settlement: Verifiable records of metered usage and value exchange.
   • Provenance: Structured audit records of decisions and evidence.

2. Plane-Based Architecture: The protocol is organized into four core planes plus a configuration layer:

   • Entity & Trust Plane: Defines identity, capabilities, credentials, and privacy controls for all entities. Employs progressive disclosure to reduce token overhead.
   • Transport & Routing Plane: Specifies addressing, discovery, and channel management, remaining agnostic to concrete transports (HTTP, WebSocket, etc.).
   • Interaction & Organization Plane: Provides primitives for collaboration: schemas, event streams, sessions, organizations, and economic primitives (metering, receipts).
   • Regulation & Oversight Plane: Embeds policy evaluation, enforcement, audit records, and dispute signals as first-class protocol concerns.
   • Configuration & Profiles: Binds the core to specific transports, identity methods, and extensions via profiles and bridges to other protocols.

3. Design Principles:

   • Keep the core small and semantic.
   • Prefer progressive disclosure over "prompt stuffing."
   • Make multi-party interaction explicit (sessions, roles).
   • Treat evidence (provenance, audit) as a first-class output.

Empirical Validation / Results

The paper validates the protocol design through a detailed, multi-phase application scenario: "An AI company with human oversight." This scenario demonstrates how all FP planes work together in a realistic setting.

Scenario: Lifecycle of an AI Company A human founder creates an organization composed of specialized agent entities (planner, developer, reviewer) and hires external services (GPU provider, code-search tool).

Key Demonstration: The scenario shows FP's uniformity—the same entity model represents both humans and GPU providers; the same checkpoint pipeline enforces both access control and budget limits; the same envelope carries both task messages and payment receipts. This demonstrates FP's ability to compose heterogeneous interactions under a single, accountable control surface.

Theoretical and Practical Implications

• Theoretical: Positions coordination, governance, and verifiable evidence as the next scarce resources in autonomous systems, aligning with economic analyses on the rising value of verification capacity [5, 19]. Treats the protocol layer as the fundamental safety and accountability boundary for agentic society.
• Practical:
  • Reduces Integration Overhead: Provides a unified substrate for composing existing protocols (MCP, A2A, etc.), reducing semantic fragmentation.
  • Enables Governable Scale: Makes multi-agent organizations, economic activity, and auditability native protocol features, not application-layer add-ons.
  • Supports Incremental Adoption: The profile/bridge architecture allows wrapping existing systems without a "flag-day" migration.
  • Lowers Coordination Cost: Aims to make coordination low-cost, open, and governable, preventing a future of brittle, proprietary, and concentrated agent ecosystems.

Conclusion

The Foundation Protocol (FP) is proposed as a compact coordination layer for an emerging human-AI society. Its core innovation is a graph-native, plane-based architecture that unifies entities, organizations, economic attestations, and oversight evidence. By keeping the core small and separating it from profiles and bridges, FP is designed to complement the existing protocol ecosystem.

The ultimate goal is to provide a shared communication substrate where autonomous agency remains composable but accountability is non-negotiable. The paper concludes by framing FP as a step toward an open, pluralistic, and governable agentic society, with the next step being the development of precise specifications and reference implementations for community evaluation and refinement.

Project: https://github.com/FoundationAgents/foundation-protocol