claudeers.
// Frameworks & SDKs

backsight

A self-hosted Hindsight memory for Claude Code: one Go binary that installs, wires, updates and backs it up

// Frameworks & SDKs[ cli ][ api ][ web ][ claude ]#claude#frameworks◷ MIT$open-sourceupdated 5 days ago

Install with your AI

Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.

Install and set up backsight (release-binary project) into my current project.
Found on https://claudeers.com/backsight
Repo: https://github.com/Barben360/backsight
Homepage/docs: —
Detected install method: release-binary → inspect the README
Category: frameworks. Platforms: cli, api, web.
Read the repo's README for exact setup and env vars, then install it and wire it into my project.

Claudeers Health Verdict:
unknown; community-verified: false. Confirm the source before running anything.
// or install directly (release-binary)

Grab the latest release asset from GitHub.

# download a build from https://github.com/Barben360/backsight/releases
// or clone
git clone https://github.com/Barben360/backsight

// compatibility

Platformscli, api, web
Operating systems—
AI compatibilityclaude
LicenseMIT
Pricingopen-source
LanguageGo

Get your FREE $2.50 API credits to access TickAtlas financial data ↗

backsight backsight

Long-term memory for Claude Code and Codex, on a Hindsight server you run yourself.

  • What: one Go binary that installs a memory server on your machine, in Docker or natively without it (the default on Windows), wires it into Claude Code, Codex or both, and keeps it running.
  • Why: coding agents forget everything between sessions. With backsight, Claude Code and Codex remember what you decided, fixed and learned, across all your projects, and recall it when it matters. Use both, and they share one memory.
  • Cost: searching the memory is local and free. Only turning sessions into memories uses an LLM: a few cents per session, paid to the provider you choose (below).

A backsight is the surveying reading taken back on a known point before moving forward.

backsight is an independent project, not affiliated with or endorsed by Anthropic, OpenAI or Vectorize.

What it does for you

  • Remembers your sessions. When a session ends, its text is redacted and sent to your server, which extracts durable facts: decisions, fixes, conventions, pitfalls.
  • Recalls at the right moment. Each session starts with a briefing on the current project. Each prompt brings the few most relevant memories into the agent's context, and the agent searches the memory before answering factual questions. Every search runs on your machine, with no LLM call.
  • Works in Claude Code and Codex. The same memory, hooks, tools and skills in both tools: what you settle in one is recalled in the other, on one PC or across your PCs.
  • Stays yours. The server runs on your machine, on 127.0.0.1, or on another of your machines that your other PCs also use. You choose which LLM extracts the memories, and can pause or exclude anything.
  • Looks after itself. Daily encrypted backups, signed updates that roll back on failure, and backsight doctor to say what is wrong and how to fix it.

New words (bank, observation, transverse…) are in the glossary.

How it compares

Coding agents can be given a memory in several ways. Compared on 2026-11-12 from each project's own docs:

Written byFound byKept tidy byReaches the agentReadable as files
CLAUDE.md, AGENTS.md, Claude Code auto memoryYou (CLAUDE.md, AGENTS.md), or the agent when it decides to (auto memory)CLAUDE.md loaded whole; auto memory: an index loaded at start (MEMORY.md, first 200 lines), topic files read when neededYou, or the agent as it writesEvery session; auto memory is per repository and per machineYes
OKF bundles, e.g. okf-agent-memoryThe agent, during the task, through its toolsKeyword search (BM25)A validator for links and structure; human review in gitWhen the agent searches, plus a short rule file at startYes, in git
Dreaming (Claude Managed Agents)The agent, as files in a memory storeThe agent reads the filesAn offline pass you start through the API: merges, corrects against past transcriptsFiles mounted in the sessionYes
claude-memAutomatically: hooks and an LLM observerKeyword (SQLite FTS5), optional semantic (Chroma)No merging or contradiction handling documentedRecent observations at session start, search on demandNo (SQLite)
backsight, on HindsightAutomatically: the server extracts facts when a session endsBy meaning, by keyword, through linked entities and by date, then reranked and adjusted by what helped beforeContinuously: duplicates merged, contradictions kept as history, facts retired with their sourcesA briefing at session start, up to 3 memories per prompt (5 when confidently relevant, a long one shortened to a headline), search on demandNo (PostgreSQL)

