From TCP/IP Standards to a Literal Wiki

Level 1: Rules Versus Hints

Imagine that the top group writes traffic rules with exact signs, lane markings, and working lights. The bottom group hands every driver a note saying, “Please be sensible,” plus a page from the town notebook. The notes may be useful, and some have real structure, but the silly faces make fun of treating hints like hard rules. The joke is that computers once communicated through strict agreements and now increasingly depend on an AI reading the instructions and getting the general idea.

Level 2: Rules, Files, and Agents

A communication protocol is an agreed set of rules that lets separate systems exchange information. TCP helps bytes arrive reliably and in order. DHCP helps a device obtain network settings. HTTP structures requests and responses. TLS protects data in transit and helps establish who is on the other end.

The lower labels address AI tooling:

• MCP, or Model Context Protocol, lets an AI application discover and use external tools, data resources, and prompt templates through a standard client–server interface.
• A2A, or Agent2Agent, lets separate agent systems advertise capabilities and exchange messages and long-running tasks.
• SKILL.md packages instructions for an agent in a Markdown file, usually with a small structured header and optional supporting resources.
• A wiki is a collaboratively edited collection of pages. It can document rules, but it does not enforce them by itself.

The crude faces exaggerate a real difference. A computer processes a TCP header according to exact fields. An LLM reads a paragraph and estimates what it means from context. Modern agent systems often combine both: strict software carries a structured message, then a model interprets the flexible content. Junior developers should ask two separate questions when evaluating such a system: “Can different implementations exchange this message?” and “How do we verify that the agent acted on it correctly?”

Level 3: Standards by Suggestion

The visual is less a fair benchmark than a complaint about standards inflation. The top row represents infrastructure that survived decades of adversarial networks, independent vendors, malformed inputs, and enormous deployment scale. The bottom row represents a fast-moving AI ecosystem where a JSON schema, a Markdown convention, and a knowledge page may all be marketed with similar grandeur. One row says “these bytes mean exactly this”; the caricature says the other row means “the agent will probably get the idea.”

Yet the old protocols were not born fully armored. They accumulated extensions, security work, compatibility rules, reference implementations, and operational wisdom because real deployment found every optimistic assumption. MCP and A2A are younger and address different abstractions: connecting AI applications to tools and context, and coordinating opaque agent systems over long-running tasks. Their reuse of JSON-RPC, HTTP, streaming, authentication, and structured discovery is not laziness; it is sensible layering. Reinventing TCP for every agent would be less “gigachad” and more “incident report with custom packet captures.”

The criticism becomes valid when teams mistake transport success for task success. An MCP client may call the correct tool with valid JSON while the model chose the wrong tool. Two A2A implementations may exchange a task flawlessly while holding incompatible assumptions about completion. A skill may load exactly as specified while its prose is stale, contradictory, or vulnerable to hostile instructions in referenced content. The protocol can guarantee delivery and structure; it cannot automatically guarantee judgment.

This gap also explains why a wiki can start behaving like infrastructure. Organizations place tool descriptions, policies, runbooks, and business definitions into documents that agents retrieve at runtime. Suddenly an informal edit can alter production behavior without a compiler error, migration, or API-version bump. Documentation has always influenced humans, but agentic automation can convert it directly into action. If prose is executable in practice, it needs code-like ownership: review, version history, tests, scoped permissions, and rollback.

The meme’s strongest lesson is therefore not “new protocols are fake.” It is “know which guarantees belong to which layer.” MCP can standardize how a tool is discovered and invoked. A2A can standardize how a task is exchanged and tracked. SKILL.md can package instructions portably. A wiki can explain local meaning. None of them alone proves that an autonomous action is correct, safe, or aligned with the user’s intent. We did not abolish protocol engineering; we placed a nondeterministic coworker above it and hoped the onboarding page was current.

Level 4: Bytes Before Vibes

The meme places four muscular figures under “PROTOCOLS THEN”—TCP/IP, DHCP, HTTP, and TLS—and four deliberately malformed figures under “PROTOCOLS NOW”—MCP, A2A, SKILLS.MD, and “A LITERAL WIKI.” Its technical accusation is that “protocol” once meant a deterministic contract between independent implementations, whereas the agent era increasingly uses the word for prose that a probabilistic model is expected to interpret helpfully.

Classic network protocols earn their visual muscles by constraining behavior at the wire and state-machine levels:

• IP defines packet addressing and best-effort forwarding across networks.
• TCP builds a reliable ordered byte stream using sequence numbers, acknowledgments, retransmission, flow control, and congestion control. Both endpoints move through defined states; dropped and reordered packets are expected conditions, not creative suggestions.
• DHCP allocates network configuration through a lease lifecycle commonly summarized as discover, offer, request, and acknowledgment. It has to work before a new client necessarily knows its own address.
• HTTP defines request, response, method, status, header, and caching semantics at the application layer.
• TLS negotiates cryptographic parameters, authenticates peers—typically at least the server—and derives session keys before protecting application records for confidentiality and integrity.

These are not all peers in one flat layer, which is the meme’s first useful distortion. HTTP and TLS normally ride on lower transport and network machinery; DHCP commonly rides over UDP and IP; “TCP/IP” names a suite rather than one isolated mechanism. The modern entries do not replace that stack either. Remote MCP and A2A traffic ultimately relies on the supposedly retired muscular protocols below it. The weak Wojaks are standing on the strong Wojaks’ shoulders while pretending the family no longer speaks.

The second distortion is that MCP and A2A really do have machine-readable protocol surfaces. MCP uses a client–server architecture and a JSON-RPC data layer with requests, responses, notifications, lifecycle initialization, version and capability negotiation, and primitives such as tools, resources, and prompts. Its transports include local standard input/output and Streamable HTTP. A2A defines data objects such as agents, messages, tasks, parts, and artifacts; operations for sending messages and tracking or cancelling work; discovery through an Agent Card; and bindings to established RPC or web mechanisms. Parsers can validate their envelopes even if an LLM later makes an eccentric decision with the contents.

SKILL.md is where the comparison becomes intentionally savage. An agent skill is generally a directory whose required Markdown file contains structured frontmatter—such as a name and description—followed by natural-language instructions, with optional scripts and reference material. There is a format contract around discovery and loading, but the operational meaning often depends on a model interpreting prose. “A LITERAL WIKI” goes further: a wiki can share conventions and knowledge, yet without a normative schema, state machine, error model, or conformance test, it is documentation rather than a communication protocol.

The deep issue is a split between syntactic interoperability and semantic interoperability. Traditional protocol logic can reject an invalid field or unexpected state deterministically. Agent systems may successfully exchange a perfectly valid JSON message and still disagree about what “research this thoroughly,” “safe to deploy,” or “done” means. The wire contract succeeded; the task contract dissolved into probability. Reliability therefore has to be built on both sides of the model boundary:

1. Keep identity, authorization, versioning, schemas, timeouts, cancellation, idempotency, and error states explicit in code.
2. Treat natural-language goals as untrusted, underspecified input.
3. Validate model-selected actions against typed arguments and policy.
4. Verify outcomes with observable postconditions rather than trusting a fluent completion.

That is the mathematical cruelty behind the joke: a schema can constrain the set of valid messages, but it cannot force a stochastic model to infer the intended goal. The modern standards are solving a higher-level coordination problem, so some ambiguity is unavoidable. Calling the whole thing a protocol becomes credible only when the deterministic shell is strong enough that ambiguity cannot silently become authority.