# context tags with lifecycles, not participant-scoped streams
Apple, Google, and carriers could ship contag inboxes tomorrow as an opt-in UI feature — context lists, lifecycle chips, per-contag unread. Nothing stops SMS, RCS, MMS, and iMessage clients from adding it; `#tags` work without them.
Contags is the missing object model: durable context objects between the same participants — Roof repair, Taxes, Startup — each with status, summary, next action, and its own message history. Replies answer what message; contags answer what context and what state.
Messaging models Person ↔ Person → messages. Human relationships are Person ↔ Person → Contags → messages. SMS, RCS, iMessage, WhatsApp, and Signal flatten project management, logistics, and long collaborations into one endless transcript. Replies create edges between messages but not durable context objects with lifecycles.
The missing primitive is a contag — label, status, summary, next action, unread count, lifecycle — layered on existing transports. Stable internal IDs; #roof as plain-text fallback for clients that don't speak Contags yet. Vendors already own the client; they could adopt the object model voluntarily while #tag text keeps everyone else compatible.
interactive specimen · prototype
Click through views — inbox, flat-stream critique, lifecycle actions, and native vs legacy clients.
contexts, not just replies
the observation
Messaging worked when it was where are you?, running late, ok — minutes-scale contexts.
Messaging is project management, family logistics, trip planning, business ops — contexts with lifetimes from hours to years, all in one participant-scoped timeline.
Email got subjects. Slack got channels. GitHub got issues. Messaging still uses People → Messages — one of the few major systems that skipped the middle layer.
why replies fail
What message was this responding to? — a tree over messages, not a durable context with status, summary, or next action.
What is this conversation about? What is its current state? Who owes the next move? — questions assistants and humans actually ask.
Active/stale status, context-specific unread counts, archiving, summaries, and next-action tracking don't emerge from reply threading alone.
The platforms have shipped organization features — WhatsApp Business labels, iMessage pinned conversations, Telegram group topics, Google Messages categories. But a label sorts and a pin surfaces; none carries status, a summary, a next action, or a lifecycle. They mark a conversation from outside; a contag is an object inside it. That's the gap between a folder and a ticket.
the primitive
Stable contag_id internally; human label (Roof repair, Taxes 2025); optional color.
created → active → waiting → stale → closed → archived; reopenable at any time.
summary (one-line state), nextAction (who: what), unreadCount, duration (minutes to decades depending on context type).
platform-ready
They could, easily, whenever they want; we don't have to wait.
iMessage, Google Messages/RCS, Samsung Messages, carrier SMS apps already render threads, badges, and tap targets — a contag inbox is UI on data they could expose tomorrow. No protocol rewrite required.
Native context list per contact, lifecycle status chips, summary/next-action fields, per-contag unread — all opt-in; flat stream remains default for users who don't want it.
contag_id in sync metadata between capable clients; #tag in message body only when crossing legacy SMS/MMS. The blocker is product priority, not feasibility.
This is the whole motivation. Every vendor could add a context inbox as an opt-in tomorrow — the data is already theirs, the UI is already theirs, and machine-readable metadata has already shipped inside ordinary SMS once (origin-bound OTP codes). So the real question isn't "is it possible" — it's why every vendor has left the middle layer empty for twenty years. Contags is the answer, built in the open while we wait for them to notice.
transport
See #roof Can you ask the contractor about flashing? — plain text, fully readable, zero breakage.
Reconstruct Roof repair with full lifecycle UI from stable IDs; #tag is transport fallback, not the source of truth.
Machine-readable metadata already rides inside plain SMS: origin-bound one-time codes — the @example.com #123456 convention phones and browsers parse out of an ordinary text, with the domain published in the site's well-known metadata. A cross-vendor standard for structured data hiding in human-readable SMS shipped years ago; contag_id is the same move, one field over.
hashtag lane
Detect #topic in 1:1 or group conversations; create virtual contags; rename, archive, close, reopen, summarize; track unread per contag — proves demand before asking platforms.
Messages without a #tag land in a default lane; every topic gets its own filtered stream and compose context.
don't wait for the vendor
The standing question is why Apple, Google, and carriers left the middle layer empty for twenty years. That dependency is exactly what the lab's other investigations dissolve: bring the capability yourself instead of waiting for the platform.
Layers — user-controlled meta-apps over the existing web — renders the contag inbox on top of today's messaging surface without the host's permission. #tags ride as plain text; a Layer parses them into durable context objects locally. The vendor's blessing becomes optional, not required.
The #tag → contag parser is a small recognizer you ship to where it runs, not a protocol change you petition for. DESH already demos code-on-demand recognizers; webpoke pushes sandboxed WASM filters to the query side — the same move, bring the code to the data instead of waiting for the data model to change.
Stable #tags keep every legacy client readable while opted-in clients reconstruct the lifecycle. Adoption is opt-in per client, not a coordinated platform rewrite — the permissionless-innovation path the lab takes everywhere.
Whenever a capability waits on a vendor's roadmap, the answer is the same shape: a meta-app (Layers), a recognizer or filter shipped as code (code-on-demand), and a plain-text fallback for the rest. Contags is that pattern applied to messaging.
why AI cares
What conversations are active? Waiting on someone else? Stale for 30 days? Next action for each context? Decisions in the roof repair thread?
Those questions require reconstruction from an undifferentiated participant timeline — expensive, error-prone, and unnecessary.
artifacts
id, label, status, summary, nextAction, unreadCount, lifecycle
client-side contags from #topic detection — the demand-proving MVP
#tag serialization over SMS/MMS/RCS; origin-bound-OTP-style metadata for capable clients
context inbox with consequential lifecycle (archive/close leave the inbox, reopen restores), native vs legacy — on this page
edges
Conversations have structure and lifetimes; modern messaging flattened them into one participant-scoped stream. The question that started it and won't go away: every messaging vendor could add a context inbox as an opt-in tomorrow — the data and the UI are already theirs — so why has no one?