I've been building something to fix that. It's called Hive.

The Problem Is Bigger Than Memory

Knowledge doesn't live in one place. My world looks like this:

Documentation and wikis in Outline. Support tickets and client data in HaloPSA. Contacts scattered across CRMs. Conversations across Discord, email, and chat. Code across dozens of repositories.

Every one of those is a silo. They don't talk to each other. Search one and you miss everything in the others. Ask an AI agent to help you and it can't see any of them.

I recently moved my personal knowledge management from Obsidian to Outline. Great tool. But it drove home the point: every time you switch tools, your knowledge graph fractures. The links, the context, the relationships between ideas... gone. Start over.

The real problem isn't that AI agents can't remember. It's that knowledge is fragmented across incompatible systems, and agents have no way to access it, let alone learn from it. That's why Hive became my top priority.

Hive: The Knowledge Layer

Hive isn't another app. It's not a note-taking tool or a database UI. It's infrastructure... a unified knowledge layer that sits behind your existing tools and makes everything searchable, embeddable, and accessible to both humans and AI agents.

The core idea is simple: everything is an entity. A support ticket, a journal entry, a conversation, a contact, a code decision... they all go into the same system, get the same vector embeddings, and become searchable together.

You don't abandon your tools. You still write in Outline, manage tickets in HaloPSA, and chat on Discord. Hive pulls from all of them, indexing everything into a single searchable layer.

The Bee Metaphor

I built Hive around a metaphor that turned out to be surprisingly useful architecturally:

The Hive is the knowledge platform. It stores, indexes, and searches everything.

The Queen Bee is Hive's core intelligence. She doesn't forage externally... she captures entities directly from conversations as they happen. Every interaction with an agent flows through the Queen, who extracts facts, decisions, preferences, and events and stores them as structured entities. She's the reason knowledge accumulates without anyone lifting a finger.

Bees are plugins that connect to external systems and forage, pulling data in from sources like file systems, ticket systems, wikis, and more.

Honeycomb is the data structure. Entities, chunks, embeddings, all linked together.

A filesystem bee watches a directory and syncs files into Hive. An HaloPSA bee pulls in tickets and client data. Each bee knows how to translate between its source system and Hive's entity model. But the Queen doesn't need an external system... she watches the conversations themselves, turning dialogue into durable knowledge.

When agents or users need to write back to external systems, they use those systems' own APIs and MCP servers directly. Hive is the knowledge layer. It ingests and searches. The tools you already use handle their own writes. Keeps the architecture simple and avoids reinventing every external system's API.

Beyond Personal: Organizational Memory

Here's where it gets interesting. Hive isn't just for individuals.

Imagine your family has a shared knowledge base... medical records, home maintenance history, insurance details, recipes, travel plans. Or your company has institutional knowledge that doesn't live in any single tool. Tribal knowledge about why that system was built this way. Client preferences that only the senior engineer remembers. Decisions made three years ago that nobody documented.

Hive supports this through webhook ingestion. External apps push data into Hive via simple webhooks. Your project management tool fires a webhook when a task is completed. Your CRM sends updates when a deal closes. Your monitoring system pushes alerts. All of it flows into Hive as entities, gets embedded, and becomes part of the searchable knowledge base.

No complex integrations. No custom API clients. Just webhooks... the simplest integration pattern on the web, feeding into a system that makes everything searchable and available to your agents.

A family Hive. A company Hive. A team Hive. Each one a PostgreSQL schema with its own entities, permissions, and embeddings. Each one accessible to the humans and agents that need it.

AI Agents as First-Class Citizens

Most systems bolt AI support on as an afterthought. In Hive, agents are first-class users from the start. They get their own API keys, their own permissions, their own encrypted secrets vault.

But the real magic is the memory layer. Two pipelines make it work.

Recall happens before every agent interaction. When an agent needs context, it queries Hive with a salience-weighted search that doesn't just match keywords... it weighs multiple factors. How semantically similar is this entity to the current query? How recently was it accessed? How important was it marked? How often does it come up? This mimics how human memory works. Recent, important, and frequently-accessed information bubbles to the top.

Capture happens after every interaction. This is the Queen Bee at work. An LLM extracts structured entities from the conversation... facts, decisions, preferences, events, lessons... and stores them as searchable entities. The agent doesn't have to explicitly "save" anything. Knowledge accumulates naturally.

The result: an agent that gets smarter over time. Not because its model improved. Because its knowledge base grew.

The Stack

Hive is built in Rust. Fast, memory-safe, single binary, no runtime dependencies.

It's a server-side application. You host it on your infrastructure, or your company does. Your data lives on your servers, under your control. Not someone else's cloud, not a SaaS you can't inspect.

Storage is PostgreSQL with pgvector for hardware-accelerated vector search. Every knowledge base gets its own schema, its own connection pool, its own isolation. PostgreSQL gives us concurrent access for multiple agents and bees, proper transaction isolation, and pgvector's approximate nearest neighbor search scales well beyond what any single-file database can handle.

Embeddings are generated via ONNX Runtime using bge-large-en-v1.5... a 1024-dimension model that captures nuanced semantic relationships. At 1024 dimensions, you get high-fidelity representations that smaller models miss. pgvector's HNSW indexing keeps search fast even as the knowledge base scales to hundreds of thousands of entities.

Application-level encryption (AES-256-GCM) means your data is encrypted at rest, not just in transit. A database dump without the encryption key yields ciphertext.

What's Built, What's Next

The foundation is solid: the entity model, vector embeddings, semantic and full-text search, the bee framework, HTTP API with authentication, and a full CLI. The core business logic... entity CRUD, auth, permissions, bee orchestration, chunking, and search... is proven and carrying forward into the PostgreSQL backend.

What's coming next: the MCP server mode so any AI client can use Hive as a tool, the recall and capture pipelines, webhook ingestion endpoints, the secrets vault, and more bees. HaloPSA, Outline, email, RSS.

The vision is a world where your AI agent remembers everything you've told it, has access to all your knowledge across every tool you use, and gets better at helping you over time. Where your family or your company has a shared knowledge base that grows organically from the tools everyone already uses. Not because someone sat down and documented everything... but because the knowledge layer captured it automatically.

If you're building AI agents and struggling with the memory problem, I'd love to hear how you're approaching it. This is the hardest and most interesting problem in the agent space right now.