Remembra Relay

One coding agent stops, the next one already knows: session handoffs built from git facts, across machines and vendors.

Stars
★ 15
Last updated
1d ago
License
MIT
Primary language
Python

At a glance

How it runs
Agent plugin / skillMCP serverLibrary / SDK
Works with
Universal · cross-platformClaude CodeCodex (Partial support)
Cost
Free tier plus a paid hosted plan
Setup effort
Low · running in minutes
You'll need
Python / pipxRemembra API key (cloud) or self-hosted serverDocker (for self-hosting, with Qdrant + Ollama)Shell / CLINetwork accessLocal filesystem
Typical use
A solo developer switching the same repo between a laptop, a server and worktrees who wants each new session to start with real context
Not a fit if
  • Teams unwilling to send session data to Remembra Cloud (unless self-hosting)
  • Coding workflows that do not use git
  • Users relying on Cursor, Gemini CLI or other unverified hooks
Source review
72/100 · Some gaps

What does this agent do, and when should you use it?

Remembra Relay is an MCP server plus CLI (remembra-relay) that produces session handoffs built from git facts when a coding agent's session ends. On close, it reads the branch, commits, changed files and unpushed commits from git, and for Claude Code and Codex also test runs from the local transcript; on the next session, the brief command or the session_brief MCP tool delivers what is done, failing and next in about 1,500 tokens, checking the agent's own summary against the recorded facts. Projects are identified by git remote, so handoffs work across machines, worktrees and vendors, and every handoff is kept in order in a trail. Underneath is a standalone memory API (Python/TypeScript SDKs, REST API, 21 MCP tools) with fact extraction, entity resolution, hybrid retrieval and PII protection. It runs on Remembra Cloud (free tier available) or self-hosted under the MIT license with Docker, Qdrant and Ollama.

At session end, remembra-relay close reads the branch, commits, changed and uncommitted files and unpushed commits from git; for Claude Code and Codex it also parses test runs and open items from the local transcript (which never leaves the machine, with secrets redacted before anything is sent). At the next session start, remembra-relay brief or the session_brief MCP tool renders a ~1,500-token brief: who worked last, what is done, what is failing and the next step — the done/not done/failing sections come from git and test runs, never from an LLM, and the agent's own summary is shown as unverified or contradicted against those facts. remembra-relay trail lists every handoff in order. The MCP server (remembra-mcp) exposes 21 tools: store_memory/recall_memories for memory, search_entities/timeline for entities and time, send_to_inbox/get_inbox for messaging between agents, and more. The underlying memory layer is directly usable via the Python SDK (from remembra import Memory; memory.store(...); memory.recall(...)) or the REST API.

  1. A solo developer switching the same repo between a laptop, a server and worktrees who wants each new session to start with real context
  2. A developer who uses Claude Code by day and Codex CLI by night and needs vendor-agnostic handoffs
  3. An engineer picking up someone else's work who wants ground truth from git rather than the previous agent's self-report
  4. Users of Cursor, Gemini CLI or any MCP client, who read briefs and write handoffs through MCP tools
  5. Developers adding a persistent memory layer with entity resolution and hybrid retrieval to an app via the Python or TypeScript SDK

How do you install or deploy this agent?

Cloud route (get a free key at app.remembra.dev first):

bash

pipx install --force 'remembra[mcp]>=0.16'
remembra-install --all
remembra-relay connect --apply

Self-hosted (starts Remembra + Qdrant + Ollama locally, no API keys needed):

bash

curl -sSL https://raw.githubusercontent.com/remembra-ai/remembra/main/quickstart.sh | bash

Or with Docker Compose:

bash

git clone https://github.com/remembra-ai/remembra && cd remembra
docker compose -f docker-compose.quickstart.yml up -d

How do you use this agent?

After installing, run remembra-relay connect alone first to preview every hook change without writing, then connect --apply to write them (each file is backed up); in Codex, run /hooks once to trust the hooks. Use your coding agent as usual: the close hook fires at session end, and the brief hook or the session_brief MCP tool delivers the handoff at session start. Review handoffs manually:

bash

remembra-relay trail

Verify setup:

bash

remembra-doctor all

Use the memory API directly:

python

from remembra import Memory
memory = Memory(user_id="user_123")
memory.store("Had a meeting with Sarah from Acme Corp. She prefers email over Slack.")
result = memory.recall("How should I contact Sarah?")
print(result.context)

What are this agent's strengths and limitations?

Pros
  • Handoff facts come from git and test runs, not an LLM; the agent's own summary is checked and the README shows a concrete example of it being contradicted
  • Projects are identified by git remote, so handoffs work across machines, worktrees and vendors (Claude Code, Codex, and any MCP client)
  • Fully self-hostable under MIT (Docker + Qdrant + Ollama), free of charge
  • Includes a complete memory layer: 21 MCP tools, Python/TypeScript SDKs, entity resolution, timeline queries and an inbox between agents
Limitations
  • Core handoff depends on Remembra Cloud (free tier exists, but a key is required); full offline use requires deploying your own server
  • Only Claude Code and Codex session hooks are verified; hooks for Cursor, Gemini CLI, Qwen Code and Kimi are unverified and only installed with --include-unverified
  • Codex support is verified against a prerelease, codex-cli 0.155.0-alpha.16.4; no stable Codex release has been tested
  • Benchmark evidence is thin: 1 of 10 LoCoMo conversations (76%, all 47 adversarial questions scored 0); a full run has not been done

How does this agent compare with similar options?