What sets backsight apart: memory you never have to write, found by meaning (searching "authentication" finds the note about an "expired token"), shared across all your projects and between Claude Code and Codex, and a record of which memories helped that shapes the next recall. Its defaults come from measuring what recall brought up on real sessions.

Where it is behind:

  • It needs a server. Hindsight with PostgreSQL, in Docker or native. The file approaches need nothing but a folder.
  • It costs a few cents per session for extraction (below). File approaches only use the agent's own tokens.
  • The memory is not readable as files. You can't review it in git, and there is no export yet.
  • No trust or expiry metadata. okf-agent-memory separates human-verified knowledge from what the agent generated, gives a fact an expiry date, and ties rules to the source files they govern. backsight does none of these.
  • Old facts are not re-checked. Dreaming re-reads past transcripts to fix stale notes. backsight relies on the agent reporting a memory wrong or outdated when it sees one.

These gaps, and what backsight could take from these projects, are tracked in #325.

Which to pick:

  • A few rules for one repo that rarely change: CLAUDE.md or AGENTS.md is enough.
  • Curated project knowledge your team reviews in git: an OKF bundle.
  • Memory that builds itself from your sessions, across many projects and both agents: backsight. It doesn't replace your CLAUDE.md or AGENTS.md; it adds to them.

What your coding agent gets

Setup wires Claude Code, Codex or both (it asks when it finds Codex). For Claude Code it installs a plugin, backsight; for Codex, two plugins, backsight@backsight (the memory tools and the skills) and backsight-hooks@backsight (the hooks alone). The binary generates all three from one source, so both tools get the same things:

KindClaude CodeCodexWhat it brings
HookSessionStartSessionStartThe memory guide (read a linked issue first, answer in your language, never ask you for a key), the project's briefing, the status line. After /clear, a resume or a fork: the guide again; after a compaction: the guide, and the briefing again only if the server rewrote it. Codex runs it with your first prompt.
HookUserPromptSubmitUserPromptSubmitUp to 3 relevant memories added to the prompt, 5 when the extra ones are confidently relevant, a long one shortened to a headline Claude can open with memory_read; plus a reminder, a nudge to search, or a save prompt when one fits.
HookPreToolUse (AskUserQuestion)PreToolUse (request_user_input)The question gate: the agent searches the memory before asking you something it may already know. Codex 0.167.0 offers its question tool in Plan mode only.
HookPostToolUse (memory tools)PostToolUse (memory tools)Notes that memory was searched, for the gate and the nudge; records which memories were shown and which the agent credited.
HookPostToolUseFailure—Off by default: when a tool call fails, the pitfalls memory knows about that failure. Codex reports no failed tool call to hooks.
HookSubagentStart, SubagentStopSubagentStart, SubagentStopA short memory guide and the top of the briefing for each subagent; its final report kept as a note; the same end-of-turn check as Stop.
HookStop, SessionEndStop, SessionEndMarks the end of each reply (for the save detector); when memories were shown and the agent has not said which it used, asks it once to call memory_credit; sends the session to your server when it ends.
MCP toolmemory_searchmemory_searchSearch the memory with 1 to 4 short queries, local and free.
MCP toolmemory_readmemory_readOne memory with the facts it was built from.
MCP toolmemory_storememory_storeStore one durable fact, redacted, and see the closest memory when it is very similar.
MCP toolmemory_creditmemory_creditName the memories shown this session that informed the answer, or that the session itself confirmed, or none (returns the citation line to print), or report one wrong or outdated: it is retired, never deleted.
Skill/backsight:remember$backsight:rememberStore a fact you give it.
Skill/backsight:pause$backsight:pauseStop or resume recording, for the session or the project.
Skill/backsight:memory-retro$backsight:memory-retroEnd-of-project retrospective: decisions, pitfalls, lessons into memory (rules into CLAUDE.md or AGENTS.md), corrections for stale ones.
Skill/backsight:memory$backsight:memoryThe memory from the command line, when the MCP tools are missing or failing.
Skill/backsight:doctor$backsight:doctorDiagnose and fix backsight, and draft a bug report you confirm.
Skill/backsight:update$backsight:updateInstall a newer release from the session, once you approve its plan.
No prompt for the memory toolsA permission ruleThe tools' own declarationsThe agent calls the four memory tools without asking you each time.

