Two Gaps: What Rune and Wake Are Actually Solving

The Same Accident in Two Forms

Building both Rune Protocol and Wake Intelligence in the same period creates an odd feeling — the sensation of working on two separate things that are somehow the same thing. Different surfaces, different APIs, different problems on the face of it. One is a reactive binding protocol. The other is an MCP server for temporal context memory.

The connection isn't aesthetic. It's structural. Both tools exist because intent — the meaning a developer puts into a decision — gets lost. What makes them different is where it gets lost.

There are exactly two places.

The first is in the moment of collaboration: the gap between what a developer means and what AI can structurally access right now, in this file, during this session. Call it the synchrony gap.

The second is between sessions: the gap between a decision made at 11am Tuesday and the empty context an AI agent starts with at 9am Wednesday. Call it the temporal gap.

Rune closes the synchrony gap. Wake closes the temporal gap. Neither one alone is sufficient. Together they describe what semantic continuity actually requires.

The Synchrony Gap

When AI works with a codebase, it operates in one of two modes: inference or declaration. The difference is not subtle.

In inference mode, AI reads a property named riskThreshold and reconstructs everything it needs to know. It finds a setter, so: probably mutable. It finds a method that checks it before an order is placed, so: probably consequential. It searches for comments — and usually finds none. Every step is probabilistic. The quality of the reconstruction degrades with codebase size, naming inconsistency, and the passage of time.

// AI infers — reconstructing from clues
class TradingEngine {
  riskThreshold: number = 0.15;       // mutable? probably. why 0.15? unknown.

  async submitOrder(orderId: string) { // consequential? looks like it. log? unclear.
    if (this.riskThreshold > ...) { ... }
  }
}

In declaration mode, the codebase has already answered every question AI would otherwise approximate. The intent is structural — not inferred from naming conventions or comment search, but read directly from the code itself.

// AI reads — no reconstruction required
class TradingEngine {
  @RuneState
  @RuneIntent("approved by risk committee Q1-2025 — review at quarter end")
  riskThreshold: number = 0.15;

  @RuneAction("submit-order")
  @RuneIntent("explicit, logged to OMS, irrevocable — pre-trade risk check runs here")
  async submitOrder(orderId: string) { ... }
}

The four Rune sigils — @ read, ~ sync, ! act, ? intent — are governance primitives, not annotations. ~risk-threshold doesn't say “this is mutable.” It signals: mutable, governed, bidirectional. The AI won't cache it silently, won't inline it, won't batch !submit-order with side effects it hasn't declared.

The ? primitive is the one that directly addresses the synchrony gap. Unlike comments — which are stripped by compilers, don't travel with bindings across layers, and carry no structural relationship to the construct they annotate — ? is co-located with the binding it governs, versioned in the same commit, and addressable at runtime. The rationale doesn't float away into a README. It stays.

The synchrony gap is closed because the codebase speaks directly. AI assistance stops being bounded by how accurately the reconstruction matches reality, and starts being bounded by the quality of the declarations — which are first-class, maintained by the same discipline that maintains the code.

The Temporal Gap

The synchrony gap exists within a session. Close it and a different gap remains.

AI enters each session with no persistent context. No accumulated understanding of the project. No memory of Tuesday's three-hour architecture discussion or the reason the authentication approach changed or which threads were abandoned and why. Every session starts from what's in the files — which captures whatwas decided, almost never why.

This is not a failure of AI. It is the default state of every system that doesn't explicitly preserve temporal context. The failure is the absence of infrastructure for preserving it.

// Without temporal context — AI reconstructs from code
// "We're using OAuth2. Why? The code doesn't say."
// "This rate limiter was added when? Unknown. By what decision? Gone."

// With Wake — context travels forward in time
save_context({
  project: "auth-refactor",
  content: "Chose OAuth2 over JWT. Need PKCE for mobile, social login for consumer tier.",
  actionType: "decision",
  causedBy: "ctx_security_review_4a9b"    // the discussion that caused this decision
})

// Next session:
load_context({ project: "auth-refactor", limit: 3 })
// ↳ Layer 1: Why OAuth2? Trace back to ctx_security_review_4a9b
// ↳ Layer 2: ACTIVE tier — accessed 6 times this week
// ↳ Layer 3: Prediction score 0.87 — likely needed again today

