Context Compiler

Inspiration

I built Context Compiler out of frustration with LLMs drifting away from instructions, constraints, and conversational state that had already been established. That pushed me back toward an older symbolic AI idea: working sets. Instead of hoping important context stays latent inside model text, I wanted a way to keep the relevant state explicit, structured, and controlled by the application.

What it does

Context Compiler is a host-side authority layer for LLM applications. It keeps authoritative state, policy, and execution boundaries outside the model, while still letting the model do what it is good at: interpretation and generation. It provides canonical directives, deterministic validation, explicit decision outcomes, and integration points where applications can enforce behavior rather than relying on prompt text alone.

How I built it

I built it as a layered system. The core engine owns canonical directives, authoritative state, validation, and deterministic state transitions. A separate directive-drafting layer handles non-canonical human input, interpretation, and proposal workflows. I also built example integrations to show how the pattern applies at real enforcement points in AI stacks, including gateway, UI, and application-level integrations. For some porting work, I also used Codex together with conformance harnesses to help accelerate implementation while keeping observable behavior aligned.

Challenges we ran into

One challenge was separating what belongs in the core from what belongs in the acquisition layer. It is very tempting to let the core "help" by repairing intent, but that blurs the authority boundary and makes behavior less predictable. Another challenge was presenting the project clearly, because it can easily be mistaken for prompt engineering, memory, or guardrails when the real point is control over state and execution boundaries.

Accomplishments that we're proud of

I’m proud that the project developed into a real architectural pattern rather than just a prompt technique. The core has a clear boundary around canonical directives and deterministic behavior, the drafting layer is intentionally separate, and the example integrations show that the approach can plug into real LLM application stacks. I’m also proud that the project is oriented toward something usable, not just something demonstrable.

What we learned

One of the biggest lessons was that generation and governance are different computational roles, and LLM applications get into trouble when both are represented only as text. We also learned that keeping authority outside the model leads to clearer system behavior, clearer failure modes, and cleaner integration points. Just as importantly, we learned that communicating this idea requires concrete demos, because the architecture is easier to understand through enforcement behavior than through abstractions alone.

What's next for Context Compiler

Next, I want to keep refining the boundary between the core authority engine, the drafting layer, and the example integrations. That includes continuing to simplify the core around canonical semantics, clarifying where checkpointing and session patterns fit, and expanding the set of reference integrations that show how Context Compiler can be used as a practical control layer in real LLM systems.## Inspiration

Built With

• chatgpt
• chromadb
• codex
• litellm
• mcp
• olllama
• openwebui
• python
• typescript
• vercel-ai