ByteRover CLI: A Git-like Memory Layer for Coding Agents
ByteRover CLI (brv) - The portable memory layer for autonomous coding agents (formerly Cipher)
At a glance
- What is it?
- ByteRover CLI (brv) gives AI coding agents a structured, version-controlled context tree. This review covers its REPL workflow, cloud sync, and where its claims outrun its evidence.
- Who is it for?
- ByteRover CLI is for developers and teams who want a structured, version-controlled memory layer for AI coding agents and are willing to trust a hosted cloud service. It is not for those who need a clearly licensed tool, since the repository metadata lists the license as NOASSERTION, or for teams that want collaboration without the cloud, which is central to it.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- No. The owners have archived the repository on GitHub, so it is read-only and no longer receives changes.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.
Star history
- campfirein/byterover-cli4,945 ★ · -13
| Repository | 2026-09-10 | 2026-11-13 |
|---|---|---|
| campfirein/byterover-cli | 5k | 4.9k |
-13 Stars in the last 64 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The Problem: Agents Forget Between Sessions
AI coding agents like Cursor or Claude Code handle a single session well, but they lose track of project decisions once the conversation ends. ByteRover CLI addresses this by giving agents a persistent, structured memory that survives across sessions and tools. The README describes it as a 'portable memory layer' and a 'context tree.' The target user is a developer who curates knowledge about their codebase, such as 'Auth uses JWT with 24h expiry,' and then expects any agent to recall that when asked later. This is not a general-purpose chatbot memory; it is scoped to project knowledge. The tool also targets teams that want to share that context across machines and members, which is where the cloud component comes in.
How the Context Tree Works
The core mechanism is a context tree that stores structured knowledge. You add entries with the `/curate` command in the REPL, attaching a note to a specific file, as in `/curate "Auth uses JWT with 24h expiry" @src/middleware/auth.ts`. The agent then queries this tree with `/query How is authentication implemented?`. The tree is not a flat list; it is organized hierarchically, which suggests that related knowledge can be grouped. The README mentions an 'agentic map' that helps the agent understand the codebase, though the details are thin. The tree is stored locally by default, and you can sync it to the cloud. The version control system treats the context tree like a Git repository, with branch, commit, merge, and push/pull operations. That is a specific design choice: memory is not a stream of messages but a curated, reviewable artifact.
Getting Started: Commands and First Run
Installation is straightforward. On macOS and Linux, you can use a shell script that bundles everything, so no Node.js is required. On any platform, you can install via npm with `npm install -g byterover-cli`, which requires Node.js >= 20. After installation, verify with `brv --version`. The first run is a REPL: `cd your/project` and then `brv`. The README claims the REPL auto-configures on first run with no setup needed. The primary interface for most users is `brv webui`, which opens a web dashboard. Advanced users can run `brv curate`, `brv query`, and `brv review pending` from the shell. The review workflow is notable: curate operations can be pending and require approval or rejection via `brv review approve` or `brv review reject`. This implies that the agent can propose memory additions that a human must approve, which adds a safety layer.
Version Control and Cloud Sync: Git for Memory
The most distinctive feature is the version control system for the context tree. Commands like `brv vc init`, `brv vc commit`, `brv vc branch`, and `brv vc merge` mirror Git's workflow. This means you can treat changes to project memory as you would code changes: commit staged knowledge, branch experimental memory, and merge it back. The README distinguishes legacy sync (`brv push` and `brv pull`) from the newer version-controlled sync (`brv vc push` and `brv vc pull`). The cloud component, ByteRover Cloud, provides team sync, shared spaces, and multi-machine access. It also includes a hosted LLM with limited free usage. The cloud is optional for local work, but collaboration features like team management and usage analytics require it. The README claims SOC 2 Type II certification, but that is a vendor claim, not something we can verify from the repository.
Limitations and Failure Modes
A genuine limitation is that the tool's value depends on the quality of curated context. If you do not actively curate knowledge, the tree stays empty and the agent gains nothing. The README shows that you must manually add entries like '/curate "Auth uses JWT..."', which is a conscious effort. Another issue is the reliance on cloud for team collaboration. If you use `brv vc push` and `brv vc pull`, you are dependent on ByteRover Cloud's availability and its privacy mode. For teams with strict data residency requirements, sending code context to a hosted service could be a deal-breaker. There is also a potential conflict when multiple agents or teammates curate conflicting knowledge about the same file. The review workflow and version control help, but they add process overhead that not every solo developer wants.
Benchmark Claims vs. Reproducibility
The README reports impressive benchmark numbers: 96.1% on LoCoMo and 92.8% on LongMemEval-S, using LLM-as-Judge accuracy. These are long-term conversational memory benchmarks. However, the README does not describe the exact evaluation setup, such as which LLM served as the judge or how the context tree was populated. It points to an arXiv paper (2604.01599) for details, and the repository has a paper/ directory. The claim that benchmarks run on the production codebase is good, but without seeing the paper, we cannot assess whether the benchmark setup matches real usage. A developer should treat these numbers as marketing until they read the paper.
Alternatives and the License Question
A direct alternative is using agent-native memory files, such as Claude Code's CLAUDE.md or Cursor's rules files. Those are simple, local, and human-readable, but they lack version control and cross-agent sharing. ByteRover's difference is the structured context tree, the review workflow, and the cloud sync. Another alternative is a vector database for retrieval-augmented generation, but that approach typically stores embeddings, not curated, human-readable knowledge. The license is listed as NOASSERTION in the repository metadata, so read the LICENSE file before you plan to build a product around it. The README also lists 'Enterprise proxy support' among its key features.
Editorial conclusion
ByteRover CLI is for developers and teams who want a structured, version-controlled memory layer for AI coding agents and are willing to trust a hosted cloud service. It is not for those who need a clearly licensed tool, since the repository metadata lists the license as NOASSERTION, or for teams that want collaboration without the cloud, which is central to it. Before adopting, verify the benchmark methodology against the arXiv paper, test the review workflow with your own curate operations, and confirm that the 20 LLM providers include the ones you actually use. If you prefer a simpler, file-based memory approach, you might stick with agent-native memory files. The repository is archived, and its last release was v3.16.1 on 2026-05-27, but the real test is whether the context tree stays accurate over weeks of real use, not just in a benchmark.
Frequently asked questions
What does the ByteRover CLI actually do?
It gives coding agents persistent structured memory. You run brv in a project directory, the REPL builds an agentic map of the codebase, and you add knowledge with slash commands such as /curate with a quoted statement and a file reference, then retrieve it with /query. Everything works locally by default, and the cloud adds sync and sharing.
How do I install the byterover CLI?
On macOS and Linux the bundled shell installer needs no Node.js: `curl -fsSL https://byterover.dev/install.sh | sh`. Supported platforms are macOS ARM64, macOS x64, Linux x64 and Linux ARM64. With npm you need Node.js 20 or newer and run `npm install -g byterover-cli`, then check it with `brv --version`.
Is the byterover-cli repository still active?
No. The repository is archived on GitHub, the last push is dated 2026-06-25, and the newest release is v3.16.1 published 2026-05-27. There will be no further commits or releases from this repository.
What is the difference between brv push and brv vc push?
brv push and brv pull are labelled legacy and described as migrating or snapshotting context to and from the cloud. The README redirects both to brv vc push and brv vc pull for version-controlled sync going forward. The vc group mirrors git with init, add, commit, log, branch, checkout, merge, clone, push and pull.
What benchmark scores does the ByteRover CLI report?
On LoCoMo it reports 96.1 percent overall accuracy across 1,982 questions and 272 docs, and on LongMemEval-S it reports 92.8 percent overall accuracy across 500 questions and 23,867 docs. Both are described as LLM-as-Judge accuracy, and the README says the benchmarks were run with the production codebase in this repository.
Official sources
Was this useful?