Each hook's time limit and exact behaviour: how-it-works.md. In Codex, the memory server is named backsight, so its tools are mcp__backsight__memory_search and so on; you trust the hooks once in Codex's review, and its sandbox may ask you to approve a skill's backsight command. Everything that differs: docs/codex.md.

How it works

A session and the memory, step by step. The green part runs on your machines and costs nothing; only the orange part, in the background, calls your LLM provider. The server runs on this PC, or on another of your machines that your other PCs also use (install.md).

sequenceDiagram
    actor You
    participant CC as Claude Code or Codex
    participant BS as backsight
    participant HS as Hindsight server (yours)
    participant LLM as LLM provider

    rect rgba(46, 160, 67, 0.12)
    Note over CC,HS: On your machines, free
    You->>CC: open a session
    CC->>BS: SessionStart hook
    BS->>HS: read the project's briefing
    BS-->>CC: memory guide + briefing
    You->>CC: a prompt
    CC->>BS: UserPromptSubmit hook
    BS->>HS: recall (search + local reranker)
    Note over BS: reorder by what helped before (local record)
    BS-->>CC: up to 3 relevant memories (5 if confident), with short ids
    CC->>BS: memory_search, memory_read
    BS->>HS: search
    BS-->>CC: memories, to cite
    CC->>BS: a question to you, no search yet
    BS-->>CC: refused once: search the memory first
    CC->>BS: memory_store, a subagent's report
    BS->>HS: redacted fact or report
    CC->>BS: memory_credit: the memories that helped, or none
    BS-->>CC: the citation line to print
    CC->>BS: memory_credit: one proved wrong or outdated
    BS->>HS: correction note, the wrong fact retired
    CC->>BS: Stop hook, the reply ends
    opt memories shown, no memory_credit yet
    BS-->>CC: asked once which ones helped
    end
    You->>CC: end the session
    CC->>BS: SessionEnd hook
    BS->>HS: redacted session text
    Note over BS,HS: or the background job, once the last turn is 30 min old
    end

    rect rgba(219, 109, 40, 0.12)
    Note over HS,LLM: Paid, in the background
    HS->>LLM: extract facts, consolidate them
    HS->>LLM: refresh the project's briefing
    end

Background jobs keep it running (systemd user timers):

flowchart LR
    tick(["jobs tick<br/>every 15 min"]) --> t1["settle which memories<br/>helped (local)"] --> t2["start the server if down,<br/>send idle sessions and queued notes"] --> t3["pace the import<br/>of past sessions"] --> t4["purge again a document<br/>an older client rewrote"] --> t5["share what helped<br/>with your other PCs"]
    maintain(["jobs maintain<br/>daily, 04:00 to 04:30"]) --> m1["encrypted backup<br/>(on the server's host)"] --> m2["move memories<br/>to their project"] --> m3["check purged<br/>documents"] --> m3b["delete short subagent<br/>reports (once)"] --> m4["check for<br/>a new release"] --> m5["doctor snapshot"]

Every hook, threshold and time limit: how-it-works.md.

How memory learns what helps

How a memory's rank moves: over 50 shows, a memory never credited sinks, one credited one time in ten stays at zero, one always credited rises. How a memory's rank moves: over 50 shows, a memory never credited sinks, one credited one time in ten stays at zero, one always credited rises.

