tether-memory 0.1.0__tar.gz

tether_memory-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    name: ${{ matrix.os }} / py${{ matrix.python }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python: ["3.10", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Install package + dev deps
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -v

tether_memory-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,29 @@
+name: Release
+
+# Publish to PyPI when a version tag is pushed (e.g. v0.1.0).
+# Uses PyPI Trusted Publishing (OIDC) — no API tokens stored anywhere.
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  pypi-publish:
+    runs-on: ubuntu-latest
+    environment: pypi          # configure this name in the PyPI trusted publisher
+    permissions:
+      contents: read           # required for actions/checkout (private repo)
+      id-token: write          # required for OIDC trusted publishing
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist + wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

tether_memory-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+
+# tether local data / secrets
+*.db
+*.db-*
+.env
+
+# OS / editor
+.DS_Store
+.idea/
+.vscode/

tether_memory-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sidyellur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tether_memory-0.1.0/NOTES-FOR-BLOG.md

@@ -0,0 +1,25 @@
+# tether v0.1 — Blog Journal
+
+## The core insight: memory as a shared substrate
+
+The problem tether solves: personal agents will live across devices (laptop, desktop, phone). For that to feel like *one* assistant, not several amnesiac ones, memory has to be a substrate that follows you — readable and writable from every device and any agent, not siloed in a single tool. This isn't about perfect sync or guarantees; it's about being a *convenience layer* that helps when present and never breaks the agent when degraded.
+
+## Design choice: local-first + opt-in sync
+
+We chose to ship a local SQLite file as the default — zero config, no accounts, no network. The alternative (Turso/libSQL primary with local replicas) only works if sync is reliable. By making it opt-in, we sidestep the vendor risk and deployment complexity. Agents that don't need cross-device memory use it as-is. Agents that do can point at a Turso primary and get an embedded replica. The same code path handles both.
+
+## Real-world spike: .sync() doesn't fail fast
+
+During Task 7, we discovered libsql-experimental's `.sync()` doesn't fail fast on unreachable backends — it retries the handshake internally (observed every ~2-3s) without returning control. The plan assumed we could call `conn.sync()` inline as an initial connectivity probe. We corrected this by bounding the initial sync in a background thread + timeout, the same pattern we already use for later syncs. This change is subtle but critical: it keeps server startup from hanging indefinitely on a dead network.
+
+## The upsert-on-write design
+
+The store deduplicates on write, not on read. A memory with the same `type` + normalized `title` updates in place. This was a deliberate choice: agents shouldn't need to know "is this fact new or existing?" before calling remember. Re-remembering a fact refines it. The cost is a dedup index on (type, title_norm), but the benefit is that the store doesn't rot into a heap of near-duplicates.
+
+## Four verbs, nothing more
+
+We resisted the urge to add `list`, `get`, or raw SQL. The four verbs (remember, recall, link, forget) are the minimum surface needed for an agent to use memory. A fifth verb (the boot-index resource) is auto-loaded each session, so agents don't need to think about it. This minimalism makes the tool usable across contexts and easy to reason about.
+
+## Deferred, not dropped
+
+The spec laid out three things we didn't build: semantic search (embeddings), entity/edge graph model, and automatic corrupt-DB recovery. We designed the schema so all three slot in without data migration. The important part: we called out what's deferred in the docs, not silently dropped it. v0.1 works; v0.2's roadmap is visible.

tether_memory-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: tether-memory
+Version: 0.1.0
+Summary: A shared memory layer for personal agents, across devices: an MCP server over local SQLite with opt-in libSQL/Turso sync.
+Project-URL: Homepage, https://github.com/sidyellur/tether
+Project-URL: Issues, https://github.com/sidyellur/tether/issues
+Author-email: sidyellur <20009719+sidyellur@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2026 sidyellur
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: agent,claude,claude-code,libsql,mcp,memory,sqlite,turso
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Provides-Extra: sync
+Requires-Dist: libsql-experimental>=0.0.30; extra == 'sync'
+Description-Content-Type: text/markdown
+
+# tether
+
+**A shared memory layer for personal agents, across devices.** `tether` is an
+[MCP](https://modelcontextprotocol.io) server backed by a local SQLite file. Any
+MCP-compatible agent can `remember`, `recall`, `link`, and `forget` durable notes
+— facts about you, your projects, your preferences — so context follows you
+instead of dying with each session.
+
+It runs **local-only with zero configuration**. Point it at a hosted
+[libSQL/Turso](https://turso.tech) primary and the same file becomes an embedded
+replica that syncs your memory across every device in near-real-time.
+
+## Why
+
+The near future is personal agents living across many devices — laptop, desktop,
+phone. For that to feel like *one* assistant rather than several amnesiac ones,
+memory has to be a substrate that follows you: readable and writable from every
+device and from any agent, not siloed inside a single tool.
+
+`tether` is that substrate. It is deliberately a *convenience layer* — it makes an
+agent more useful when present, and never breaks the agent's work when degraded.
+
+## Status
+
+v0.1 is implemented. Design and rationale: [`docs/superpowers/specs/2026-07-03-tether-design.md`](docs/superpowers/specs/2026-07-03-tether-design.md). Implementation plan: [`docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md`](docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md).
+
+## Design at a glance
+
+- **Four verbs**, nothing more: `remember` · `recall` · `link` · `forget`.
+- **Upsert on write** so the store doesn't rot into near-duplicates.
+- **Rich recall** (id, type, title, body, tags, `updated_at`) so an agent can
+  judge staleness and cite what it updates.
+- **An auto-loaded boot index** — a compact one-line-per-memory list surfaced to
+  the agent each session, so memory helps even when the agent doesn't think to
+  search.
+- **Local-first, sync optional** — the local path is untouched when no backend is
+  configured; degradation never throws.
+- **Keyword search now, embeddings later** — the SQLite schema is built so
+  semantic search and a full entity/edge graph slot in without migrating data.
+
+## Install
+
+Requires Python ≥3.10 on a POSIX system (Linux/macOS).
+
+Register it with Claude Code — with [uv](https://docs.astral.sh/uv/):
+
+```sh
+claude mcp add tether -- uvx --from tether-memory tether
+```
+
+…or install it first:
+
+```sh
+pip install tether-memory
+claude mcp add tether -- tether
+```
+
+(The PyPI package is named `tether-memory` — `tether` was already reserved on
+PyPI as a common brand name — but the installed command is still `tether`.)
+
+By default memory lives in a local SQLite file at
+`~/.local/share/tether/memory.db` (override with `TETHER_DB`). No accounts, no
+network — this is the whole tool for a single machine.
+
+## Sync across devices (optional)
+
+Point tether at a [Turso](https://turso.tech) / libSQL database and the local
+file becomes an embedded replica — local-speed reads, writes that propagate to
+your other devices. Install the extra and set two env vars:
+
+```sh
+pip install 'tether-memory[sync]'
+export TETHER_SYNC_URL='libsql://<your-db>.turso.io'
+export TETHER_SYNC_TOKEN='<your-auth-token>'
+```
+
+If the backend is unreachable, tether logs `sync offline` and keeps working
+against the local file; writes converge when it comes back.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `remember(type, title, body, tags?, links?)` | Save a memory; upserts on `type`+`title` so facts refine rather than duplicate |
+| `recall(query, type?, limit?)` | Keyword search; returns id/type/title/body/tags/updated_at |
+| `link(id_a, id_b)` | Bidirectional link between two memories |
+| `forget(id)` | Delete a memory |
+
+Plus an auto-loaded resource `tether://memory-index` — a compact one-line-per-memory index surfaced each session.
+
+## License
+
+MIT

tether_memory-0.1.0/README.md

@@ -0,0 +1,93 @@
+# tether
+
+**A shared memory layer for personal agents, across devices.** `tether` is an
+[MCP](https://modelcontextprotocol.io) server backed by a local SQLite file. Any
+MCP-compatible agent can `remember`, `recall`, `link`, and `forget` durable notes
+— facts about you, your projects, your preferences — so context follows you
+instead of dying with each session.
+
+It runs **local-only with zero configuration**. Point it at a hosted
+[libSQL/Turso](https://turso.tech) primary and the same file becomes an embedded
+replica that syncs your memory across every device in near-real-time.
+
+## Why
+
+The near future is personal agents living across many devices — laptop, desktop,
+phone. For that to feel like *one* assistant rather than several amnesiac ones,
+memory has to be a substrate that follows you: readable and writable from every
+device and from any agent, not siloed inside a single tool.
+
+`tether` is that substrate. It is deliberately a *convenience layer* — it makes an
+agent more useful when present, and never breaks the agent's work when degraded.
+
+## Status
+
+v0.1 is implemented. Design and rationale: [`docs/superpowers/specs/2026-07-03-tether-design.md`](docs/superpowers/specs/2026-07-03-tether-design.md). Implementation plan: [`docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md`](docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md).
+
+## Design at a glance
+
+- **Four verbs**, nothing more: `remember` · `recall` · `link` · `forget`.
+- **Upsert on write** so the store doesn't rot into near-duplicates.
+- **Rich recall** (id, type, title, body, tags, `updated_at`) so an agent can
+  judge staleness and cite what it updates.
+- **An auto-loaded boot index** — a compact one-line-per-memory list surfaced to
+  the agent each session, so memory helps even when the agent doesn't think to
+  search.
+- **Local-first, sync optional** — the local path is untouched when no backend is
+  configured; degradation never throws.
+- **Keyword search now, embeddings later** — the SQLite schema is built so
+  semantic search and a full entity/edge graph slot in without migrating data.
+
+## Install
+
+Requires Python ≥3.10 on a POSIX system (Linux/macOS).
+
+Register it with Claude Code — with [uv](https://docs.astral.sh/uv/):
+
+```sh
+claude mcp add tether -- uvx --from tether-memory tether
+```
+
+…or install it first:
+
+```sh
+pip install tether-memory
+claude mcp add tether -- tether
+```
+
+(The PyPI package is named `tether-memory` — `tether` was already reserved on
+PyPI as a common brand name — but the installed command is still `tether`.)
+
+By default memory lives in a local SQLite file at
+`~/.local/share/tether/memory.db` (override with `TETHER_DB`). No accounts, no
+network — this is the whole tool for a single machine.
+
+## Sync across devices (optional)
+
+Point tether at a [Turso](https://turso.tech) / libSQL database and the local
+file becomes an embedded replica — local-speed reads, writes that propagate to
+your other devices. Install the extra and set two env vars:
+
+```sh
+pip install 'tether-memory[sync]'
+export TETHER_SYNC_URL='libsql://<your-db>.turso.io'
+export TETHER_SYNC_TOKEN='<your-auth-token>'
+```
+
+If the backend is unreachable, tether logs `sync offline` and keeps working
+against the local file; writes converge when it comes back.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `remember(type, title, body, tags?, links?)` | Save a memory; upserts on `type`+`title` so facts refine rather than duplicate |
+| `recall(query, type?, limit?)` | Keyword search; returns id/type/title/body/tags/updated_at |
+| `link(id_a, id_b)` | Bidirectional link between two memories |
+| `forget(id)` | Delete a memory |
+
+Plus an auto-loaded resource `tether://memory-index` — a compact one-line-per-memory index surfaced each session.
+
+## License
+
+MIT

tether_memory-0.1.0/TASKS.md

@@ -0,0 +1,26 @@
+# tether — task tracker
+
+Checklist view of the v0.1 build. Full step-by-step detail (code, tests,
+commands) lives in
+[`docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md`](docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md).
+Design rationale is in
+[`docs/superpowers/specs/2026-07-03-tether-design.md`](docs/superpowers/specs/2026-07-03-tether-design.md).
+
+## v0.1 — local-first memory MCP server + opt-in sync
+
+- [ ] **Task 1 — Scaffolding.** `pyproject.toml`, `src/tether/__init__.py`, `tests/__init__.py`. Editable install + pytest run green.
+- [ ] **Task 2 — `config.py`.** DB path, sync credentials, device id resolved from env. Zero-config default = local file, no sync.
+- [ ] **Task 3 — `store.py` schema.** `memories` table + external-content FTS5 index + sync triggers; idempotent `migrate()`.
+- [ ] **Task 4 — `remember()`.** Upsert on `type` + normalized `title` so facts refine instead of duplicating.
+- [ ] **Task 5 — `recall()`.** FTS5 keyword search, type filter, rich returns (id/type/title/body/tags/updated_at); punctuation-safe.
+- [ ] **Task 6 — `link()` / `forget()` / `boot_index()`.** Bidirectional links, hard delete, compact newest-first index.
+- [ ] **Task 7 — `sync.py`.** Connection factory: local `sqlite3` or libSQL embedded replica; degrade-to-local on any failure. **Spike the `libsql-experimental` client first.**
+- [ ] **Task 8 — `server.py`.** `FastMCP` — four verbs + `tether://memory-index` resource + `main()`. Tools return `{"error": ...}` rather than crash.
+- [ ] **Task 9 — Docs + self-test.** README install/sync/tools; `scripts/selftest.py` end-to-end smoke.
+
+## Deferred (not in v0.1 — designed for, not built)
+
+- [ ] Semantic/embedding search (`embedding BLOB` + `sqlite-vec`, backfill; no data migration).
+- [ ] Entity/edge graph model layered alongside `memories`.
+- [ ] Automatic corrupt-DB move-aside-and-recreate recovery (v0.1 degrades to a per-call error instead).
+- [ ] True bounded/backgrounded sync tick beyond the best-effort `sync_now`.

tether_memory-0.1.0/blog-drafts/tether-post.md

@@ -0,0 +1,92 @@
+# Tether v0.1: A Shared Memory Layer for Personal Agents
+
+We shipped [tether](https://github.com/sidyellur/tether) yesterday — an MCP server that turns a local SQLite file into a durable memory substrate for personal agents across devices. If you're building agents that span a laptop, desktop, and phone, this is the post for you.
+
+## The problem is amnesia at scale
+
+Picture this: you're using Claude on your laptop, and it learns something important about your project — a decision you made, a constraint you mentioned, a preference you established. You close the tab. Three hours later, on your phone, you ask the same agent a question. It has no idea what you told it before. So you explain again. And again. Each device is a fresh start, and you're burning tokens re-establishing context that already exists.
+
+This matters because personal agents are *mobile* by definition. If an agent is useful, you'll want to talk to it from wherever you are. But context doesn't follow you unless memory does — and not the kind locked in vector stores or fine-tuning checkpoints. You need a *durable, writable, cross-device memory substrate* that any agent can read and update from any device, any time.
+
+That's what tether solves.
+
+## The core insight: memory as shared ground
+
+The key design decision isn't technical — it's architectural. Instead of building a memory *system* (embeddings, entity graphs, reasoning layers), tether is a *substrate*. Think of it like a filesystem: not everyone needs to understand ext4 to use a laptop, but a common storage layer makes it possible for different tools to share files.
+
+In our case, different agents on different devices share the same SQLite database. Your Claude session on the laptop can call `remember()` to save a fact. Your Claude session on the phone calls `recall()` to find it. A third-party agent in the middle can link memories together or refine them. None of them need to coordinate — they're all reading and writing the same shared ground.
+
+This isn't about perfect consistency or strong guarantees. It's about being a *convenience layer* that helps when present and doesn't break the agent when degraded. An agent using tether should never feel worse off for having it than without it.
+
+## Design choice: local-first, sync optional
+
+Here's where we got the most pushback during design: why local-first at all? Why not just build against a cloud primary from day one?
+
+The answer is deployment friction. A truly cross-device sync system requires a reliable backend, proper authentication, and careful handling of offline states. That's a lot of operational complexity for a v0.1. More importantly, many agents don't *need* cross-device sync — they're happy running on a single machine. Forcing them through that complexity would be a mistake.
+
+So we inverted it: local SQLite is the default. Zero config. No accounts. No network. You install tether, point Claude Code at it, and memory just works. An agent that wants to stay local never thinks about sync.
+
+For agents that do need to follow you across devices, you point tether at a Turso/libSQL primary and it becomes an embedded replica. The exact same code path handles both cases — the difference is a single environment variable. Write a memory on your laptop, and it propagates to your phone within seconds. Go offline, and the agent keeps working against the replica; changes converge when you reconnect.
+
+This design sidesteps vendor risk (you're not forced into a SaaS dependency) and keeps the surface simple. It also means we can iterate on sync without breaking single-machine deployments.
+
+## The hidden cost of `.sync()`: a real-world lesson
+
+During implementation, we hit a snag that wouldn't have shown up in unit tests or design docs.
+
+The plan was straightforward: when tether starts up and a backend is configured, call `conn.sync()` on libsql-experimental to probe connectivity. If the handshake fails, log it and move on. This was meant to be cheap and fast — a way to know whether the server is online before we commit to any behavior.
+
+What we actually found: `conn.sync()` doesn't fail fast. When the backend is unreachable, libSQL retries the handshake internally and retries again every ~2-3 seconds. This is good for resilience in the common case, but it means calling `sync()` inline will hang your startup if the backend is down.
+
+So we redesigned: the initial sync now runs in a background thread with a timeout. It's the same pattern we already use for periodic syncs later in the server lifecycle, just moved to startup. The change is subtle — three lines of code — but critical. Without it, tether's startup blocks indefinitely on a dead network, which defeats the purpose of having local-first defaults.
+
+This is the kind of thing that unit tests don't catch because the tests run on localhost. It's worth noting because it illustrates a principle: *be careful about libraries that abstract away I/O and timeouts*. They're usually trying to be helpful, but they can surprise you when your assumptions about control flow don't match the implementation.
+
+## Four verbs: deliberate minimalism
+
+The tether API is four functions.
+
+- `remember(type, title, body, tags?, links?)` — save a memory, upserting on type+title
+- `recall(query, type?, limit?)` — keyword search
+- `link(id_a, id_b)` — bidirectional link
+- `forget(id)` — delete a memory
+
+That's it. No `get()`, no `list()`, no raw SQL. No builder patterns or state machines. Just four verbs that do one thing each.
+
+This restraint is intentional. We resisted adding a read-first `get()` method because agents shouldn't need to know "is this fact new or existing?" before calling remember. In tether, re-remembering a fact refines it in place. We deduplicate on write, not on read — the store is indexed on (type, title_norm), and a new fact with the same normalized title updates the existing row.
+
+The upsert-on-write model is more powerful than it looks. It means agents can be optimistic: just remember the fact, and the system handles deduplication. Over time, a given memory might be updated a hundred times as an agent learns more about it, but the store stays clean instead of rotting into a heap of near-duplicates.
+
+We also ship an auto-loaded resource, `tether://memory-index`, that surfaces a compact one-line-per-memory index at the start of each session. Agents don't need to think about searching — the index is already there, ready to jog their memory or seed a conversation.
+
+## What we deferred (and why we did it right)
+
+The design spec called out three things we didn't build for v0.1:
+
+- Semantic search (embeddings)
+- Entity/edge graph model (for richer relationships)
+- Automatic corrupt-database recovery
+
+All three are useful, and all three would have added weeks to the timeline. So we made a deliberate choice: design the schema so they slot in without data migration. The `memories` table has room for embedding vectors. The schema supports rich relationships even if we're only using simple bidirectional links right now. The durability story is clear about what we don't handle.
+
+The important part: we called this out explicitly in the docs, not silently dropped it. v0.1 works and is useful today. v0.2's roadmap is visible. Anyone deploying tether knows what they're getting and what's coming.
+
+## Why this matters for multi-agent systems
+
+If you're building a system where multiple agents (or multiple instantiations of the same agent) need to collaborate on behalf of the same person, tether gives you a common language. One agent can `remember()` a decision. Another can `recall()` it and build on it. A third can `link()` it to a related fact. None of them need to implement their own memory system — they just read and write to shared ground.
+
+This becomes crucial as AI tooling matures. Right now, most agents are single-threaded: you ask, it thinks, you get an answer. But future agents will be long-lived, collaborative, and distributed across devices. They'll need to accumulate knowledge over time, share context across sessions, and let you bounce between tools without losing continuity. That's only possible if memory is a substrate, not a silo.
+
+tether is a small piece of that puzzle. It's deliberately boring — four verbs, SQLite, no magic. That boringness is the point. In a few years, when agents are everywhere, boring shared infrastructure will be more valuable than novel but isolated systems.
+
+## Try it
+
+Install with Claude Code:
+
+```sh
+claude mcp add tether -- uvx tether
+```
+
+Local memory is free. If you want cross-device sync, set `TETHER_SYNC_URL` and `TETHER_SYNC_TOKEN` pointing to a Turso database and you're done.
+
+Feedback and issues are welcome. We're building this in public, and v0.2 will be shaped by what agents actually need.