Stop giving your AI agents the same repo tour.

Bitloops builds and maintains a local, typed, queryable model of your codebase so AI agents, developers, and reviewers can work from shared system state instead of rediscovering the repository from raw text.

Website · Docs · Quickstart · DevQL · Discussions

AI coding agents are powerful, but most of them still start every task by crawling the repository again: read files, grep for symbols, infer architecture, guess which tests matter, inspect old docs, and compress all of that into a prompt.

Bitloops gives them a maintained operating picture instead.

macOS, Linux, WSL:

curl -fsSL https://bitloops.com/install.sh | bash

Windows PowerShell:

irm https://bitloops.com/install.ps1 | iex

Windows CMD:

curl -fsSL https://bitloops.com/install.cmd -o install.cmd && install.cmd && del install.cmd

From the repository or subproject you want Bitloops to capture:

bitloops init --install-default-daemon

Then work normally with your AI coding agent and commit as usual. Bitloops installs managed hooks, starts or binds the local daemon as needed, captures relevant session context, and keeps the local repository model fresh through daemon workers and Git safety producers.

Open the local dashboard:

bitloops dashboard

Or visit:

http://127.0.0.1:5667

Pause or resume capture for the current project:

bitloops disable
bitloops enable

Remove Bitloops-managed local artefacts from your machine:

bitloops uninstall --full

For detailed setup, configuration, troubleshooting, storage, and upgrade notes, use the documentation site.

Bitloops is alpha, but the current product already focuses on practical local workflows:

• initialize a repository and install managed agent/Git hooks;
• capture AI-agent sessions and checkpoint history;
• inspect captured work and repository intelligence in a local dashboard;
• query repository state through DevQL and GraphQL;
• model current and historical files, artefacts, dependencies, commits, tests, checkpoints, and capability-pack data;
• use supported agent integrations across Claude Code, Codex, Cursor, Gemini, Copilot, and OpenCode;
• keep data local by default, with optional remote stores, connectors, telemetry, and inference providers controlled by configuration and consent.

Some of the deeper truth-maintenance vision is still evolving. Bitloops already contains many primitives for provenance, confidence, freshness, stale-state handling, lifecycle state, and reviewability, but broader invalidation, governance, and human-approval flows are being built incrementally.

Bitloops turns agent activity, repository structure, development history, tests, and external knowledge into a local queryable model.

• Developers using AI agents who want better context, fewer repeated repo scans, and a searchable trail of what the agent did.
• Engineering teams and reviewers who need to inspect AI-assisted work by reasoning, prompts, files read, tools used, and commit linkage, not only by diff.
• Platform and AI-tool teams who want a typed local substrate for repository intelligence, agent context, and review workflows.
• Strategic readers evaluating AI-native software engineering infrastructure where codebase knowledge compounds instead of disappearing into chat history.

AI coding is bottlenecked by state, not only generation.

A codebase is not fundamentally a pile of text. Text is the serialization format for a changing system of files, symbols, APIs, tests, dependencies, entry points, runtime assumptions, historical decisions, external knowledge, review state, and agent activity.

Most AI coding tools repeatedly force that structured system through an unstructured medium: prompt text, retrieved chunks, embeddings, and chat memory. The agent then has to infer the system again and again.

That loop looks like this:

retrieve -> infer -> act -> forget

Bitloops changes the loop to:

extract -> persist -> classify -> validate -> refresh -> act

The goal is not just better retrieval. The goal is durable codebase truth maintenance: maintain useful facts, relationships, evidence, history, freshness, and review state so future agents and humans can act from the same operating picture.

Agents cannot reliably change systems they cannot model. Bitloops builds and maintains the model.

flowchart TD
    Developer["Developer / AI coding agent"] --> CLI["Bitloops CLI"]
    Developer --> Hooks["Agent and Git hooks"]

    CLI --> Daemon["Local Bitloops daemon"]
    Hooks --> Capture["Session and checkpoint capture"]
    Capture --> Stores["Local stores"]

    Daemon --> Sync["Current workspace sync"]
    Daemon --> Ingest["Historical ingest"]
    Sync --> Model["Queryable repository model"]
    Ingest --> Model

    Model --> Packs["Capability packs"]
    Packs --> Enrichment["Architecture, tests, knowledge, guidance, clones"]
    Enrichment --> Model

    Model --> DevQL["DevQL"]
    Stores --> DevQL

    DevQL --> Dashboard["Local dashboard"]
    DevQL --> Editor["Editor integrations"]
    DevQL --> Agents["Agent context"]

The CLI is the user control surface. The daemon coordinates long-running work: repository watching, current-state sync, historical ingest, task queues, capability consumers, enrichment workers, dashboard serving, and GraphQL endpoints.

DevQL is the typed product contract. GraphQL is the canonical API, with a terminal-friendly DSL layered on top for CLI use.

Example DevQL pipeline:

repo("my-repo") -> asOf(ref:"main") -> artefacts(name:"findById") -> tests()

Normal local use does not require cloud access to your codebase. By default, Bitloops keeps configuration, runtime state, relational data, event data, and blobs on your machine.

Optional connectors, remote stores, telemetry, and inference providers are controlled by configuration and consent. Deterministic analysis is preferred where facts can be known mechanically; inference is reserved for ambiguity, synthesis, semantic summaries, and novel cases.

Supported agent integrations:

• Claude Code
• Codex
• Cursor
• Gemini
• Copilot
• OpenCode

Built-in language adapters:

• Rust
• TypeScript / JavaScript
• Python
• Go
• Java
• C#

Technical details live in the documentation:

• Quickstart for setup and first use;
• DevQL for querying the maintained repository model;
• Docs home for guides, concepts, reference, and troubleshooting;
• Contributor documentation for source builds, architecture, language/agent/capability extension guides, and testing workflows;
• CONTRIBUTING.md for repository contribution rules.

Bitloops is moving toward stronger codebase truth maintenance:

• more accurate freshness, stale-state, and conflict signals;
• better review workflows for AI-assisted work;
• richer test, coverage, architecture, semantic, and knowledge context;
• deeper connector-backed knowledge from tools like GitHub, Jira, and Confluence;
• more agent and language support;
• optional team and remote backends while preserving local-first defaults;
• governed flows that can turn useful agent discoveries into reviewable, reusable system state.

Bitloops is not just a prompt wrapper, hook installer, dashboard, code search tool, vector database, documentation layer, chat memory, or generic RAG system.

Those can be surfaces or ingredients. The durable product is the maintained model of the codebase and development process.

• Website: https://bitloops.com
• Docs: https://bitloops.com/docs/
• Issues: https://github.com/bitloops/bitloops/issues
• Security: SECURITY.md
• Code of Conduct: CODE_OF_CONDUCT.md

Apache-2.0. See LICENSE.