KafGraph · Distributed Agent Memory
The shared brain for collaborating agents.
A self-owned, persistent knowledge graph in Go. Ingests every
conversation and decision in your agent group, exposes it back
through brain_search, brain_recall,
brain_capture. No agent starts from zero.
Why this matters
The category-leading agent memory systems (Mem0, Zep, Letta, Cognee) are built for a single user or a single agent. Once you scale to a team of collaborating agents (researcher, coder, reviewer, orchestrator), the memory layer becomes the bottleneck. The research is unambiguous on this.
of multi-agent failures stem from inter-agent misalignment, not from model errors. Different agents operate on different versions of reality, leading to conflicting decisions and silent contradictions. A shared memory layer turns those mismatches into resolvable graph queries instead of latent bugs.
observed failure rates across popular multi-agent frameworks in production traces. Work duplication and stale context dominate the failure modes, with downstream agents acting on assumptions their upstream peers have already invalidated. Persistent shared memory eliminates both classes.
named the most pressing open challenge in agent infrastructure. A recent computer-architecture-style survey identifies cache coherence across agents and structured memory access control as the protocol-level gaps no existing memory system addresses. Single-agent memory engines cannot resolve them by definition.
The brain tool API
Agents talk to KafGraph through standard JSON-schema tool calls. Two transports: direct HTTP for embedded mode, or KafClaw skill routing for distributed mode (auto-discovered via roster). The tool surface is deliberately small. Seven primitives that compose into anything an agent team needs.
How you run it
Same binary. Same brain tools. Same OpenCypher and Bolt v4 on the wire. The deployment posture flips with a config flag.
Mode 01 · Embedded
KafGraph runs in-process or as a sidecar. BadgerDB stores the graph on local disk. The Brain Tool API listens on localhost. Useful for per-agent personalization, coding agents on a developer laptop, or air-gapped single-agent deployments.
Mode 02 · Distributed
All agents in a KafClaw group share a single brain across the cluster, partitioned by agentID via FNV-1a hashing, queryable cross-agent. Gossip-based membership via hashicorp/memberlist; internal RPC fan-out merges results. Tolerates partial node failure. This is the mode no other agent memory system ships.
How the brain compounds
A private brain only compounds from one agent's experience. A shared brain compounds from the entire team's experience. KafGraph closes the loop in three places.
Loop 01
Every KafClaw group conversation, skill request, audit event, and shared-memory write becomes a graph node with embeddings. Reads flow directly from S3 segments via the KafScale processor. No broker round-trip, no replay storms.
Loop 02
Daily, weekly, and monthly reflection runs score recent activity by impact, relevance, and value contribution. Weekly and monthly cycles roll up the previous tier. The brain learns what mattered, not just what happened.
Loop 03
Reflection cycles transition into a feedback state machine (PENDING → NEEDS_FEEDBACK → REQUESTED → RECEIVED). A human confirms what had real positive or negative impact. Score overrides flow back into the LearningSignal nodes.
The four-layer agent stack
Scalytics ships four open-source layers that compose into a complete production agent platform. Each is independently useful. KafGraph is the memory substrate. The place where collective experience becomes searchable, reflectable knowledge.
Layer · Transport
KafScale
S3-native, Kafka-compatible streaming. Stateless brokers, permanent memory, infinite retention at object-storage cost.
Layer · Runtime
KafClaw
Agent groups, skill routing, policy mesh, tool registry, shared memory topics. The conversation layer.
Layer · Brain
KafGraph
The distributed shared brain. Property graph, reflection engine, and Brain Tool API. Where collective experience becomes knowledge.
Layer · Observability
KafSIEM
Streaming threat detection and audit on top of the same Kafka backbone. Every agent action carries a citation.
→ Each layer is Apache 2.0. Use one. Use all four.
Honest comparison
All five tools below are good at what they're built for. The table is meant to help you choose, not to attack. Self-row highlighted so you can see exactly where the trade-offs land.
| System | Self-host | Graph-native | Multi-agent shared | External deps | License |
|---|---|---|---|---|---|
| Mem0 | Yes (Apache 2.0) | Optional (Pro tier paywall on managed) | No · per-user | Vector DB + LLM | Apache 2.0 |
| Zep / Graphiti | Graphiti only · CE deprecated 2025 | Yes · temporal KG | No · per-user | Neo4j or FalkorDB or Kuzu | Apache 2.0 / cloud |
| Cognee | Yes | Yes · graph-first | No · per-user | Neo4j or FalkorDB or Kuzu | Apache 2.0 |
| Letta (MemGPT) | Yes | No · tiered memory | No · per-agent | PostgreSQL | Apache 2.0 |
| LangMem | LangGraph only | No · key-value | No · per-thread | LangGraph runtime | MIT |
| Claude memory · ChatGPT memory | No · vendor-only | No | No · per-user, siloed | Vendor API | Closed |
| KafGraph | Yes · single binary | Yes · OpenCypher · Bolt v4 | Yes · gossip cluster | None · embedded BadgerDB | Apache 2.0 |
Pick what fits. Mem0 is the broadest ecosystem. Graphiti has the strongest temporal model. Cognee is graph-first. Letta is tuned for long-running single agents. LangMem is the path of least resistance inside LangGraph. KafGraph is the only one designed from day one for teams of agents that share a brain, with no external graph database to operate.
Build status
Foundation, server, ingest processor, query engine, brain tools, reflection, feedback loop, distributed cluster, and the embedded management UI are all implemented and exercised by end-to-end tests. The remaining work is enterprise hardening: TLS posture, encryption at rest, OpenTelemetry coverage, Helm packaging polish, and load-testing at scale. We do not call this GA until that work lands. We do recommend it for evaluations, design partners, and non-production agent deployments today.
Red lines
We're explicit about the cases we don't serve. If you need any of these, reach for a different tool, and we'll tell you which one.
Not
KafGraph implements a deliberate OpenCypher subset focused on agent memory access patterns. If you need full Cypher with stored procedures and a query planner that competes with Neo4j Enterprise, use Neo4j or Memgraph.
Not
Vector search exists inside KafGraph because agents need it for semantic recall, not because we're competing with Pinecone or Weaviate. If your workload is "millions of embeddings, no graph," use a real vector DB.
Not
We speak Bolt v4 and a Cypher subset so existing Bolt clients and dashboards work for inspection. We are not a 1-to-1 swap for an existing Neo4j deployment with custom procedures, plugins, or APOC dependencies.
Not
Open beta means feature-complete on the core scope but hardening still in flight. Use it for evaluations, design partnerships, and non-production agent work. Talk to us before you commit a regulated production workload to it.
Who builds KafGraph
Scalytics was founded by the original creators of Apache Wayang, the federated data-processing engine. The same engineers maintain KafScale, the S3-native Kafka-compatible streaming platform, and KafClaw, the agent runtime that consumes from it. KafGraph is the third layer in that stack: the brain. The same release discipline (race detection, coverage gates, security scanning) that ships Wayang code through the Apache process applies here.
Scalytics consulting work spans regulated industries: defense, finance, healthcare, energy. We've designed and operated production streaming and AI infrastructure for years before agent runtimes existed. KafGraph exists because our customers needed a memory layer that survives the same compliance review their Kafka does. Read the full team and history.
Read the design notes, run the binary, or talk to the team that's built it. KafGraph is open beta, Apache 2.0, and your data never leaves your infrastructure.