The README compares Relay to three alternatives (docs/comparisons/handoff-tools.md, with sources and dates): vendor memory (Claude Code, Codex, Copilot, Windsurf) is not cross-vendor and keeps no durable trail; local handoff tools (such as claude-mem and agentmemory) do not work across machines and rely on transcripts/diffs; memory APIs (Mem0, Zep, Letta) work across machines but their handoff facts do not come from git. Relay's differentiators are cross-vendor support, git-fact verification and a durable trail.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Remembra Relay This agent 72 · Some gaps Agent plugin / skillFreemium ★ 15 1d ago Python Claude Code
Happier 82 · Good Desktop appFree + model costs ★ 1.7k today TypeScript Codex · Claude Code
Emulo 78 · Good Agent plugin / skillFree + model costs ★ 292 2d ago HTML Codex · Claude Code
OtoDock 77 · Good Self-hosted serviceFreemium ★ 187 12d ago Python Codex · Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
72/ 100 5-point scale 3.6 / 5
Trust 19/29
Reliability 11/14
Adaptability 14/18
Convention 14/18
Effectiveness 9/13
Verifiability 5/8
Why each dimension lost points
Trust19 / 29 · 3.3/5

Evidence shows strong permission discipline: remembra-install previews changes before writing, connect --apply keeps backups, doctor is read-only, per-agent scoped keys are recommended, secrets are redacted on every write path, CI is SHA-pinned with pip-audit. Deductions: agent-scoped keys can read the whole account unless project-scoped (admitted in SECURITY.md), and hooks permanently rewrite each agent's local config — a standing side effect beyond least privilege.

Reliability11 / 14 · 3.9/5

Self-consistency is good: pyproject 0.16.1 coheres with README 'ships in 0.16.0'; missing extras are named by _launch rather than crashing, and wheel-install CI asserts those error paths. failure_messages earns full marks: doctor gives one fix per problem and error strings are CI-checked. dependency_availability is only adequate: core function depends on a cloud API key and resolvable PyPI versions, unverifiable statically.

Adaptability14 / 18 · 3.9/5

Audience and scenarios are clear (cross-machine, cross-vendor coding-agent handoffs). Capability boundaries are a highlight: a per-agent hook verification table, version-pinned Codex claims, and Cursor hooks labeled unverified and excluded unless --include-unverified. Deduction: hook behavior on other versions/tools is explicitly untested, so trigger precision is only adequate.

Convention14 / 18 · 3.9/5

Information architecture is clear (README/SECURITY/docs layering); MIT license is consistent across pyproject, LICENSE and README; known-limitations disclosure is exceptional (plaintext SQLite, no SOC 2, non-expiring keys, withdrawn certification dates) — full marks there. Deductions: changelog lives off-repo; maintenance rests on a single maintainer (Damany Dolphy/DolphyTech); with an unverified publisher, maintenance commitments rest on self-attestation only.

Effectiveness9 / 13 · 3.5/5

Output usability: ~1,500-token fact-based briefs and a durable trail designed for agent consumption. Marginal value is real: git facts check the agent's own summary and mark contradictions, better than transcript-only handoff. Deduction: the core value rides on a hosted service with plan tiers; self-hosting is free but operationally heavier, and enterprise claims are unaudited, so cost-benefit is unproven for that segment.

Verifiability5 / 8 · 3.1/5

Claim traceability is strong: the README brief example is anchored by a test (test_readme_relay.py), and the comparison doc claims per-claim sources and dates. fact_inference_separation earns full marks: done/not-done comes from git, not an LLM; agent summaries are labeled unverified; the project publicly retracted its own invalid benchmark. Deduction: cross-source corroboration points to off-repo docs and sites not visible in this review, and the executed hook runs cannot be independently checked, so it scores only 1.

Risks and how to mitigate them
  • Static review only; no code was executed — hook behavior, install effects and test results are not independently reproduced.
  • Agent-scoped keys can read everything the account can unless project-scoped keys are used — scope each agent key deliberately.
  • When self-hosting, SQLite (including the FTS index and backups/Litestream replicas) stays plaintext even with REMEMBRA_ENCRYPTION_KEY set; use volume-level encryption.
  • Hooks rewrite local config for Claude Code/Codex/Gemini/Qwen/Kimi; run connect without --apply first, and keep the per-file backups it creates for rollback.
  • Publisher (DolphyTech) is not registry-verified; API keys and session data flow to its US-hosted cloud with no SOC 2 or external pen test — prefer self-hosting for sensitive work.
  • API keys never expire and must be revoked manually; set a rotation schedule.
  • Hooks are verified only against the versions listed; after upgrading any agent tool, run remembra-relay doctor.
Evidence confidence: Low Reviewed Sep 27, 2026 Reviewed revision f70abacacd8f
See the full review method →

FAQ

Is it paid?
Handoffs, briefs, the inbox, the trail and search are free on every plan. Remembra Cloud paid tiers are Solo $12/mo, Pro $29/mo, Team $15/seat/mo; self-hosting is free under MIT.
Does my code or transcript leave my machine?
The transcript never leaves your machine; secrets are redacted before anything is sent. If you want nothing passing through Remembra Cloud, self-host a server and point remembra-install at it with --url.
I use Cursor or Gemini CLI — does it work?
Yes, through the MCP tools (session_brief, close_session), but their session hooks are unverified and only installed with connect --include-unverified.
How much of the brief is LLM-generated?
The done, not done and failing sections come entirely from git and the session's test runs; the agent's own summary is only shown for comparison, marked unverified or contradicted.
Will multiple agents in the same repo conflict?
Give each agent its own scoped key and its handoffs show as key-verified; the same repository, identified by git remote, counts as one project across machines, with handoffs kept in order in the trail.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents