Commonplace

The problem

I built Commonplace to explore the product problem long-context AI creates: when a model can reason over far more information than a person can inspect at once, how do users understand, steer, and trust what it is using? Most LLM products treat context as invisible plumbing — retrieval happens, chunks get stuffed into the prompt, and the state evaporates between turns. The user never learns what the model was looking at, so they can't correct it when it looks at the wrong thing.

Commonplace inverts that. It's a long-context workspace where the model's active working set is visible, persistent, steerable, and grounded: you can watch what the model holds, pin what matters, see every load and eviction explained, and click any claim through to the exact source passage that was in memory when the sentence was written.

Why it matters

As context windows grow, "the model saw everything" stops being an answer. Users need to know what influenced a response, preserve important context across long-running work, and intervene without becoming prompt engineers. Commonplace turns those invisible systems decisions into an understandable product surface. Working memory here is an honest simulation of assembled prompt context on today's models — a design prototype for the long-context world, built truthfully on the current one.

Three moments that carry the thesis

• Ask a cross-source question. Two concept cards hydrate into working memory as the response streams — you see the model's context assemble in real time, narrated in plain language.
• Click a citation. Every claim carries a provenance chip linking to the exact source passage available to the model at answer time — not a post-hoc search, but what was actually in memory.
• Pin a memory item. Create context pressure and the system makes an explainable compression decision: pins are inviolable, evictions are narrated, and the retrieval fallback says so out loud when no concept card covers a question.

The engineering underneath

• Durable ingestion. A 1.75M-word corpus runs through a Temporal workflow with idempotent steps — the pipeline survives worker restarts without duplicate work, and I tested that failure mode rather than assuming it. Full ingest cost: $0.19.
• Explicit model routing. Concept-card hydration when coverage exists, pgvector similarity fallback when it doesn't — and the op feed labels which path answered. Prompt budgets are enforced, not vibes.
• Evaluation as a habit. Faithfulness, retrieval, and routing each have eval files; running them surfaced live failures that got fixed before they became demo surprises.
• It generalizes. The same product runs on Swift Evolution proposals by swapping only the domain pack — no app-logic changes. The philosophy corpus is the demo medium, not the thesis.

Outcome

A working single-user prototype, live on Vercel, that makes a concrete argument: context isn't invisible infrastructure — it's a user-facing control surface. The same thinking applies directly to coding agents: helping users understand what repository context an agent has, what it changed, and when to trust or intervene.