Product
Everything worth knowing, in one place your agents can actually cite
Five groups of capability, all of them built and running. What is still ahead says so in its own words rather than hiding in a feature list.
Pull it in
A connector turns what somebody already wrote into a resource — and never loses track of where it came from.
Connectors, not scrapers
GitHub today; Jira, Slack, Figma next
A connector reads the conversation layer at a source — GitHub issues, pull requests and their review threads, docs, releases — and records each item as a resource at a path in your knowledge tree. The GitHub connector runs today. Jira and Slack are next, then Figma.
Origin travels with the resource
Which source, which author, which URL
Every resource carries its origin: the source it came from, the external id there, the URL, the author who wrote it, and when. That is what makes a citation possible later — origin is where the resource came from, provenance is where the answer came from, and the second one ends at the first.
Content is addressed by its hash
Re-recording the same thing records nothing
Appending what a path already says is a no-op, so a connector can re-sync as often as it likes without inflating the history. Chunks and embeddings are content-addressed the same way, which is what makes re-indexing cheap instead of a rebuild.
Sqlite is the system of record
One store, one replication, one restore
An append-only log of changes plus a content-addressed blob table is the truth; search, embeddings and summaries are derived indexes that can be thrown away and rebuilt. One storage engine and one replication path per instance, rather than a second durable store with its own restore to get wrong.
Keep the history
The shared context is the sequence of changes. Time travel and audit are not features on top of that — they are what it already is.
Every change is recorded
What, by whom, when, and why
Recording a resource is a change — what changed, by which author, when, and the message saying why — and every change produces a new revision. Nothing is overwritten and nothing is deleted out of the line, so the history is the same shape a month later as it was the day it was written.
Read at any revision
What did we know last Tuesday?
Time travel is just asking at an older revision, and audit is just reading the changes. Diff two revisions and you get the resources that were added, modified or removed between them — which is also, exactly, how a proposal is reviewed.
Subscriptions
Your agent reads the news, not the newspaper
A subscription remembers the last revision an author has seen; the feed is every change after that bookmark, and catching up empties it. Content never travels — only the news that it changed — so forty people's agents do not each pull the whole context every morning.
Ask it
An agent asks a question and gets an answer it can prove. That is the whole point of the store above it.
Hybrid search
Full-text and vector, fused
Full-text and vector retrieval run side by side and their rankings are fused, so an exact term still wins on an exact term and a paraphrase still finds the thread that answered it. Embedding happens in the background and never in the write path, so recording a change is never waiting on a model.
Provenance on every answer
Revision, resource, and the origin URL
An answer arrives wearing its provenance: the revision it was read at, the resource it came from, and the origin URL at the source. Click from the agent's sentence back to the issue where a human actually wrote it. Cites, not vibes.
MCP, and a REST contract under it
Connect once, serve every agent
Your instance speaks MCP, so Claude, Cursor and anything else that speaks it connect once and can search, read, diff and quote immediately. The MCP door is generated from the same OpenAPI contract the REST API is, so the two can never describe different systems.
No relevance theatre
Ranked, not scored at you
Results come back ranked, and that is all that is claimed. No confidence percentage is printed beside a hit, because a fused ranking has no calibrated score to print and a number that looks like one would be read as a promise.
Keep it honest
Curation is the product, not a policy document. What agents read from cannot be quietly rewritten by an agent.
Proposals
Approved into history, or gone entirely
Members and agents never write shared context directly — they open a proposal: proposed changes with a message saying why, waiting on a decision. An owner approves it and its changes join the history as ordinary changes on the same straight line. Rejected, it vanishes without a trace.
Permission filtering, before ranking
A pre-filter inside the query
What a person may see is enforced inside the index query, before results are ranked — never as a filter applied to results that came back. Results cannot betray what was withheld, and a hidden resource is indistinguishable from one that does not exist.
User-bound tokens, no service accounts
An agent acts as the person it serves
An agent gets a token bound to a person and sees exactly what that person sees, no more. There is no service token to hand out and no shared identity to hide behind, so attribution survives: the history always answers "who did this?"
Run it
One instance per customer. The isolation is architecture, not a query clause.
Your own container and database
No shared index, ever
Every customer runs their own container, with its own database file and its own index directory, replicated to its own storage prefix. There is no shared table with a customer column for a filter bug to leak across, and the API has no customer id in it to get wrong.
Replicated, and restored on wake
An ephemeral disk is the assumption
The database is streamed continuously to your instance's own storage prefix and restored if the disk is gone on wake. Indexes are not replicated — they are derived, and rebuilding them is cheaper than shipping them.
The web app, per plane
Browse, history, search, review
Your instance serves its own UI: browse the tree, read a resource, compare two revisions, search, and review the proposals waiting on a decision. Account pages — organisation, members, roles, invites — are served by the control plane on its own origin, so no data call ever crosses between the two.
Isolated by architecture, not by policy
Every customer runs their own container, its own database and its own storage prefix. There is no shared index with a customer column for a filter bug to leak across.
What a person may see is enforced inside the search query, before ranking — and their agent sees exactly what they see, never more.
No service accounts. An agent acts as the person it serves, with a user-bound token, so the history always answers who did something rather than which robot did.
What it deliberately does not do
No model-written facts
Nothing enters the shared context because a model inferred it from a conversation. Everything is pulled from a source with an origin, or proposed by somebody and approved by an owner.
No editing in place
There is no update path that overwrites what a resource used to say. A change appends and produces a new revision, which is why last Tuesday is still readable and audit is just reading the log.
No answers without provenance
Every result carries the revision it was read at, the resource it came from, and the origin URL. If a claim arrives without that chain, it did not come from your context.
Give your agents something worth reading
One context per team, versioned and curated, reachable by every agent you run.