Wake's five layers each close a specific dimension of the temporal gap:

The temporal gap isn't just “AI doesn't remember.” It has structure. There's the causality gap (why was this decided?), the relevance gap (is this still active?), the prediction gap (what will be needed next?), and now the posture gap (how should this context be framed for the question being asked?). Each layer is a targeted answer to a specific dimension of the same problem.

Different Mechanisms, Same Property

Rune is a protocol. Wake is an MCP server. They have nothing in common technically. What they share is a single property: neither relies on prose that decays.

Comments decay. Documentation drifts. READMEs go stale. The rationale for a decision — the constraints, the rejected alternatives, the stakeholder context — is almost always preserved somewhere when the decision is made, and almost always missing when it becomes relevant again. This is not a discipline failure. It is a structural failure: prose that lives outside the artifact cannot be guaranteed to travel with it.

Rune's answer is to make intent a first-class construct in the binding layer. ? is not a comment. It is a named, addressable, runtime-queryable field that lives in the same commit as the code it governs. A Rune-annotated codebase is one where every binding carries its own rationale, structurally, without discipline overhead.

Wake's answer is to make causal history a first-class construct in the context layer. A context saved with causedBy is not a note. It is a node in a graph — traversable, queryable, scoreable. The reasoning chain is preserved as structure, not as prose in a Slack thread that predates the current team.

The mechanisms differ because the gaps differ. The synchrony gap exists inside a file, in the present moment, at the level of a binding. Rune operates there — at the level of a property, a method, an attribute. The temporal gap exists between sessions, across time, at the level of a decision. Wake operates there — at the level of a project, a causal chain, a memory tier.

Same invariant. Different surface. Different resolution.

Why the Ecosystem Circles This

These two gaps — synchrony and time — show up in every part of the ecosystem, and every tool in the ecosystem is, in some form, an answer to one of them.

EMBER defines a semantic vocabulary for legacy modernisation: INTENT, DIMENSION, THRESHOLD, SIGNAL. It is a language designed for the third reader — AI — and its entire premise is that meaning must be declared in structure, not inferred from code archaeology. That is the synchrony gap, applied to a legacy codebase.

RECALL treats authorship as a compile-time constraint. CREATED-BY accepts exactly three values: Human, AI compositor, or AI agent. The source doesn't just remember what was written — it remembers who, structurally, in a form that travels with every artifact the pipeline produces. That is the temporal gap, applied to institutional memory.

Phoenix and Strata are methodologies that compile to deterministic runtimes. The premise is that a rigorous enough methodology can replace prose documentation with executable structure — the kind of structure that remains correct without requiring maintenance discipline. Both gaps, applied to the largest-scale version of the problem: a legacy system that no longer has anyone who understands it.

The pattern underneath all of it: meaning is being moved across a boundary — between human and AI, between sessions, between teams, between eras of a codebase. Each tool is a different answer to the question of how meaning survives that crossing. Rune and Wake make the two primary axes of that question explicit.

Rune and Wake Are Not Two Answers

The feeling of building two separate things at once was right in one sense and wrong in another.

They are separate in every technical dimension: a protocol specification vs. an MCP server, a binding layer vs. a context store, a synchronous concern vs. an asynchronous one. The implementation details share nothing.

But they are the same problem. Semantic continuity — the property that meaning survives the gap — is what both tools are trying to guarantee. Rune guarantees it for the synchrony gap. Wake guarantees it for the temporal gap. Neither guarantee holds without the other. A codebase where AI reads declarations perfectly but loses the reasoning between sessions is still a codebase where intent decays. A codebase with perfect temporal memory but no structural declaration is still a codebase where AI reconstructs rather than reads.

There is a framing that makes this concrete. In AI-assisted development, there are exactly two moments when meaning can dissolve:

One protocol. One server. Two gaps. The same answer applied twice, to the two places where intent gets lost.

Rune Protocol is at rune.semanticintent.dev — specification, reference implementations in C#, TypeScript, React, and SQL. Wake Intelligence is at wake.semanticintent.dev — 5-layer temporal brain, 231 tests, deployed on Cloudflare Workers.