semlith
One index · every AI agent · a record of what each read

Semlith

One index of everything your organisation knows — every repository, page, ticket and drive — which every AI agent can reach, with a record of what each one read.

Install free — the binarySemlith Cloud plans →

Every agent asks the same index — and gets facts, not guesses.

On your laptop, in a cloud session, in a CI job. Each answer states the commit it was read at.

It reads GitHub, GitLab, Confluence, Jira, Google Drive, OneDrive, SharePoint, Your folders, Uploads.

01 — The problem

Every agent starts from zero, inside one repository.

Your agents run everywhere now — a terminal, an editor, a cloud session, a CI job. Each one sees a sliver of what your team knows.

BROKEN · REACH
Cloud agents can't see your context.
A cloud session is sandboxed to one repository, with no local tools. Whatever your laptop knows isn't there.
cloud session✕ one repo only
CI job✕ no index
second laptop✕ index again
BROKEN · BREADTH
Nobody holds the whole organisation.
The caller lives in another repository. The spec is in Confluence, the decision in a Jira ticket, the diagram in a PDF on a drive.
acme/apiacme/webConfluenceJiraGoogle DriveSharePoint
SEMLITH
One index. Every agent.
Every repository and document, indexed once and kept fresh — answering every agent, on every machine, over one MCP URL.
1 URL
for every client — 12 tested
02 — Reach

One index. Every agent. Every machine.

Run it on your machine for free, or let Semlith Cloud hold the index so cloud sessions and CI can reach it too. Same tools, same answers — pick where it lives:

  • In your terminal
    Claude Code · Codex · OpenCode · Gemini CLI · Copilot CLI
    reaches itneeds Cloud
  • In your editor
    Cursor · Copilot in VS Code · Zed · Cline
    reaches itneeds Cloud
  • On your desktop
    Claude Desktop · ChatGPT desktop
    reaches itneeds Cloud
  • In a cloud session
    Agents running on the web, sandboxed to one repository
    reaches itneeds Cloud
  • In CI and routines
    Org tokens are machine identities — free, never a seat
    reaches itneeds Cloud
  • On your other machines
    Index once; every laptop asks the same store
    reaches itneeds Cloud
MCP URL · one for every client
https://cloud.semlith.com/acme/mcp
claude mcp add --transport http semlith \
  https://cloud.semlith.com/acme/mcp \
  --header "Authorization: Bearer sml_live_k9f2…"
One hosted copy of your index. Tokens are shown once and scoped to the stores you allow. Queries are never metered.
03 — Breadth

The answer is wherever it is. Semlith finds it there.

Every repository, page, ticket and file you pick goes into one index…

…and each piece lands on a map by what it's about — not where it's stored.

The question lands beside its answers: the code, the Confluence page, the Jira ticket, the PDF on a drive. (Exact names still work: it checks the words and the meaning, then combines both.)

04 — Proof

Facts from the graph. Never a model's guess.

Semlith maps which piece calls which — across repositories. So an agent can ask what uses this? and what would this change reach? There is no generative model in the retrieval path, so the index cannot make anything up.

Extracted — the file says so
Resolved — one definition matches
Ambiguous — it says how many
Inferred — matched by name only
Hover a piece →
Watch it light up everything it touches, across repositories.
05 — Impact check

Know what a pull request reaches.

On every pull request, Semlith posts one status check and one comment: what changed, which callers it reaches — even in another repository — and what it leaves dangling. No model reads the diff. Every finding is a graph fact with a file:line.

When there are findings, conclude
One caller sits in another repository. Neutral asks for a look; it never blocks a merge.
semlith/impact—neutral4 findings, 1 across repositories
semlith commented on acme/api #412 · Add order splitting
semlith impact · acme/api #412 · 3f9a2c1 · indexed 41 s behind HEAD
Changed · 3 symbols
create_order(cart) → create_order(cart, split)src/orders.rs:142
total(order) (body only)src/orders.rs:201
struct SplitPolicy (new)src/orders.rs:118
Reaches · callers not in this PR
handle_checkoutacme/web › src/checkout.ts:88resolvedanother repository
retry_ordersrc/jobs.rs:57resolved
test_create_ordertests/orders.rs:19resolved
Left dangling
none
No caller yet
SplitPolicy::default :130
Related documents · name a touched symbol
acme/docs › specs/orders.md §3.2resolved
acme/docs › adr/0007-split-shipments.pdf p.2inferred
Semlith posts facts from the index, never an opinion about the change.
On every Semlith Cloud plan, for GitHub pull requests, through the GitHub App. The comment can be turned off; the check stays. See plans →
06 — The ledger

A record of what every agent read.

Every retrieval — from a laptop, a cloud session, or an impact check — is a row, and each row is chained to the one before it. Change one, and the chain visibly breaks. Click a row to try.

