Remembra Relay
One coding agent stops, the next one already knows: session handoffs built from git facts, across machines and vendors.
- Source repo
- remembra-ai/remembra
- Stars
- ★ 15
- Last updated
- 1d ago
- License
- MIT
- Primary language
- Python
- FA score
- 72/100 · Some gaps
At a glance
- How it runs
- 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
- 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.
- A solo developer switching the same repo between a laptop, a server and worktrees who wants each new session to start with real context
- A developer who uses Claude Code by day and Codex CLI by night and needs vendor-agnostic handoffs
- An engineer picking up someone else's work who wants ground truth from git rather than the previous agent's self-report
- Users of Cursor, Gemini CLI or any MCP client, who read briefs and write handoffs through MCP tools
- 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 --applySelf-hosted (starts Remembra + Qdrant + Ollama locally, no API keys needed):
bash
curl -sSL https://raw.githubusercontent.com/remembra-ai/remembra/main/quickstart.sh | bashOr with Docker Compose:
bash
git clone https://github.com/remembra-ai/remembra && cd remembra
docker compose -f docker-compose.quickstart.yml up -dHow 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 trailVerify setup:
bash
remembra-doctor allUse the memory API directly:
python
from remembra import Memorymemory = 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?
- 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
- 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?
Why each dimension lost points
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.
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.
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.
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.
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.
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.
- 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.