Part 1 was the engine: a local-first RAG index in Rust — SQLite, hybrid search, Lua connectors, served to any tool over MCP. This post is the harder question one layer up, the one the engine only makes sense as an answer to: context that stays current and shareable across a team — and whether Context Harness is really the shape of that answer, or a hammer I enjoyed building and then went looking for a nail to justify.
I want to be honest about the register here, because it's different from Part 1. That post was a retrospective — a thing I built, surveyed, and understood. This one isn't finished. Context Harness is a work in progress, and I'm still genuinely working out whether its core bet is right. So this is me reasoning in public, dogfooding a tool and watching whether it earns its place — not selling you a conclusion I don't have. Pretending otherwise would be its own kind of slop, which is funny, because slop is the thing the tool exists to fight.
The itch
Context Harness came from confabulation. AI tools are great until they start confidently inventing details about my code — a function signature that doesn't exist, a config key I never wrote, a system summarized the way it isn't. The fix is grounding: give the model the real material and it stops guessing. Cursor does this with semantic search over a repo. I wanted that, but portable, multi-repo, and pointable at any pile of my own work — and the index it builds is a database (a SQLite file, hybrid keyword-plus-vector search, served to any tool over MCP). That's the engine I described in Part 1.
I'm already in the format camp
Before I defend the engine, I should admit which side I've actually lived on. The loudest current answer to "how do you give AI context" isn't an engine at all — it's a format: markdown with frontmatter, in a directory, that agents read directly. Google's Open Knowledge Format, Karpathy's LLM-wiki, the AGENTS.md convention, every Obsidian vault. No SDK, no runtime, no index — the format is the contribution, and a long-context model just reads the files.
I'm not skeptical of this from the outside. I've kept markdown knowledge vaults for years — personal and professional — since before "LLM wiki" was a phrase. For one person, or a couple of people who trust each other's notes, it is genuinely the right tool. Lightweight, portable, human-readable, version-controlled. If that's your scale, you probably don't need anything I'm building.
Where the format quietly breaks
It breaks at team scale, and I've watched it break. Past about three people, a shared markdown corpus develops the same disease every wiki has ever had: it goes stale, nobody owns curating it, and it grows into an overwhelming pile of text that no one trusts is current. The format assumes someone keeps the files good. At small scale that someone exists. On a large engineering team riddled with silos, they don't — and "just read the folder" turns into "read a thousand documents, half of them six months out of date, and hope."
This isn't a niche complaint. Portable, shareable, current team context is, as far as I can tell, an unsolved problem — even well-resourced internal tooling at large companies hasn't really cracked it. That part I'm confident about. It's the part I'm less sure about that this whole post is circling.
The bet I'm dogfooding
Context Harness's bet is that the thing markdown can't be — at team scale — is exactly what a context engine can: a shared store that stays current (it re-syncs from the sources instead of waiting for a human to update prose), is shareable (the index is an artifact a team can pull, not a vault each person curates alone), and possesses skills rather than being inert text — the Lua connectors, tools, and agents that let it ingest weird sources and act on what it finds. A worthy context tool, the way I think about it, is a current, shareable thing that does things — not an overwhelming corpus that rots.
Two honest clarifications, because they matter and they cut against my own earlier framing:
- "Local-first" is mostly a cover story. Under the hood the design is configuration-driven, with multiple backends — local is one configuration, not a religion — and yes, there's a paid tier in the back of my mind. That flexibility is precisely what could make it team-shareable; a purist local-only tool couldn't be.
- Search is a component, not the point. A serious context tool needs good retrieval, sure. But "search the blog" and "keep a team's context fresh and shareable" only overlap at the word search. The first is a commodity; the second is the actual problem. I spent a whole post in another series untangling the same search-versus-state conflation, and I don't want to repeat it here.
The browser-RAG tangent (still half-baked)
There's a tempting offshoot I haven't resolved: ctx export already dumps the index to JSON, and you could pair that with on-device embeddings (Transformers.js with the same small all-MiniLM-L6-v2 model the engine can embed with locally) and a vector index (sqlite-vec runs in WASM) to do retrieval entirely in a browser tab. For a forty-post blog it's a 25MB model aimed at a mosquito. For the multi-repo workspace the engine was built for, maybe not. I file it under "experiments I want to run," not "roadmap."
What I'm actually doing about it
Dogfooding, mostly — which is the only honest way to find out if the bet holds. I run Context Harness against my own vaults and my own multi-repo work, and I watch for the moment it either earns its keep or doesn't: does a freshly-synced, shareable, skill-bearing index actually beat "just keep good markdown," once the corpus is too big and too shared for any one person to keep good? I don't have that answer yet. Some days the format camp looks obviously right and the engine looks like a hammer I built because hammers are fun. Other days I hit exactly the staleness-at-scale wall the engine is meant for, and it feels like the only thing that could work.
The meta-loop is the honest ending, and I'll leave it unresolved on purpose: I built a tool to fight AI slop by grounding models in real context, I'm using a model to reason about whether that tool is even the right shape, and the answer is genuinely I'm still finding out. Naming that uncertainty — instead of papering over it with a confident conclusion — is the same discipline the tool is supposed to enforce on the models. So that's where Context Harness is: a hammer still looking for its nail, being swung in public until I know whether the nail is real.
— Parker Jones