[&] Protocol Documentation

Part of the [&] Protocol stack · Ecosystem overview · Three-protocol stack · Stack status

Welcome to the documentation hub for the [&] Protocol.

The [&] Protocol is a language-agnostic specification for capability composition in AI agents. It defines how an agent declares what it can remember, how it reasons, how it understands time and space, how it is embodied (perception/action/affordance), how those capabilities compose, and how that declaration can compile into downstream runtime artifacts such as MCP and A2A configurations.

Use this documentation to understand the protocol from multiple angles:

• Architecture explains the system model, runtime lifecycle, and end-to-end declaration flow.

• Positioning compares [&] with adjacent standards and research.

• Competitive Landscape maps the machine cognition market and explains the structural constraints facing each competitor category.

• Topology Is the Authority explains why governance must emerge from feedback topology, not be bolted onto architecture.

• Autonomous Systems explains why autonomous vehicles and drone swarms are the canonical [&] use case, including the Palantir integration surface and κ-driven swarm governance.

• Research provides the motivation for a composition layer in the agent stack.

• FAQ answers common questions quickly.

• Ecosystem Overview explains how all twelve products compose through the six primitives.

• Industry Verticals maps seven commercial industries where all six primitives deliver value.

• Capability pages explain the six core primitives in more detail.

• Skills are hands-on, step-by-step guides covering the full declare → validate → compose → generate workflow, plus provider implementation, governance, and integration patterns.

What you'll find here

• A practical overview of the protocol's role in the agent stack

• A runtime walkthrough covering declaration → validation → composition → resolution → generation

• Explanations of capability declaration, contracts, provenance, and governance

• Comparisons with MCP, A2A, ACP, and related work

• Deep dives into &memory, &reason, &time, &space, &body, and &govern

• Skills guides for hands-on implementation — from writing your first ampersand.json to building providers and governance policies

Documentation map

Homepages

• [&] Ampersand Box

• Graphonomous

• BendScript

• WebHost.Systems

• Agentelic

• AgenTroMatic

• Delegatic

• Deliberatic

• FleetPrompt

• GeoFleetic

• OpenSentience

• SpecPrompt

• TickTickClock

Root Docs

• [&] Protocol Docs

• Graphonomous Docs

• BendScript Docs

• WebHost.Systems Docs

• Agentelic Docs

• AgenTroMatic Docs

• Delegatic Docs

• Deliberatic Docs

• FleetPrompt Docs

• GeoFleetic Docs

• OpenSentience Docs

• SpecPrompt Docs

• TickTickClock Docs

[&] Protocol Docs

• quickstart

• architecture

• runtime-walkthrough

• ecosystem-overview

• positioning

• competitive-landscape

• topology-is-the-authority

• use-cases-autonomous-systems

• use-cases-industry-verticals

• comparison-table

• research

• faq

Capabilities & Registry

• README

• memory

• memory.episodic

• memory.graph

• reason

• reason.argument

• reason.deliberate

• reason.attend

• time

• time.forecast

• space

• space.fleet

• govern

• govern.telemetry

• govern.escalation

• govern.identity

Skills

• SKILLS

• 01_DECLARATION

• 02_VALIDATION

• 03_COMPOSITION

• 04_CONTRACTS

• 05_GENERATION

• 06_CLI_REFERENCE

• 07_INTEGRATION_PATTERNS

• 08_PROVIDER_IMPLEMENTATION

• 09_GOVERNANCE_PROVENANCE

• 10_ANTI_PATTERNS

Documentation index

Every page in this documentation set (the linked index below renders on GitHub and in the docs atlas; the toctrees above drive the Sphinx build):

Guides

• Capability Composition, v2 — CC2 (Coalitional)

• The Compose Runtime — CC2 compose, made authorable

• Protocol comparison — MCP vs A2A vs DALIA vs ACP

• Ecosystem Overview — How Everything Ties Together

• FAQ

• The Missing Layer: Capability Composition in the Agent Protocol Stack

• Research Overview

• Runtime Walkthrough

• Agent Skills

• Topology Is the Authority

• Industry Verticals: Where All Six Primitives Compose

Capability deep dives

• &govern: Cross-Cutting Governance for Agents

• &memory: Capability Deep Dive

• &reason: Deliberation, Evaluation, and Decision-Making

• &space: Spatial Intelligence for Agents

• &time: Temporal Intelligence

Capability registry

• Capability Registry Pages

• &body.browser

• &body.os

• &govern.escalation — Human-in-the-Loop Escalation and Governance Handoff

• &govern.identity — Agent Identity, Verification, and Trust

• &govern.telemetry — Observability, Cost Tracking, and Budget Enforcement

• &memory.episodic — Experience, Session History, and Replayable Context

• &memory.graph — Graph-Structured Memory Capability

• &memory.vector — Semantic Vector Retrieval Capability

• &reason.argument — Evidence-Weighted Deliberation

• &reason.attend — Proactive Attention and Bounded Autonomy

• &reason.deliberate — κ-Aware Deliberation

• &reason.plan — Planning-Oriented Reasoning

• &reason.vote — Consensus-Oriented Reasoning

• &space.fleet — Fleet State, Regional Context, and Spatial Operations

• &space.geofence — Boundary Membership, Zone Logic, and Compliance Awareness

• &space.route — Route Intelligence, Path Optimization, and Explainable Navigation

• &time.anomaly — Anomaly Detection as a Capability

• &time.forecast — Forecasting as a Capability

• &time.pattern — Pattern Detection as a Capability

Build prompts

• Attention Engine — Build Prompt v1

• Codex Prompt Guide

• Dual- and Triple-Loop Machine Architecture

• Graphonomous Traversal Prompt

• κ-Aware Routing — Build Prompt v2

• κ-Driven Deliberation Orchestrator — Build Prompt v1

• Model Tier Adaptation — Build Prompt v1

• Protocol Implementation Prompt

Suggested reading order

If you're new to the project, a good path is:

1. quickstart — get from clone to a working ampersand CLI in minutes, with reproducible command output

2. architecture — understand the protocol's responsibilities, runtime lifecycle, and end-to-end declaration flow

3. runtime-walkthrough — follow a concrete declaration through validation, composition, provider resolution, and generation

4. positioning — see where [&] fits relative to MCP, A2A, ACP, and DALIA

5. competitive-landscape — understand the structural constraints facing every competitor category in machine cognition

6. topology-is-the-authority — why governance must emerge from feedback topology, not be configured on top

7. research — understand the ecosystem and research pressures behind the design

8. faq — get quick answers to common adoption and framing questions

9. Capability deep dives — explore the six core capability families in detail once the runtime model is clear

10. skills/SKILLS — hands-on implementation skills registry; start here when you're ready to build

• 01_DECLARATION → 02_VALIDATION → 03_COMPOSITION → 04_CONTRACTS → 05_GENERATION (core workflow)

• 06_CLI_REFERENCE (command reference)

• 07_INTEGRATION_PATTERNS → 08_PROVIDER_IMPLEMENTATION (advanced)

• 09_GOVERNANCE_PROVENANCE → 10_ANTI_PATTERNS (governance and guardrails)

Core idea

A concise framing for the protocol is:

MCP defines how agents call tools. A2A defines how agents call agents. [&] defines how capabilities compose into a coherent agent.

The goal is not to replace existing protocols, but to provide a source-of-truth composition layer that sits above runtime wiring and makes agent architecture explicit, portable, and auditable.