Hive

Orchestration layer for AI agents — CPU-side action routing, context compression, and causal graph memory that keep mechanical work and context bloat off the LLM.

Why it matters

An agent loop spends most of its LLM calls on mechanical work — list the files, run the tests, read the file the traceback named, re-run the tests. Each of those is a paid call with the whole transcript attached. Hive answers those on the CPU and only escalates the decisions that actually need reasoning. The model sees less, pays less, and resolves the same tasks.

The headline — hard tier, n=15, held-out oracle

On a 6-task benchmark built to separate the arms (real repos, hidden pytest oracle injected only at grading, DeepSeek-V4.1-Flash, n=15, spec review equalized):

Hive matches the LLM-everything baseline task-for-task at 58% fewer LLM calls and ~45% lower cost — the routing is free capability, not a capability tax. On the easier 10-task suite it's starker: identical 30/30 resolve at −83% LLM calls and −82% prompt tokens.

Full per-task tables, the three retracted runs that got us here, and the honest caveats: benchmarks/README.md · docs/benchmarks/PROVENANCE.md.

What it does

Three jobs, all on the CPU, before the LLM is involved:

1. Routes mechanical decisions — read_file, run_tests, apply_patch go to a CPU policy. No LLM call. Out-of-distribution states escalate instead of guessing.
2. Compresses context — a content-aware classifier drops or distills the wax (stale logs, unchanged files) so the LLM sees only the honey.
3. Remembers causally — a timestamped graph records cause → effect → supersession, so the agent stops re-deriving what it already learned.

   agent request → HiveStack → { route, compress, remember } → LLM (only when needed)

Run it

Not yet on PyPI — install from source. pip install hive-agent-memory is
planned but the name does not resolve on PyPI yet.

git clone https://github.com/DJLougen/hive && cd hive
pip install -e .                           # base: rule_fast + rust_brain

from hive import HiveStack

stack = HiveStack()
result = stack.step(
    {"goal": "Fix auth bug", "step": 1},
    [("user", "login is failing"), ("assistant", "checking logs...")],
)
result["decision"]    # RouteDecision — CPU-routed or escalated
result["compressed"]  # CompressedTurn — what the LLM actually sees

Reproduce the benchmark:

python scripts/hive_bench.py --backend openai \
    --endpoint <openai-compatible-url> --api-key-env <KEY> --model <model> \
    --suite benchmarks/tasks/suite.hard.json --arm all --repeat 15

Where to go next

Status

v0.7.0 (Beta, unreleased — last release v0.6.1). Routing-accuracy numbers are in-distribution — see the OOD caveat in docs/architecture.md. PFN / busyBee-cpu training-mode integration is in progress (busyBee-cpu).

Roadmap

• Core orchestration (routing, compression, causal memory)
• Enterprise modules (auth, encryption, audit, rate limiting, multi-tenancy)
• Native Rust backend (hive-cpp) with multi-platform wheels
• Real-workload held-out A/B evaluation (three tiers, honest provenance)
• MCP + FastAPI agent extras ([agents], [server], [mcp])
• PFN-based busyBee training mode (inference + campaign retrain from FeedbackBuffer)
• Durable distributed memory backend (gossip replication in place; durability pending)
• Kubernetes operator for autoscaling
• Broader out-of-distribution routing coverage

License & citation

MIT — see LICENSE. Cite via .github/citation.cff:

@software{hive2026,
  title  = {Hive: orchestration layer for AI agents},
  author = {Lougen, Daniel J.},
  year   = {2026},
  url    = {https://github.com/DJLougen/hive}
}

Issues: https://github.com/DJLougen/hive/issues · Discussions: https://github.com/DJLougen/hive/discussions