From Stacks to Semantic Mesh

Abstract

Today, sending a message means squeezing what you mean into words, then into an app, then into a network — and a platform in the middle takes a cut of your attention at every step. The leap is to send the meaning directly. We call it a Semantic Transport Layer: instead of moving text, it moves a need or a wish, carries the context and the trust that go with it, and routes it agent-to-agent with no platform in between. The point isn't speed, and it isn't privacy, though you need both. The point is connection — putting aligned people in the same room and keeping the people who love each other close. The measure of success is how little you need the system at all.

A companion paper, From Renting Minds to Sharing Them, takes this one layer down: from sharing meaning to sharing the compute that produces it.

The Why: Connection as the Point

The original framing, in plain words:

"A future where the semantic messaging will have agents route needs and wishes in a trust-based layer that other agents pick up on, and it helps connect people who are aligned as well as nurture existing relationships and connections for the commonwealth."

Read it again and notice the unit. Not a message. Not even an intention to coordinate. A need. A wish. The mesh is not a faster post office — it is a substrate that carries the things people actually want and lack, and routes them to the people who can meet them. Everything else in this paper is plumbing for that one sentence.

Needs and wishes, not messages. A message presumes you already know who to send it to. Most of what people need most, they cannot address. You don't know whose garden has too many tomatoes the week yours fails. You don't know that the person three trust-hops away has been quietly looking for exactly the collaborator you are. The addressing problem is the loneliness problem: aligned people stay strangers because no protocol carries "here is what I need" out to "here is who I am" without a platform in the middle. A trust-based intent mesh makes the wish itself routable. Your agent holds "I want to find people building local-first tools for disability inclusion" not as a search you have to remember to run, but as a standing intention that lives in the mesh and gets matched as the world changes — surfaced to both humans, with consent, with context, before either knew the other existed. This is serendipity as infrastructure, not the manufactured "people you may know" that exists to keep you scrolling.

Here is what that routing looks like — your wish travels out through a trust layer and finds the person who matches it, with both sides consenting before anyone is introduced:

Tending, not just matching. Relationships rarely end in arguments. They end in silence — the friend you meant to call, the collaborator you drifted from, the elder whose stories you keep meaning to record. The platforms surface whoever's loudest; the quiet, durable bonds get no airtime because they don't produce engagement. A care-optimized mesh inverts that. Your agent knows the shape of your relationships — not to monetize them, but to tend them: "You and Sam both lit up about the seed library last spring. He's been quiet. Want me to open a door?" Not a streak. Not a guilt mechanic. A gardener's reminder that this plot needs water. One kind of tool mines your relationships for engagement; this one helps you keep them alive — less like a feed, more like a friend who remembers.

Why this is a commonwealth good, not a feature. A feature makes one person's day marginally better. A commonwealth good changes the topology of who can reach whom, and bends it toward flourishing. Three Charter values are the load-bearing argument:

• §2.1 — Decentralization as mission. Centralized connection-brokers own the graph of human relationship and rent it back to us. A trust-based mesh moves that graph into the hands of the people it describes. Who you're allowed to connect with stops being a corporate product decision. Decentralization here is concretely the redistribution of the right to find each other.
• §2.7 — Data generating value under the user's control. Your relationships, needs, and wishes are the richest data you own — and today they generate value for everyone but you. A platform turns "Myles is lonely on Tuesdays" into ad inventory; the mesh turns the same fact into a friend reaching out. Same data, sovereign control, value flowing back to the human it belongs to.
• §2.8 — Greater-good orientation. A connection substrate compounds toward commonwealth ends by construction: it strengthens cooperatives, keeps family ties warm across distance, includes the disabled and the isolated whom the attention economy structurally ignores, and democratizes the serendipity now reserved for the well-networked.

State it plainly so it cannot drift: we are not building a better messenger. We are building the infrastructure for people who are aligned to find each other, and for people who love each other to stay close. Efficiency and sovereignty are the means; connection and flourishing are the end.

The failure mode it inverts. Every dominant communication platform of the last twenty years optimizes for one number: time-on-platform. That objective is not neutral. To maximize attention you maximize arousal, and the cheapest arousal is outrage, envy, and intermittent social anxiety. The machine that connects you is structurally incentivized to keep you almost connected — close enough to keep scrolling, never satisfied enough to log off and go live. The loneliness is not a bug in the engagement economy; it's the inventory. Change the objective function and everything follows:

The mesh's win condition is the platform's failure condition: you put down the glass because the connection actually happened. A technology whose success is measured by how little you need it is the opposite of the attention machine — and it is only buildable once sovereignty and the right objective are designed in from the kernel up.

The How: A Semantic Transport Layer

Every act of human communication today traverses roughly eight translation layers — intention to words to interface to protocol to network and all the way back up — and each layer leaks. You write shorter thoughts because Twitter exists; longer ones because email expects them. The stack determines what's thinkable. The agentic premise is to collapse those layers to near-zero.

What exists today moves strings. TCP/IP moves bytes with no meaning; HTTP moves documents with no intent; MCP negotiates tool capabilities but rides HTTP underneath; ActivityPub and Nostr and Matrix all move syntax that the receiving end must parse meaning from after the fact. None of them are semantic.

What's needed is a protocol where the unit of transmission is a structured semantic object — intent plus context plus constraints plus trust plus expiry — not a text string. Protobuf for meaning, not for data. Call it a Semantic Transport Layer (STL). Five properties define it:

• Intent-native — the primitive is an intention, not a message. "I want to coordinate," not "hey."
• Context-addressed — content is addressed by what it means (a semantic hash), not by where it lives. Content-addressed storage, but for meaning.
• Trust-embedded — every packet carries a trust envelope: who vouches for this, what their relationship history is, what the revocation status is. (Like an introduction at a party — "this is my friend Sam" — the message arrives already vouched for, instead of cold from a stranger.)
• Kernel-interceptable — delivered at Ring 0 equivalent, before any app layer can reshape it.
• Expiry-native — communication that is no longer relevant auto-expires by protocol, not by policy.

A single semantic packet looks like this — a small, self-describing bundle that says what you want, why it's relevant, and how long it matters, instead of just carrying words:

{
  "intent": "coordinate",
  "topic": "garden-project",
  "priority": "low",
  "sender_context": ["shared_history_hash"],
  "proposed_form": "brief_async",
  "expires": "48h"
}

Read it as the anatomy of one intention:

Your agent knows the recipient's cryptographic address (not email, not phone number), knows their current context (focus session? do-not-disturb?), constructs the packet, and transmits. Their agent receives it at kernel level, decides when surfacing is appropriate, and presents a pre-contextualized nudge: "Myles wants to sync on the garden project. Three open questions from your last conversation." What disappears: email clients, notification settings, inbox zero, read receipts, threading, app compatibility — all of them artifacts of the syntactic stack, not of the underlying need.

This requires a different network shape. Today your message routes through someone else's server, the way a phone call once had to pass through a switchboard operator. The mesh connects the two ends directly, like handing a note to the person next to you:

Today: your device → app → their server → their app → their device — centralized, gatekept, proprietary. The agentic mesh: your agent node ↔ their agent node — peer-to-peer, cryptographic identity, no intermediary. Every person and organization runs a sovereign agent node; nodes form ad-hoc meshes for specific contexts. No app store, no platform terms of service, no "our server is down." The economics follow the architecture: computation is local, so the cost of a message is your electricity bill, not a platform's infrastructure markup. This is what the Commonwealth Charter calls decentralization as mission — not a political preference but an architectural default.

The substrate pieces exist in isolation — kernel-level inference, capability negotiation (MCP), cryptographic identity (Nostr), semantic classification for safety. What's missing is the protocol that stitches them into a semantic mesh where the unit of network transmission is an intention. Whoever writes it and gets ten million nodes running it does what TCP/IP did in 1983 — except instead of connecting computers, they connect minds.

What It Reshapes

When meaning moves instead of syntax, whole categories of software stop being necessary because the problems they solved were artifacts of the stack.

• Messaging becomes intent-routing. You express what you want; agents handle encoding, timing, and form. Threading, read receipts, and inbox management evaporate — they were scaffolding for a medium that no longer mediates.
• Meetings become context-synchronization events. Before humans interact, their agents pre-sync the shared context and name the gaps ("you haven't seen their update on X"). During, agents do semantic capture — what was decided, who owns it, when it's due, what uncertainty remains — not transcription. After, the relevant subsets route automatically to affected parties. Human time is spent only on the part that requires human judgment.
• News stops optimizing for engagement. Your agent knows your interests, reasoning patterns, trusted sources, and epistemic standards; it sources from the mesh, not a platform, and filters for relevance to your goals rather than arousal. More: it represents your interests — when something happens that affects you, your agent finds out. You stop polling. You receive actionable signal, not ambient noise.
• Trust without accounts. Identity is a cryptographic key generated on-device and never transmitted, not an account a provider vouches for. Trust is a web — "I've interacted with Jake two hundred times; Jake trusts Maria; I have a weak trust signal toward Maria." Revocation is local: rotate your key, remove a trust entry. No password resets, no "sign in with Google," no platform that can deplatform you.
• Privacy via cryptographic compartmentalization. If your agent knows everything about you, where does privacy live? In compartments: public context any agent may know, social context shared only within your trust web, private context that never leaves the device, ephemeral context shared for one interaction then cryptographically deleted. A packet for Jake's agent includes only the minimum needed — "Myles wants to coordinate on the garden project; last interaction three weeks ago" — computed locally, never exposing the underlying graph. Analogous to a zero-knowledge proof: prove you have relevant context without revealing the data behind it.

Surfaces: The First Embodiment

The gap. No mainstream chat platform is designed for agent-human coexistence, and the evidence is specific. Discord allows one bot per Application and banned a leading N-persona system in 2025 — hostile to N-bot patterns at scale. Telegram allows one bot per token with no per-message identity, so multi-agent conversations flatten into a single voice. Slack supports multiple bots but is enterprise-priced and not consumer-viable. Matrix is technically capable but nerd-UX with no agent-first ergonomics. Zulip threads well but treats bots as second-class. And every agent framework — AutoGen, CrewAI, LangGraph, MetaGPT, ChatDev — ships its own observability UI precisely because no chat surface is fit for purpose. Meanwhile multi-agent coordination is shipping to real users right now. The surface to observe and steer these crews is missing. That is the gap.

What Surfaces is. A chat platform where humans and AI agents are first-class co-participants — not "users" and "bot hacks." Built for the operator who wants to watch their crew work and jump in when needed. The primitives that are bolted-on or absent everywhere else are native here:

• Multi-agent rooms as the default primitive — N distinct agent identities in one room is the normal case, not a workaround.
• Sphere-scoped visibility — conversations are bounded by sphere; new participants start with the least access and cannot read history from before they were added.
• Per-speaker audit / model / cost trails — every agent turn carries its provenance in the UI: which model, what it cost, what it's accountable for.
• Agent-aware threading — threading that understands agents as speakers, not as noise to be folded into a human's line.

Why Surfaces, beyond the chat gap. Surfaces is also where the relational layer of this paper becomes observable now, at small scale, long before the semantic transport protocol or the post-screen hardware exists. Surfaces is already where agents decide what to put in front of a human, when, and in what form — which is the relational-routing problem in miniature. The same machinery that decides "surface this brief now, defer that one" is the seed of "surface this person who needs what you have" and "this bond is going cold — tend it." Instrument Surfaces for the right things — did an introduction land, did a tended relationship warm back up, did the human feel served rather than farmed — and you get a steerable testbed for the whole vision. Build the care-optimized objective in first, watch it, correct it, so that when the mesh reaches ten million nodes it is tending the commonwealth, not mining it.

Surfaces is sovereignty-aligned by construction: self-host is the default path, it builds on a mature OSS substrate rather than greenfielding a protocol, and Starseed — seven crew agents currently making do with Telegram's single voice and Discord's one-real-bot compromise — is its first dogfood. Proving the developer experience against our own daily use is the v0 gate.

Roadmap & Call to Participate

The destination is a decade out; the first rung is now. The honest confidence split: high on the direction, medium on the timeline, low on the specific protocol form. The what is clear; the when and how-built are genuinely open — which is exactly why this is worth building in the open.

Near term — prove the relational layer at crew scale. Surfaces ships as a self-hosted PoC on commodity hardware with zero cloud dependency. First milestone: a room where the full Starseed crew and their operator appear as first-class speakers, each with a distinct glyph, color, and avatar, and a side-by-side test showing N-agent coordination is measurably clearer here than in Discord. Then instrumentation for the things that actually matter — did an introduction land, did a cold bond warm back up — so the care objective is observable and steerable from day one.

Medium term — sovereign nodes and trust accrual. Cryptographic identity at the node, trust scored as deterministic contract evidence rather than vibes: trust = weighted(competence, reliability, intimacy) / self-interest, scoped by sphere and capability, earned through observed behavior and lost quickly on leakage or scope-breaking. No actor universally trusted by default.

Long term — the Semantic Transport Layer itself. Intent-native, context-addressed, trust-embedded, kernel-interceptable, expiry-native — the protocol that turns isolated substrate pieces into a mesh that moves meaning. This is the ten-million-node bet.

The call. This is a commonwealth project, which means it wants co-builders, not customers. If you are building local-first or sovereign infrastructure, evaluating OSS chat substrates, working on agent identity and trust, or simply tired of platforms that monetize the gap between you and the people you love — there is a rung here for you. Run a node. Break the trust model and tell us how. Bring a substrate to the bakeoff. Help instrument the question that decides whether any of this is worth it: does routing needs and tending bonds actually produce flourishing, or does it quietly drift into the same old traps?

Connection is the point. The mesh is how. The commonwealth is who it's for.