backsight counts, by id, the memories the agent was shown and the ones it reports using. A memory shown near the top and left unused is a confident miss: with one uncredited show in three counted as a miss, as drawn here, a memory credited one time in ten stays where the reranker put it, one credited more often rises and one credited less often sinks. Misses lose half their weight in 90 days and credits in a year, and the boost stays between −0.025 and +0.075 by default.

What it costs

backsight is free, and so is searching the memory: recall at each prompt, memory_search and backsight search run on your machine, with the server's local search models, and send nothing out. The server's LLM is not free: it reads each session to extract memories, and you pay its provider for the tokens.

ProviderPer sessionPer month (5 sessions a day, 22 days)
DeepSeek V4.1 Flash (default)$0.05, $0.10 at peak hours$5, up to $11
Claude Haiku 5.5$0.04$4
GPT-6 Luna$0.04$4
Ollama on your machinefree, but slow on a CPU and lower qualityfree
Your Claude subscriptioncounts against your plan; not recommended

How these figures are made, so you can redo them for your use:

  • A session is 30,000 characters of sent text (your prompts, the agent's replies and one line per tool call): the average of 42 real sessions of the author.
  • Tokens per session, from backsight's own estimate (the one backsight retain backfill --plan shows): about 92,000 input and 14,000 output tokens for extraction and consolidation. On top of that estimate, output is counted 2.5 times over for the model's thinking tokens, the ratio measured on the author's server, so these figures are higher than what --plan shows. Add one refresh of the project's briefing: about 96,000 input tokens on the author's average memory, up to about 130,000 on a well-filled one (how-it-works.md). A briefing is rewritten at most once every 6 hours per project, so sessions close together share one refresh.
  • Prices, per million tokens: DeepSeek V4.1 Flash $0.15 input and $0.60 output off-peak, twice that at peak hours (01:00–04:00 and 06:00–10:00 UTC on weekdays, DeepSeek pricing); Claude Haiku 5.5 $0.10 input and $0.50 output (Claude pricing); GPT-6 Luna $0.10 input and $0.50 output (OpenAI pricing). Checked on 2026-10-26 (DeepSeek), 2026-11-01 (Claude) and 2026-11-07 (OpenAI). Cached input, which is cheaper, is counted at the full price. backsight's own estimates and cap go further for Claude and OpenAI models: input not read from the cache counts at the cache-write price, 1.25 times the input price, so they never under-count (configuration.md).
  • In setup, the providers are deepseek (model deepseek-flash, not the Pro model), anthropic, openai, ollama and claude-code. GPT-6 Luna (gpt-6-luna) is the default model for openai.

Long sessions cost more, short ones less. Importing your past sessions (backfill) is a one-off at about the same price per session: setup shows its estimate and a spending cap before you accept. backsight stats shows the tokens actually spent, and their cost once the model's price is known (configuration.md).

Your Claude Code or Codex usage does not change, except that memories take a little of the agent's context: at most 3,000 to 4,000 tokens per session (how-it-works.md).

Before you start

You need:

  1. Linux on amd64, or Windows 11 on x86_64, without administrator rights (Windows). macOS comes later.
  2. On Linux, Docker with Compose v2, usable without sudo (Windows needs no Docker: the server runs natively):
    • install Docker Engine for your distribution: docs.docker.com/engine/install;
    • add yourself to the docker group, then log out and back in: sudo usermod -aG docker $USER (details). Members of this group have root-level access to the machine; rootless Docker avoids that and works too;
    • check: docker compose version prints a version 2, without sudo.
  3. Claude Code 2.1.309 or newer, with claude on your PATH: install Claude Code. Or Codex 0.167.0 or newer, with codex on your PATH, or both (Codex).
  4. An API key for the LLM that extracts memories, from a pay-as-you-go account (a Claude subscription is not one):
  5. About 6 GB of free disk (the server image and its models are about 2.4 GB to download), and curl, tar, and minisign or OpenSSL 3 to check the release signature; on Windows, about 3.5 GB and PowerShell.

Install

Let your coding agent install it. Paste this into Claude Code or any coding agent:

Install Backsight for me by following https://raw.githubusercontent.com/Barben360/backsight/main/docs/agent-guide.md — ask me before every choice.

The agent never sees your LLM key: you type it yourself. Or install by hand:

  1. Install the binary. The script checks the release's signature and checksum before installing anything:

    curl -fsSL https://raw.githubusercontent.com/Barben360/backsight/main/scripts/install.sh | sh
    

    If it prints an export PATH=… line, run it (or open a new login shell).

    On Windows x86_64, in PowerShell, without admin rights (the script checks the signature itself, in PowerShell; see Windows):

    powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/Barben360/backsight/main/scripts/install.ps1 | iex"
    
  2. Set it up:

    backsight setup
    

    Setup checks the machine, asks a few questions (which tools to wire, when Codex is installed; the LLM provider; how long Claude Code keeps transcripts; backups; importing past sessions; importing a folder of notes; and, with Codex, whether to turn off Codex's own memories and import them), shows its plan and asks for your consent. It then asks for your provider key at a hidden prompt: keys are never passed as arguments. The first run downloads the server: several minutes on a home connection. If setup stops, fix what it says and run backsight setup --resume; troubleshooting.md covers the usual causes.

  3. Restart Claude Code (or run /reload-plugins in it). For Codex: restart it, then trust backsight's hooks in the review it shows at start (Codex).

  4. Another PC: install the binary the same way, then backsight connect --token-file <file> with the connection token the first PC hands out (backsight server expose --private <ip> --out <file> there, then backsight server token --out <file> for each new token). Carry the file yourself, never through a chat. See several PCs.

Every detail: docs/install.md.

Check it works

  1. backsight verify runs every hook and the memory tools as Claude Code does, then stores and recalls a test memory; backsight verify --codex does the same as Codex does. Setup already ran the one for each tool it wired. No line should say fail.
  2. Start a Claude Code session in one of your projects. Its first line is 🧠 backsight · 🗂️ <project>; the very first session also shows 👋 Memory is on, with where sessions go. In Codex, these lines come with your first prompt.
  3. backsight doctor checks the whole install. Right after setup, a warning that there is no backup yet is expected: the first one runs tonight, or now with backsight backup create.
  4. Work as usual. Once your first session has ended (or sat idle for 30 minutes) and a few minutes more have passed, backsight verify --live confirms it reached the server and became memories, and backsight search "<a topic of that session>" finds them.

When the agent uses a memory, it cites it:

🧠 From memory (my-project · 0b4c2a52) — the API client retries 3 times, decided on 2026-10-12 because the gateway drops idle connections.

Coming from another tool

Memory files from another tool (LifeOS, a notes vault, an export) or your own notes can go into the memory: backsight import ~/notes --plan shows the files and the cost, then backsight import ~/notes sends them in the background within a spending cap. docs/import.md has the details and a LifeOS recipe.

Pause, turn off, uninstall

ToRunWhat stays
Stop recording this session/backsight:pause in Claude Code (/backsight:pause resume to go on), $backsight:pause in CodexRecall keeps working.
Never record a projectbacksight pause --project in its directoryRecall keeps working there.
Remove backsight from Codex onlybacksight client uninstall --codexClaude Code's wiring, your memory.
Undo setupbacksight setup --undobacksight, your config and your memory; Claude Code and Codex are as before.
Remove backsightbacksight uninstallYour memory server and backups.
Remove everythingbacksight uninstall --delete-data --purge-localYour backups, and the Docker images (uninstall.md).

Example

Monday, in a session on your billing project:

> The invoices job times out against the new gateway. Let's raise the client timeout to 60 s and retry twice.

The session ends; backsight sends it to your server, which extracts the decision. On Thursday, in a new session:

> Why does the invoices job take so long on failures?

backsight adds the memory to your prompt, and the agent answers with it:

🧠 From memory (billing · 7d1e93a0) — the invoices client timeout was raised to 60 s with 2 retries on 2026-10-12, because the new gateway is slow to answer.

A failing call can take up to 3 minutes: 60 s for each of the 3 attempts.

Privacy

  • The server runs locally, on loopback, with its API and web UI behind keys, unless you open it to your other PCs on a private address (backsight server expose --private; a tailnet address keeps the API key encrypted, a LAN carries it in clear). Recall and searches never leave your machines. Whoever runs the host reads every PC's memories: see several PCs and privacy.md.
  • Session text goes to the LLM provider you chose, under that provider's terms. With Ollama, it stays on the machine.
  • The server downloads its two search models from Hugging Face on its first start, and Docker pulls its images; no memory text goes with them.
  • Secrets are redacted before anything is stored, facts that look like secrets are refused, and the agent is told never to ask you for a key in the conversation.
  • /backsight:pause ($backsight:pause in Codex) stops recording a session; backsight pause --project or a .backsight.toml with retain = false excludes a project.
  • Backups are always encrypted.
  • No telemetry, no automatic reports. The binary's only other connection is a daily check for new releases on GitHub.

Details, with each provider's terms and where it keeps data: docs/privacy.md.

Daily use

You mostly use Claude Code or Codex as before. Commands you may need:

CommandUse
backsight doctorCheck everything, with a fix for each problem (in the session: /backsight:doctor or $backsight:doctor, which can also file a bug).
backsight search "<keywords>"Search the memory yourself (local, free).
backsight store --kind decision "<fact>"Store a fact (in the session: /backsight:remember or $backsight:remember).
backsight forget <id>Retire a wrong memory.
backsight pause / backsight resumeStop or restart recording (in the session: /backsight:pause or $backsight:pause).
backsight statsSee how memory was used this week, and what it cost (--client codex for one tool).
backsight update applyInstall a newer release, after checking its signature; you are told when one is out.

The dashboard

backsight dashboard serves a local page and prints a one-time link to it (--open opens it in your browser). The page answers "is my memory working?" with the numbers backsight stats prints, in the light or dark theme. docs/dashboard.md explains each page and each number.

The dashboard's Overview: the verdict, the summary line and six tiles The dashboard's Overview: the verdict, the summary line and six tiles

Documentation

backsight guide browses these docs in the terminal, and backsight guide search "<question>" searches them.

PageWhat is in it
installRequirements, setup questions, secrets, where files go.
Windowsbacksight on Windows without administrator rights: install, the server's scheduled task and supervisor, updates, troubleshooting.
native runtimeThe server without Docker: what it is, what it lacks, how to switch.
daily useSessions, projects, skills, searching, storing, forgetting.
Codexbacksight in Codex: install, trusting the hooks, approvals, the sandbox, Codex's own memories, what differs from Claude Code.
importImporting a folder of notes or another tool's memory files, with a LifeOS recipe.
GPU rerankerFaster recall with your NVIDIA, AMD or Intel GPU: what to install, the service to add, how to check and undo it.
how it worksRecall, the question gate, the save detector, latency and context cost, the hooks.
configurationEvery config.toml key.
several PCsOne memory shared by your PCs: the host, joining, offline laptops, a lost laptop.
privacyWhat is stored, what leaves the machine, each provider's terms.
commandsEvery command and flag.
backups and restore, update, uninstallKeeping the install safe and current.
troubleshootingWhen setup or memory stops working.
dashboardThe dashboard's pages and every number on them.
compatibilitySupported versions, and the Hindsight version each release pins.
agent guideThe install steps for a coding agent.
glossaryThe words these docs use.

Status

backsight is stable from v1.0.0: a one-person project, used daily by its author. Linux is the main tested platform. Windows 11 x86_64 is new: CI runs its tests and a full native install, store, backup, restore and uninstall on every pull request that changes more than documentation. Codex support is new in v1.2.0: CI drives a real Codex through setup, hook trust, a session, recall, credit, update and uninstall against a scripted model on every such pull request, and a test bench shares one memory between Claude Code on one PC and Codex on another; daily use with a real model is still young. Each release pins one Hindsight version, listed in docs/compatibility.md.

Found a problem? Ask your agent: /backsight:doctor in Claude Code, $backsight:doctor in Codex. It diagnoses, fixes with your OK, and drafts the issue it files only once you confirm. Or run backsight report yourself: it prints a redacted diagnostic and a link to file a GitHub issue, and sends nothing itself. For a security problem, see SECURITY.md.

Contributing: CONTRIBUTING.md.

Third-party components

backsight does not ship these: Docker pulls the images from their publishers, and the server downloads the models from Hugging Face. They come under their own licences and terms, which you accept by installing them: check them against your use, at work in particular.

ComponentLicenceNotes
Hindsight server image, by VectorizeMITThe memory server.
pgvector image (PostgreSQL with pgvector)PostgreSQL LicenseThe server's database.
multilingual-e5-small, the embedding modelMITDownloaded at the server's first start.
mmarco-mMiniLMv2-L12-H384-v1, the rerankerApache-2.0Downloaded at the server's first start. It was trained on mMARCO, a translation of MS MARCO, whose terms say the data is "intended for non-commercial research purposes only". Whether those terms reach a model trained on it is unsettled; Hindsight's own default reranker has the same origin. If it matters for your use, run another reranker (troubleshooting.md shows how).
Qwen3 8B, only with the ollama providerApache-2.0You pull it with Ollama.
The native runtime's downloads: uv, Python, Hindsight and its Python packages, PostgreSQL with pgvector by pg0, and on Windows the Microsoft Visual C++ runtime DLLsEach its ownDownloaded when a native server is installed. Their licences and where to read them: native-runtime.md, windows.md.
Go modules compiled into the binaryMIT, BSD-3-Clause, Apache-2.0Listed in go.mod. Their license texts and notices, with the Go standard library's, ship as THIRD_PARTY_LICENSES in every release archive and print with backsight version --licenses.

Your LLM provider's terms apply to what the server sends it: privacy.md.

License

MIT, see LICENSE.

// faq

What is backsight?

A self-hosted Hindsight memory for Claude Code: one Go binary that installs, wires, updates and backs it up. It is open-source on GitHub.

Is backsight free to use?

backsight is open-source under the MIT license, so it is free to use.

What category does backsight belong to?

backsight is listed under frameworks in the Claudeers registry of Claude-compatible tools.

7 views
★ 10 stars
unclaimed
updated 5 days ago

// embed badge

backsight on Claudeers
[![Claudeers](https://claudeers.com/api/badge/backsight.svg)](https://claudeers.com/backsight)

// retro hit counter

backsight hit counter
[![Hits](https://claudeers.com/api/counter/backsight.svg)](https://claudeers.com/backsight)

// reviews

// guestbook

0/500

// related in Frameworks & SDKs

🔓

An open-source AI coding agent that lives in your terminal.

// frameworksQwenLM/⟨TypeScript⟩★ 30,647◷ Apache-2.0[ claude ]
🔓

Claude Code 泄露源码 - 本地可运行版本,新增跨平台桌面端软件补齐Computer Use(附带核心模块解析)

// frameworksNanmiCoder/⟨TypeScript⟩★ 15,320◷ NOASSERTION[ claude ]
🔓

LangGPT: Empowering everyone to become a prompt expert! 🚀 📌 结构化提示词(Structured Prompt)提出者 📌 元提示词(Meta-Prompt)发起者 📌 最流行的提示词落地范式 | Language of GPT The p…

// frameworkslanggptai/⟨Jupyter Notebook⟩★ 12,706◷ Apache-2.0[ claude ]
🔓

Omnigent is an open-source AI agent framework and meta-harness: orchestrate Claude Code, Codex, Cursor, Pi, and custom agents — swap harnesses without rewrit…

// frameworksomnigent-ai/⟨Python⟩★ 11,291◷ Apache-2.0[ claude ]
→ see how backsight connects across the ecosystem