u/mastagio

So, after several weeks of frustration with claude code and token spend, we came up with a thesis: with the right context, an open-weight model could match a frontier model on coding. So we decided to build Bitloops to test it.

Bitloops is an open-source memory and context layer for coding agents. We benchmarked it: GLM 5.1 on Opencode paired with Bitloops scored 88 on SWE-bench Verified (for the 43 Rust specific tests). This is higher than Claude Opus 4.6's 81% on the same benchmark.

How it works:

• Targeted context retrieval, not grep. Bitloops continuously models your codebase: structural relationships, dependencies, prior decisions. When the agent asks "how does auth work," it gets back the connected code and reasoning, not 12 random snippets. Agents query through DevQL, a typed GraphQL interface they already understand.
• Shared memory across sessions. Most agents start every session from zero. Bitloops keeps a local knowledge layer scoped to the repo and shared across agents. Cursor in the morning, Claude Code in the afternoon, same memory.
• Git-linked reasoning capture. Every session becomes a Checkpoint tied to your commits. Next session, the model sees why the last change was made, not just what changed. Reviewers get the developer-agent conversation next to the diff.
• Native agent hooks. Bitloops plugs into the agent's own hook surface on Claude Code, Codex, Cursor, Gemini, Copilot, and OpenCode. Context gets injected before the model sees the prompt. No protocol indirection.
• Local-first. Rust daemon, SQLite + DuckDB, local embeddings runtime.
• Local dashboard: still alpha, but it can present the analysis of your codebase in different ways like code-city, architectural structure, etc.
• Languages: works with TS / JS, Python, Rust, Go, Java, C# and PHP

Apache 2.0, everything's on GitHub: https://github.com/bitloops/bitloops

Happy to dig into the architecture, the hook integration, or the benchmark methodology.

So, after several weeks of frustration with claude code and token spend, we came up with a thesis: with the right context, an open-weight model could match a frontier model on coding. So we decided to build Bitloops to test it.

Bitloops is an open-source memory and context layer for coding agents. We benchmarked it: GLM 5.1 on Opencode paired with Bitloops scored 88 on SWE-bench Verified (for the 43 Rust specific tests). This is higher than Claude Opus 4.6's 81% on the same benchmark.

How it works:

• Targeted context retrieval, not grep. Bitloops continuously models your codebase: structural relationships, dependencies, prior decisions. When the agent asks "how does auth work," it gets back the connected code and reasoning, not 12 random snippets. Agents query through DevQL, a typed GraphQL interface they already understand.
• Shared memory across sessions. Most agents start every session from zero. Bitloops keeps a local knowledge layer scoped to the repo and shared across agents. Cursor in the morning, Claude Code in the afternoon, same memory.
• Git-linked reasoning capture. Every session becomes a Checkpoint tied to your commits. Next session, the model sees why the last change was made, not just what changed. Reviewers get the developer-agent conversation next to the diff.
• Native agent hooks. Bitloops plugs into the agent's own hook surface on Claude Code, Codex, Cursor, Gemini, Copilot, and OpenCode. Context gets injected before the model sees the prompt. No protocol indirection.
• Local-first. Rust daemon, SQLite + DuckDB, local embeddings runtime.
• Local dashboard: still alpha, but it can present the analysis of your codebase in different ways like code-city, architectural structure, etc.
• Languages: works with TS / JS, Python, Rust, Go, Java, C# and PHP

Apache 2.0, everything's on GitHub: https://github.com/bitloops/bitloops

Happy to dig into the architecture, the hook integration, or the benchmark methodology.

So, we were juggling Codex, Claude Code, and Cursor, across our own projects. Every project had a CLAUDE.md, .cursor/rules, a half-finished AGENTS.md — same context, written three different ways, all going stale within a week. We were maintaining Word documents pretending to be codebase brains.

So we built Bitloops — but instead of "a smarter rules file," we went a layer deeper: a local daemon that builds a typed, queryable graph of your codebase (including architectural layer, requirements, constraints, etc.). We call the query layer DevQL (GraphQL-style). Your agents call DevQL to pull the exact context they need for a given prompt and you can too.

What that gets you:

• One-command install (CLI). Pick your agents — Bitloops auto-generates the agent skills they need to call DevQL on their own.
• Real-time code graph + commit history. Always current. Imports git history so the agent can see how the code got here, not just what it is.
• Architectural understanding, not vector search. Entry points, state persistence, who calls whom, dependency shape. The agent can ask structural questions and get structural answers.
• Decisions and constraints captured from your agent conversations and attached to the specific artefacts they apply to. (Shipping right now.)
• Code City (the image above) — your actual repo as a 3D city. Buildings = files (height = size), arcs = dependencies. It's how we and our agents see structure, not just file lists. Click any building → context surfaced in milliseconds.
• Local-first. Source code isn't stored on our servers. Embeddings and summaries can run locally or in the cloud (free for now).
• VS Code extension so you can inspect any artefact and see exactly what an agent sees when it calls DevQL.

What it doesn't do yet:

• No team / multi-repo features yet.
• Not all languages (but it covers: Rust, TS / JS, Python, Go, Java, C#, PHP)
• PR review feature — the idea is to enable more efficient and effective PR reviews looking at architectural changes, system design impact, etc.
• A lot more that we would like....

Open source. https://github.com/bitloops/bitloops

Star it if you want to follow along — we ship weekly. Would love feedback.