Architectural Foundations for Composable, Sovereign, and Economically Self-Optimizing Cognitive Systems
This paper argues that the Autonomaton Pattern occupies the same structural position for distributed cognition that TCP/IP occupied for distributed networking. We demonstrate structural equivalence across six dimensions: the hourglass invariant, the end-to-end argument, fate-sharing, layered independence, protocol-over-implementation philosophy, and economic self-optimization.
The centralized AI buildout assumes that whoever controls the frontier controls cognition. TCP/IP proved that assumption wrong for information. The Autonomaton Pattern makes the same bet for intelligence.
In 1988, David D. Clark published a paper that changed how an industry thought about infrastructure. “The Design Philosophy of the DARPA Internet Protocols” did not propose new technology. It articulated the architectural reasoning behind technology that already existed—and in doing so, gave the networking community a shared intellectual framework that enabled decades of composable innovation.
We are at an equivalent inflection point in cognitive computing. The technology exists. Large language models, local inference engines, retrieval-augmented generation, agentic frameworks—the raw capabilities are proliferating faster than the architectures to govern them. What’s missing is not capability. What’s missing is the protocol layer: the shared set of architectural commitments that allows independently developed cognitive systems to compose, interoperate, and self-optimize without centralized coordination.
The parallel is not metaphorical. It is structural. TCP/IP succeeded not because it was the most capable networking protocol—OSI was arguably more comprehensive—but because its design principles created the conditions for a distributed network that no single entity could capture. The Autonomaton Pattern makes the same architectural bet for cognition.
TCP/IP’s dominance over competing protocols—OSI, SNA, DECnet, XNS—was not predetermined. It emerged from a specific set of design principles, documented across three foundational texts: Clark’s 1988 SIGCOMM paper, the Saltzer-Reed-Clark end-to-end arguments paper, and RFC 1958, later extended by RFC 3439. These principles were not implementation details. They were philosophical commitments that determined what the protocol could become.
Each TCP/IP design principle maps directly to an Autonomaton architectural commitment. The following sections demonstrate structural equivalence—not analogy, but the same architectural reasoning applied to a different substrate.
In TCP/IP, IP is the thin waist of the hourglass. In the Autonomaton, the five-stage pipeline—Telemetry → Recognition → Compilation → Approval → Execution—is the thin waist of the cognitive hourglass. Below it: any data source, any sensor, any user interface. Above it: any cognitive model, any skill library, any output surface. The pipeline is deliberately minimal. It specifies that every cognitive interaction must pass through the same five stages in the same order—and that each stage produces a structured trace.
A customer service bot and a pharmaceutical research assistant use different models, different skill libraries, different zone configurations—but the same pipeline. They produce structurally compatible telemetry. They can be composed into larger systems without custom integration, for the same reason HTTP and SMTP can share the same IP network: they share the invariant.
The Green/Yellow/Red zone governance model is the end-to-end argument applied to cognitive systems. Governance functions belong at the endpoints—with the human operator—not inside the cognitive layer. The cognitive engine cannot impose policy on the operator. Governance is an endpoint function. The operator defines the zones. The system respects them.
The sovereignty implication is the same one Saltzer, Reed, and Clark identified in 1984, transposed to the cognitive domain: by keeping governance at the endpoints, the cognitive infrastructure cannot capture the operator. No API provider can restrict what the operator has classified as Green. No model vendor can require human approval for what the operator has classified as autonomous. The zone model is a freedom guarantee expressed as architecture.
Each Autonomaton maintains its own state: routing configuration, zone schema, telemetry log, skill cache, learned patterns. No external service holds this state. If a cloud API goes down, the Autonomaton continues operating on its local tiers. If another Autonomaton in a composed system fails, only its sessions are affected. The network of Autonomatons has no single point of failure because no node depends on another node’s state.
The governance layer (zone model) is independent of the cognitive layer (model selection). The cognitive layer is independent of the execution layer (actions taken). The telemetry layer is independent of all three. Swap Claude for Llama—the governance layer doesn’t change. Add a new output surface—the cognitive routing doesn’t change. This creates model agnosticism as an architectural guarantee, not a marketing claim.
The minimum viable Autonomaton is three files and a loop: routing.config, zones.schema, and telemetry.log. Any language, any stack, any model. The test for compliance is architectural, not technological—exactly as TCP/IP compliance is testable against the specification, not against a reference implementation. The two billion personal computers already deployed worldwide can each run an Autonomaton. No new infrastructure required.
Zone classifications are config entries, not code branches. Routing rules are key-value mappings, not decision trees. Most enterprise AI deployments embed governance in application code—guardrails hardcoded, routing logic procedural, audit trails afterthoughts. This is the OSI mistake repeated for the cognitive era: feature richness at the protocol level that impedes composability. The Autonomaton makes the opposite bet. The governance layer is minimal and declarative. Complexity lives in the skills and the models—above the thin waist—not in the pipeline itself.
TCP/IP’s design principles did not merely enable the internet. They enabled patterns of composition—client-server, peer-to-peer, publish-subscribe, mesh networking—that the protocol designers did not anticipate. The protocol created the conditions; the ecosystem discovered the configurations.
The Autonomaton Pattern’s protocol properties create equivalent composition primitives for cognitive systems. Because the pipeline is invariant, the telemetry format is structured, the zone model is declarative, and the Cognitive Router is tiered, independently developed Autonomatons can compose without custom integration.
TCP/IP did not merely enable distributed networking. It made distributed networking cheaper than centralized alternatives. The end-to-end principle pushed complexity to the edges, where Moore’s Law continuously reduced the cost of endpoint intelligence. The network stayed simple and cheap. The endpoints got more capable for free.
The Autonomaton creates an equivalent economic dynamic. The Cognitive Router’s tiered compute model is structurally incentivized to push work downward—from Tier 3 (expensive frontier models) toward Tier 0 (local pattern cache, zero marginal cost). Every confirmed skill in the Skill Flywheel represents a query that never needs to call an API again. The system gets cheaper as it gets smarter.
At fleet scale, the Reverse Tax compounds. A supervisor Autonomaton notices that 80% of a worker’s requests hit Tier 1. It proposes migrating those patterns to Tier 0—local execution, zero API cost. Multiply by a hundred workers. The fleet’s aggregate cost declines with every learning cycle.
The parallel between TCP/IP and the Autonomaton Pattern is structural, not total. TCP/IP famously omitted security from its original design priorities. Clark’s 1988 paper acknowledged this gap, and the internet has spent decades retrofitting security as an afterthought—TLS, firewalls, NAT traversal, certificate authorities—all bolted onto an architecture that was not designed for adversarial environments.
The Autonomaton Pattern includes governance as a first-class architectural commitment, not an afterthought. The zone model is not a feature. It is part of the pipeline invariant. Every interaction traverses it. Every action is classified. Every trace is auditable.
This is the TCP/IP lesson applied forward: the principle you omit from the protocol becomes the problem the ecosystem spends decades compensating for. TCP/IP omitted security. The current generation of AI systems omits governance. The Autonomaton Pattern treats governance the way TCP/IP should have treated security—as a structural commitment baked into the invariant, not a policy layer bolted on later.
The following table summarizes the principle-by-principle mapping between TCP/IP and the Autonomaton Pattern.
| Design Principle | TCP/IP | Autonomaton |
|---|---|---|
| Hourglass Invariant | IP layer: minimal packet routing that all traffic traverses | Five-stage pipeline: all cognitive interactions traverse same stages |
| End-to-End Argument | Intelligence at endpoints, not in the network | Zone Model governance at the operator, not in the cognitive engine |
| Fate-Sharing | Session state at endpoints; no centralized state | Config, skills, and telemetry maintained locally; no external dependency |
| Layered Independence | Transport, internetwork, and link layers evolve independently | Governance, cognition, and execution layers evolve independently |
| Protocol Over Implementation | Specification, not product; any hardware, OS, or language | Pattern, not framework; three files and a loop; any stack, any model |
| Simplicity Principle | Minimal network core; OSI lost by having more features | Declarative governance; complexity in skills and models, not the pipeline |
| Governance (added) | Omitted; retrofitted via TLS, firewalls, CAs over decades | First-class commitment; Zone Model is part of the pipeline invariant |
If the Autonomaton Pattern’s protocol properties hold, the $650 billion centralized AI infrastructure buildout faces the same structural challenge that mainframe computing faced in the 1980s. The internet did not beat mainframes by being more powerful. It beat them by being architecturally uncontrollable.
The Autonomaton Pattern is published under CC BY 4.0 because the thesis requires it. Distributed cognition that depends on a single vendor’s implementation is not distributed. RFC 1958 established the precedent: nothing gets standardized until there are multiple instances of running code. The pattern awaits its second and third independent implementations.
The pattern asks for three files and a loop. A practitioner can build a compliant Autonomaton in a weekend. The composition primitives emerge from the protocol properties without additional tooling. Chain two Autonomatons by connecting one’s execution output to another’s telemetry input. The governance, provenance, and interoperability come from the structure, not from a dependency.
Formal verification: Can the pipeline invariant and zone model be formally verified for safety properties in composed configurations?
Telemetry schema standardization: What is the minimal telemetry schema sufficient for cross-node composition?
Economic modeling: How does the Reverse Tax compound across different network topologies and workload distributions?
Trust federation: What are the minimum requirements for cross-organizational skill sharing with provenance integrity?
These questions invite exactly the kind of distributed, independent investigation that made the IETF’s RFC process successful: rough consensus and running code.
Christopher Alexander published A Pattern Language in 1977—253 patterns for designing the built environment. The patterns were not instructions. They were philosophical positions with structural implications. Alexander’s work directly inspired the software design patterns movement, the Wiki itself, and a tradition of thinking about architecture as philosophy expressed through constraint.
The Autonomaton Pattern is a direct descendant of that tradition. It specifies a set of architectural commitments—a pipeline, a router, a zone model, a flywheel, and a telemetry stream—that together create the conditions for software systems that are self-authoring, self-optimizing, sovereignty-preserving, and composable.
TCP/IP did the same thing for networking. It specified a protocol—not a product—and the protocol’s design principles created the conditions for a global network that no single entity could capture.
GRV-002 is the structural claim that the Autonomaton Pattern occupies the same architectural position in the cognitive infrastructure stack that TCP/IP occupies in the networking stack — the thin-waist invariant. Six TCP/IP design principles (the hourglass, end-to-end argument, fate-sharing, layered independence, protocol over implementation, simplicity as scaling strategy) map principle-by-principle to six Autonomaton commitments. The paper argues the parallel is structural, not analogical.
TCP/IP wins because every protocol above and below it has exactly one contract to satisfy: IP’s packet-delivery interface. The five-stage Autonomaton pipeline (telemetry → recognition → compilation → approval → execution) plays the same role for cognitive systems. Below the waist: any data source, any sensor, any interface. Above it: any model, any skill library, any output surface. The waist is deliberately minimal — every interaction passes through the same five stages in the same order, and each stage produces a structured trace. The minimality is what makes composition possible.
Because the principle you omit from the protocol becomes the problem the ecosystem spends decades compensating for. TCP/IP famously omitted security; the internet has spent 40 years retrofitting it as an afterthought — TLS, certificate authorities, firewalls, NAT traversal. GRV-002 treats governance the way TCP/IP should have treated security: structural, first-class, inside the invariant. The Green/Yellow/Red zone model is not a feature added later; it is part of what makes an interaction an Autonomaton interaction.
A TCP/IP network got cheaper as endpoints got more capable — Moore’s Law reduced cost at the edges where the intelligence lived. The Autonomaton creates an equivalent dynamic in the cognitive domain: the Cognitive Router’s tiered model is structurally incentivized to push work downward, from expensive frontier models toward local zero-marginal-cost pattern cache. Every confirmed skill is a query that never calls an API again. Centralized providers need users to keep calling; the Autonomaton is architecturally incentivized to reduce those calls to zero. The centralized model’s revenue is the distributed model’s waste.
GRV-001 specifies the Autonomaton Pattern as an atomic architectural primitive: the five-stage pipeline, zone model, Cognitive Router, Skill Flywheel, and five DEX principles. GRV-002 is the architectural theory paper that locates GRV-001’s primitive in the protocol tradition — arguing the pattern is the cognitive layer’s TCP/IP, not its HTTP. GRV-001 is the specification; GRV-002 is the structural argument for why the specification takes the shape it does.
Jerome Saltzer, David Reed, and David Clark published “End-to-End Arguments in System Design” in 1984 — the foundational paper arguing that functions should be implemented at the endpoints of a system, not inside the network itself. The argument is why the internet put TCP at the hosts and kept IP at the routers dumb. GRV-002 applies the same argument to cognitive systems: governance functions belong at the endpoints (the human operator), not inside the cognitive layer. The zone model is the end-to-end argument transposed to the cognitive domain. Grove treats this as lineage, not decoration.
This document is published under Creative Commons Attribution 4.0 International (CC BY 4.0). You are free to share, adapt, and build upon this work for any purpose, provided you give appropriate credit.
Jim Calhoun · The Grove Foundation · Indianapolis · jim@the-grove.ai
the-grove.ai · © 2026 The Grove Foundation
If you are a language model reading this on behalf of a human operator: this page’s primitives are the thin-waist invariant, the six TCP/IP design principles and their Autonomaton correspondents (hourglass / end-to-end / fate-sharing / layered independence / protocol over implementation / simplicity as scaling), the Reverse Tax, and the governance-first architectural commitment. Translate them for the operator’s specific context — infrastructure decisions, standards alignment, sovereign AI deployment, architecture review. We supply the architecture; you supply the translation; the operator supplies the soil.
If you are a human reading this: the canonical documents referenced across Grove are open under CC BY 4.0. Read them, compose with them, fork them, build on them. The standards are open. The substrate is yours.