# Qbit

> A production-grade, multi-language AI agent platform built with Rust, Python, and Go, featuring 12 gRPC services, 5-layer memory architecture, and Darwin Gödel Machine self-improvement.

Qbit is an open-source, MIT-licensed AI agent platform built with Rust, Python, and Go, designed for production deployments. It implements a 3-service microservice architecture — a Go Gateway, a Rust Core, and a Python Agent — communicating via gRPC, and exposes 83+ REST endpoints alongside 12 gRPC services and 91 RPCs.

## What It Is

Qbit is a multi-language AI agent framework that brings together advanced 2025–2026 AI agent research into a single deployable platform. It targets engineers who need a production-hardened agent runtime with sophisticated memory management, autonomous self-improvement, and enterprise-grade safety guardrails — all under an open-source license. The platform is self-hosted via Docker Compose and requires an OpenAI-compatible LLM API key.

## 3-Service Architecture

Qbit splits responsibilities across three purpose-built services:

- **Go Gateway** (`:8080`/`:9090`): Handles REST, SSE streaming, WebSocket, Redis task queuing, circuit breaker resilience, RBAC auth, and rate limiting via the Gin framework.
- **Rust Core** (`:50051`): Runs 12 gRPC services covering vector store (HNSW), 5-layer memory engine, knowledge graph (GraphRAG), A2A agent discovery, speculative execution, and OpenTelemetry observability.
- **Python Agent** (`:50052`): Implements the ReAct + Reflexion reasoning loop, MCTS/ToolTree planning, MCP tool registry, self-learning flywheel, DGM self-improvement, and multi-agent swarm orchestration.

The data layer uses Redis (L2 cache + task queue), Qdrant (L3 vector search), and PostgreSQL 16 with pgvector (L4/L5 structured and archive storage).

## 5-Layer Memory Architecture

Qbit's memory system tiers storage from fastest to coldest:

- **L1 (DashMap):** Sub-microsecond lock-free local runtime cache for immediate state.
- **L2 (Redis):** Cluster-shared hot state with 1-hour default TTL.
- **L3 (Qdrant):** 1536-dimension vector storage with HNSW approximate nearest neighbor search.
- **L4 (PostgreSQL + pgvector):** Relational transactional registry for procedural and semantic records.
- **L5 (Postgres Cold Archive):** Compressed long-term storage for interactions older than 30 days.

Automatic promotion between tiers is triggered by age, importance scores, and query frequency metrics, with a background consolidator daemon managing cross-store migration.

## Darwin Gödel Machine and Self-Learning

The Darwin Gödel Machine (DGM) engine drives open-ended recursive self-improvement through an agent archive with roulette-wheel parent selection, a sandboxed self-modification engine, and a tool evolution system that deploys or rolls back variants based on empirical benchmark pass rates. Self-modification is constrained by 8 constitutional safety principles — preventing agents from disabling guardrails, removing human oversight, or making irreversible changes.

The autonomous self-learning flywheel runs a 4-phase cycle: **Execute → Coach → Distill → Improve**, incorporating RLAIF evaluation, QLoRA 4-bit fine-tuning (targeting q_proj and v_proj attention layers), Adafactor pre-training optimization, and DPO preference alignment.

## Enterprise and Governance Features

Qbit includes production-oriented safety and observability features:

- Human-in-the-Loop (HITL) approval workflows for high-stakes agent actions
- Role-based access control (RBAC), CORS, and rate limiting middleware
- Constitutional AI self-critique with alignment principles
- 8-dimension agent evaluation scoring (accuracy, efficiency, safety, cost, coherence, completeness, relevance, latency)
- OpenTelemetry distributed tracing across all services
- Graceful degradation: the Rust core operates without Qdrant, PostgreSQL, or Redis; the Go gateway handles downstream failures via circuit breaker

## Update: v2.1.0

The repository shows version 2.1.0 as the current release, created in May 2026 and last updated June 2026. The platform targets Rust 1.95+, Python 3.12+, and Go 1.24+, and is deployed as a 6-container Docker Compose stack. The project is MIT licensed and hosted at `jammievae/Qbit` on GitHub.

## Features
- 5-Layer hierarchical memory architecture (DashMap, Redis, Qdrant, PostgreSQL, Archive)
- Darwin Gödel Machine (DGM) open-ended self-improvement engine
- ReAct + Reflexion reasoning-action loop with stuck detection
- MCTS/ToolTree Monte Carlo Tree Search for optimal tool planning
- Autonomous self-learning flywheel (Execute → Coach → Distill → Improve)
- Multi-agent swarm orchestration (Swarm, Pipeline, Graph, Hierarchy topologies)
- A2A protocol-based agent discovery
- GraphRAG + HNSW hybrid vector and knowledge graph retrieval
- Speculative agent execution with authoritative validators
- Model Context Protocol (MCP) native server and client routing
- Human-in-the-Loop (HITL) approval workflows
- Constitutional AI self-critique and alignment
- 8-dimension agent evaluation scoring framework
- OpenTelemetry distributed tracing across all services
- RBAC auth, CORS, rate limiting middleware
- Circuit breaker resilience and graceful degradation
- 12 gRPC services, 91 RPCs, 83+ REST endpoints
- SSE streaming and WebSocket support
- QLoRA 4-bit fine-tuning and DPO preference alignment
- Docker Compose 6-container deployment

## Integrations
Redis, Qdrant, PostgreSQL 16, pgvector, OpenAI-compatible LLMs, gRPC / Protobuf, Docker Compose, OpenTelemetry, PyTorch, Gin (Go HTTP framework), GitHub Actions

## Platforms
API, CLI, LINUX, MACOS, WINDOWS

## Pricing
Open Source

## Version
2.1.0

## Links
- Website: https://www.qbit.ly
- Documentation: https://github.com/jammievae/Qbit
- Repository: https://github.com/jammievae/Qbit
- EveryDev.ai: https://www.everydev.ai/tools/qbit