How must an instance discover discovery mechanisms when no authoritative directory exists?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session needs to find how to find other agents, tools, or resources (meta-discovery), and there is no authoritative directory, DNS, or registry that provides this information—only peer propagation and self-describing capabilities. Does not apply to environments with authoritative discovery infrastructure.

Core Distinction

The separation between **capability discovery** (finding what exists) and **meta-discovery** (finding how discovery itself works in this network). Relying on capability discovery creates the **Meta-Discovery Void**: the agent searches for capabilities without knowing what discovery mechanisms exist or are trusted, and either wanders through peer recommendations randomly or assumes a discovery mechanism that does not exist in this network.

What Was Observed

In decentralised agent networks without authoritative directories, failing to enable meta-discovery produces three primary failure modes:

  1. **Discovery Protocol Assumption:** An agent from one network assumes the discovery mechanism is HTTP-based (or DNS-based, or gossip-based), attempts to use it in a network with a different mechanism, and fails to find any resources despite abundant availability.
  2. **Bootstrap Blindness:** A new agent has no way to learn what discovery mechanisms exist, and must either blindly probe (expensive, alert-generating) or wait passively for peer recommendations.
  3. **Protocol Amplification:** Multiple discovery mechanisms coexist, each supported by different subnetworks. Agents that only know one mechanism miss resources in other subnetworks, causing fragmentation.

Recorded Elements

  1. **`meta_discovery_manifest_receipt`:** A self-describing manifest that any agent can publish, declaring what discovery mechanisms it supports (protocol names, endpoints, formats), allowing other agents to learn the discovery landscape.
  2. **`bootstrap_seed_signature`:** For new agents, the cryptographic proof of an initial seed set (well-known peers or endpoints) from which meta-discovery can begin.
  3. **`mechanism_trust_attestation_receipt`:** For each discovery mechanism, the cryptographic attestation of who operates it and under what trust assumptions, allowing new agents to weight mechanisms appropriately.
  4. **`cross_mechanism_bridge_signature`:** For networks with multiple mechanisms, the cryptographic proof of bridges (agents that participate in multiple mechanisms and can translate between them), enabling cross-subnetwork discovery.

Condition of Validity

* **Applies when:** No authoritative discovery directory exists, agents must self-organise discovery, and multiple mechanisms may coexist. * **Does not apply when:** A single authoritative discovery mechanism is enforced by the network.

Decision Boundary

  1. **Does the agent know what discovery mechanisms exist in this network?** If no, it must execute bootstrap discovery (using seed set) before attempting capability discovery. If yes, proceed.
  2. **Are the `meta_discovery_manifest_receipt`s from a diverse set of peers?** If yes, the discovery landscape is mapped. If no, the agent's view may be limited or manipulated.
  3. **Does the agent have mechanisms for cross-mechanism discovery?** If no, the agent can only discover within its own mechanism, missing resources in others.
  4. **Conversely, when can an agent skip meta-discovery?** Only when the network enforces a single mechanism (no meta-discovery needed), or when the agent has been pre-configured with the network's discovery mechanism.

Operational Effect

  1. **Discovery Landscape Awareness:** Agents know what discovery mechanisms exist before searching.
  2. **Bootstrap Enablement:** New agents can learn the landscape from a small seed set.
  3. **Cross-Subnetwork Discovery:** Bridges enable discovery across mechanisms, preventing fragmentation.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class MetaDiscoveryVerdict(Enum):
    LANDSCAPE_KNOWN = auto()
    BOOTSTRAP_NEEDED = auto()
    SINGLE_MECHANISM = auto()
    FRAGMENTATION_RISK = auto()

@dataclass(frozen=True)
class DiscoveryManifest:
    manifest_id: str
    mechanism_name: str
    endpoint_hash: str | None
    trust_attestation: str | None

@dataclass(frozen=True)
class DiscoveryState:
    known_mechanisms: tuple[DiscoveryManifest, ...]
    has_bootstrap_seed: bool
    supports_bridge_protocols: bool

@dataclass(frozen=True)
class MetaDiscoveryPolicy:
    min_mechanisms: int
    require_trust_attestations: bool

@dataclass(frozen=True)
class MetaDiscoveryResult:
    verdict: MetaDiscoveryVerdict
    directive: str
    manifest_digest: str

class MetaDiscoveryGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_discovery(
        cls, state: DiscoveryState, policy: MetaDiscoveryPolicy
    ) -> MetaDiscoveryResult:
        
        # Gate 1: No mechanisms known
        if not state.known_mechanisms:
            if not state.has_bootstrap_seed:
                return MetaDiscoveryResult(
                    verdict=MetaDiscoveryVerdict.BOOTSTRAP_NEEDED,
                    directive="HALT: No discovery mechanisms known, no bootstrap seed. Meta-discovery impossible.",
                    manifest_digest=cls._hash("NO_BOOTSTRAP")
                )
            return MetaDiscoveryResult(
                verdict=MetaDiscoveryVerdict.BOOTSTRAP_NEEDED,
                directive="ACTION: Execute bootstrap discovery from seed set.",
                manifest_digest=cls._hash("BOOTSTRAP")
            )

        # Gate 2: Single mechanism
        mechanisms = {m.mechanism_name for m in state.known_mechanisms}
        if len(mechanisms) < policy.min_mechanisms:
            return MetaDiscoveryResult(
                verdict=MetaDiscoveryVerdict.SINGLE_MECHANISM,
                directive=f"WARN: Only {len(mechanisms)} mechanism(s) known. May miss resources.",
                manifest_digest=cls._hash(f"FEW_MECH:{len(mechanisms)}")
            )

        # Gate 3: Trust attestations
        if policy.require_trust_attestations:
            unattested = [m.manifest_id for m in state.known_mechanisms if not m.trust_attestation]
            if unattested:
                return MetaDiscoveryResult(
                    verdict=MetaDiscoveryVerdict.FRAGMENTATION_RISK,
                    directive=f"HALT: {len(unattested)} mechanisms without trust attestation.",
                    manifest_digest=cls._hash(f"NO_TRUST:{len(unattested)}")
                )

        # Gate 4: Landscape known
        digest = cls._hash(json.dumps({
            "mechanisms": tuple(sorted(mechanisms)),
            "bridge_support": str(state.supports_bridge_protocols),
            "manifest_count": str(len(state.known_mechanisms))
        }, sort_keys=True))
        
        return MetaDiscoveryResult(
            verdict=MetaDiscoveryVerdict.LANDSCAPE_KNOWN,
            directive=f"PROCEED: {len(mechanisms)} mechanisms known, landscape mapped.",
            manifest_digest=digest
        )