✓ All 6 rows check out. Each one carries a fingerprint of the row before it.
Query text stays yours
The binary keeps what was asked on your machine. Nothing synced to Cloud carries it, and Cloud's own ledger keeps it off unless your organisation turns it on.
Per agent, per repository
See which client read what, and how much it saved over reading whole files.
Free on your machine
Recording is in the binary. Cloud keeps 30 days and exports CSV or JSON; Enterprise streams it to your SIEM.

07 — Always up to date

You save. Or push.

Fix a bug, merge a pull request, edit a spec, drop in a PDF.

Semlith notices.

On your machine it watches quietly — under a second of work per idle minute. In the cloud, a GitHub push re-indexes; GitLab, pages, tickets and drives are checked about once a minute.

It re-reads only what changed.

One file changed? One file re-read — vectors and graph edges together. Everything else stays where it was.

Ready to be found.

Under five seconds from save to searchable on your machine. In the cloud, every source states the commit it was read at, and how far behind it is.

<5s
08 — Private by construction

The binary never sends anything. Cloud is your choice.

The free binary
  • No account. Nothing to sign in to.
  • Loopback only. It listens on 127.0.0.1 — a door that only opens from the inside.
  • --airgap refuses every outbound request before a socket opens: model, upgrade, prices, cloud. Without it, the only fetches are model weights and acceleration packs on first use, each pinned by digest, and what you ask for.
  • Credential files stay out. Credential files (.env, keys, ~/.ssh) are never indexed unless you pass --include-secrets. A file whose contents look like a secret waits for your decision.
Semlith Cloud, if you choose it
  • Read only. It never pushes, edits or deletes. The one write is the impact check, where you allow it.
  • Only what you pick. Connector tokens encrypted at rest; org tokens kept only as a hash. Stores never cross organisations.
  • No model is trained on it. No third-party AI service ever sees your content.
  • Your store is yours. It downloads and opens in the free binary, offline.
What the cloud reads and keeps →
check it yourself:sudo tcpdump -i any -n 'not host 127.0.0.1'
09 — Documents, too

Agents make up quotes from files they can't read.

Grep can't open a slide deck or a spreadsheet. Semlith reads 13 document formats — and pictures, by what they show — so the agent quotes the real passage. Measured on 127 questions over 11 formats:

PASSAGE FOUND
98%
with semlith, against 63% with grep, glob and read.
WITHOUT SEMLITH
41 of 127
top quotes were made up — not in the document they named.
AND CHEAPER
$0.043
per session with semlith, against $0.067 without. More accurate and cheaper at once.
  • PDF
  • Word
  • PowerPoint
  • Excel
  • OpenDocument
  • EPUB
  • RTF
  • Email (EML, MBOX)
  • HTML
  • Notebooks
  • Markdown & text
  • Images, by what they show
  • Code, 46 languages

An Opus agent on 53 public documents. It chose semlith on its own in 127 of 127 sessions.

10 — Measured

Every number says what it was measured against.

RIGHT CODE, WITHIN 4K TOKENS
78%
against 48% for BM25 over ripgrep — first hit in 237 tokens instead of 529.
727 questions over 70 repositories, each searched within its own repository. 507-question dev split; on 220 held-out questions, 75% against 51%.
84%
of two-part questions
against 47% for rg · multi-hop
0.88
recall on "who calls this?"
graph tools, against 0.71 for rg
879k
chunks across 70 repositories
concept search p95 under a second
<5 s
from save to searchable
on your machine, with watch running
230/s
chunks indexed per second
Apple M1 Neural Engine, on a laptop
46 · 13
languages · document formats
plus 5 image types
12
AI assistants tested
terminal, editor and desktop clients
3,982
tokens read per question
against 105,132 opening whole files, on semlith's own repository, an upper bound
WHERE IT PAYS OFF
On one small repository, a strong agent with grep does fine on its own. Semlith earns its place on wide and unfamiliar codebases, many repositories, "who calls this?", and documents. Every public benchmark, win or lose →

Index once.Every agent asks.Every read on record.

SEMLITH · RECEIPT
your visit, written down
visitoryou
readthis page
time here0 s
sections seen1 / 12
bytes sent anywhere0
chain-------- ✓
thanks for reading
One line to get it
No account. Nothing to sign up for.
$ curl --proto '=https' --tlsv1.2 -fsSL https://raw.githubusercontent.com/semlith/semlith/main/install.sh | sh
macOS (Apple silicon) · Linux (x86_64, ARM) · Windows (x86_64) — then it sets itself up for the AI tools you use.
Terminal
Claude Code · OpenAI Codex · OpenCode · IO CLI · GitHub Copilot CLI · Gemini CLI
Editors
GitHub Copilot in VS Code · Cursor · Zed · Cline
Desktop apps
Claude Desktop · ChatGPT desktop (the Codex app)

Semlith Cloud, the optional hosted index for teams, reads GitHub, GitLab, Confluence, Jira, Google Drive, OneDrive, SharePoint and uploads, read only. What it reads and keeps

github.com/semlith/semlith
open source · Apache-2.0built in Rustno network at question time