NeuroRouter Is a Context Compiler

April 2026 · Obsta Labs

The next useful layer for coding agents is not bigger chat memory. It is a compiler between the messy work transcript and the next model call.

Claude and Codex are already useful. The failure is usually around them: stale reads beside current files, rejected approaches beside chosen ones, old tool output beside the active objective, and a client that resends the whole pile because the API is stateless.

NeuroRouter treats that pile as source code. It compiles it before the request reaches the model.

source transcript
  → semantic field
  → optimized working set
  → target model context
  → proof of continuity

The transcript is not the work

A long session contains decisions, constraints, rejected approaches, quantities, current state, file paths, failures, and unresolved blockers. It also contains dead scaffolding: old searches, duplicate summaries, failed retries, stale file reads, and narration that no longer constrains the next step.

Verbatim retention treats both classes as equal. A context compiler does not. It asks which pieces still carry the work.

The semantic field

The semantic field is the load-bearing shape of the task: what we are doing, which path we chose, what must not be broken, what was rejected, what files and repos are in scope, what changed, and what is still blocked.

Human language already does this kind of compression. Some writing systems can omit short vowels and still preserve roots. In conversation, people drop adjectives, filler, and repeated nouns while keeping boundaries, negation, quantities, and causality. The message still lands because the structural field survived.

Agent context needs the same discipline. Preserve the root of the decision, the start and end of the work, the negations, the quantities, and the causal links. Drop transcript drag.

Compilation, not summarization

Summarization asks a model to rewrite the past. That can be useful, but it is not a safety boundary. A context compiler uses deterministic structure: source transcript in, field contract out, optimized request emitted for the target client.

Claude and Codex do not need identical payloads. Claude benefits from useful degraded continuity when a million-token session is still valuable but no longer perfectly healthy. Codex benefits from loop and rescue signals when it starts rereading the same files instead of editing, testing, or refreshing the objective.

The target is not a smaller prompt for its own sake. The target is a request that still reaches the same decision vector at lower cost and with fewer stale distractions.

Proof of continuity

A compiler needs tests. NeuroRouter reports whether decisions, constraints, rejected approaches, workspace identity, objective freshness, loop health, and tool-chain structure survived the transformation.

That proof matters because smaller context can be worse. If a proxy removes text the model actually needed, the model rereads, retries, or drifts. The right metric is not bytes removed. It is whether the next request still carries the work.

Context engineering is useful only when the semantic field survives.

Where this goes

Today, NeuroRouter runs locally, protects detected secrets, shapes long Claude and Codex sessions, preserves active decisions, reports session integrity, and exports support-safe evidence when work needs rescue.

The direction is bigger than one release: context should become a compiled artifact with a target dialect, a continuity proof, and a clear boundary between private engineering traces and customer-facing evidence.

Models will keep improving. That is good. The better they become, the more valuable it is to feed them clean, current, structurally faithful context.