Spectron

Product Introduction

1. Definition: Spectron is an agent memory and knowledge layer platform, built as a stateless application tier on top of the SurrealDB multi-model database. It is a specialized system designed for AI agent memory management, functioning as a unified ACID-compliant substrate for graph, vector, document, and structured data.
2. Core Value Proposition: Spectron exists to solve the critical problem of unreliable, fragmented, and untraceable agent memory by providing persistent, queryable, and autonomous memory for AI agents. Its core proposition is delivering "memory you can trust" through a single-database architecture where all data commits in one transaction, ensuring consistency, provenance, and auditability from the ground up.

Main Features

1. Unified ACID Substrate: The foundational technology is SurrealDB, a multi-model database engine. Spectron operates on a single instance where graph edges, vector embeddings, document chunks, attributes, relations, and audit traces all reside. This eliminates the "middleware on fragments" problem, allowing for one ACID transaction per write. This ensures that operations like storing an entity, its embedding, and its relations are atomic, preventing the consistency gaps inherent in stitched multi-database architectures.
2. Provenance and Supersession Memory Model: Every fact-bearing row (entity, attribute, relation) carries a provenance object detailing its source kind (e.g., turn, document, reflection), trust level, and lexical span. The system implements supersession, not overwrite. When new information contradicts old, the old fact is marked with a valid_until timestamp and remains queryable for audit, while the new fact becomes current. This creates a tri-temporal fact system tracking system time (MVCC clock), known time (when Spectron first believed a fact), and valid time (when the assertion held true in the world).
3. Hybrid Retrieval and Fused Ranking: Spectron performs hybrid retrieval fusing eight signals into one auditable ranking: vector recall (embeddings), lexical recall (BM25), graph traversal, keyword bridges (RAKE), document links, Personalised PageRank, geographic recall, and trace-derived features. The ranker reads its own history, boosting rows useful for similar queries and demoting those associated with corrections. Every query produces a retrieval trace, making the scoring of each feature auditable.
4. Tiered Query Cost Ladder: To optimize performance and cost, reads are routed through a four-tier ladder gated by query understanding. Tier 1 is a direct key lookup for typed facts (sub-millisecond). Tier 2 is response reuse with entity-aware cache invalidation. Tier 3 uses the full hybrid retrieval and LLM synthesis. Tier 4 is a full-context fallback for low-confidence cases. Each tier emits a trace, making cost and latency observable per context.
5. Autonomous Understanding Mechanisms: The substrate deepens its own understanding between conversations via three mechanisms. Reflection (POST /reflect) synthesizes retrieved context into new, lower-trust facts. Elaboration is a background job proposing links between related but unconnected entities. Consolidation is an async job that crystallizes belief by pooling recent facts to create, update, or supersede them, tracking derived inputs and proof count.
6. Multi-Tenant Scope Isolation: Security and isolation are enforced at the substrate level. Each Context is its own SurrealDB namespace and database, making cross-Context reads impossible via the API. Within a Context, facts live at hierarchical scopes (e.g., org=acme/team=support), and principals carry per-verb grants (read, write, forget) over those paths, defaulting to deny. This prevents scope leakage.
7. Six Memory Categories: Spectron structures experiential memory into six typed sub-stores, not a single bucket: Episodic (raw conversational record), Identity (durable principal facts), Knowledge (learned project facts), Context (active working set), Instructions (behavioral rules), and Uncertainty (explicit "we don't know" rows emitted by the reconciler). Each has its own schema, lifecycle, and retrieval weight.
8. Document Pipeline with Provenance: Documents (text, PDFs, images, audio, video) are ingested, chunked, and indexed with structural metadata (byte offsets, time codes). Originals are stored in an object store with content-addressed identity (Blake3 hash). Extracted facts flow through the same reconciler as conversational facts, ensuring identical guarantees. A keyword graph built via RAKE provides cheap structural recall for rare-term queries.

Problems Solved

1. Pain Point: Fragmented and Inconsistent Agent Memory. Traditional agent memory stitches a vector database, a graph database, and a row store, leading to no ACID transactions across stores, eventual consistency, and seams smoothed over by application code. This breaks with entity collisions (e.g., "Beth" the customer vs. agent), silent overwrites (old facts lost), scope leakage (tenant data mixing), and untraceable answers (no provenance). Spectron solves this with a single-database, ACID-compliant agent memory substrate.
2. Target Audience: AI/ML Engineers and Developers building persistent agents (e.g., with LangChain, OpenAI Agents, Claude Code). Platform and Engineering Leaders seeking reliable, auditable, and scalable memory infrastructure for enterprise AI applications. Data Architects designing systems for knowledge-intensive domains like FinTech, Healthcare, Defense, and Legal Tech.
3. Use Cases:
   • Conversational AI Agents: Maintaining accurate, context-aware memory across long interactions and sessions, with the ability to handle corrections and updates reliably.
   • Enterprise Knowledge Management: Ingesting authoritative documents and experiential data into a queryable knowledge graph with full audit trails for compliance.
   • Multi-Agent Systems: Providing a shared, reconcilable memory layer across agents and instances with scope isolation to prevent data conflicts.
   • Contextual AI Applications: Powering applications where fact provenance, temporal validity, and update history are critical, such as legal research assistants, medical record analysis, or customer support systems.
   • Edge and Embedded AI: Leveraging the single-binary, scale-to-zero architecture of SurrealDB for lightweight, persistent memory in edge deployments.

Unique Advantages

1. Differentiation from Memory Middleware (Mem0, Zep): Spectron is the database itself, not a middleware layer. It eliminates the infrastructure of stitching separate vector, graph, and row stores. This provides native ACID transactions across all data types, removes the "middleware tax" on latency, and allows the entire system to scale to zero (inheriting compute-storage separation from SurrealDB). Multi-tenancy, supersession, and audit are engine-enforced, not application logic.
2. Differentiation from Vector Databases (Pinecone, Weaviate): Spectron is not a vector database. Vector recall is only one signal among eight in its fused ranker. It solves the known failure modes of embeddings-only retrieval: near-duplicate domination, rare-term query misses, and invisible relational structure. Its structural index is built at write time, and retrieval is fully auditable with per-feature scores.
3. Key Innovation: The Coherence Model. Spectron's core innovation is its eight-pillar, six-category, five-dimension coherence model built on a single substrate. The combination of authoritative/experiential memory distinction, the unified supersession reconciler, tri-temporal provenance, and the trace-graph feedback loop creates a memory system that is not only accurate at write time but maintains and improves its own coherence and trustworthiness over time and through autonomous learning cycles.

Frequently Asked Questions (FAQ)

1. How does Spectron differ from a traditional vector database for AI agents? Spectron is not a vector database; it is a multi-model agent memory platform. While vector databases focus solely on similarity search via embeddings, Spectron fuses vector recall with graph traversal, BM25 lexical search, keyword bridges, and more into a single auditable ranking. Crucially, it adds provenance, supersession (update without overwrite), and tri-temporal tracking—features essential for reliable agent memory that pure vector stores lack.
2. Is Spectron open source? What about SurrealDB? SurrealDB, the underlying multi-model database engine, is open source and free to self-host. Spectron, the agent memory layer built on top, is currently closed source and ships as a single Rust binary with an integrated MCP server. The company's stated roadmap is to eventually upstream foundational parts of the Spectron memory model into SurrealDB.
3. How does Spectron handle multi-tenancy and data isolation for AI agents? Spectron enforces multi-tenancy at the substrate level. Each Context (a logical tenant) is a separate SurrealDB namespace and database, making cross-tenant data access impossible via the API. Within a tenant, facts live at hierarchical paths, and access is controlled via principal-based RBAC with per-verb grants (read, write, forget) that default to deny, ensuring strict scope isolation and preventing data leakage.
4. Can I use Spectron with my existing AI framework like LangChain or OpenAI Agents? Yes. Spectron provides harness adapters for popular frameworks, including LangChain (SpectronChatMessageHistory), OpenAI Agents (run callback), and Vercel AI SDK (middleware). It also speaks the Model Context Protocol (MCP) natively, allowing direct integration with tools like Claude Desktop and Cursor via a simple configuration. Generated SDKs are available for Python, TypeScript, Kotlin, and Swift.
5. What does "supersede, never overwrite" mean for agent memory? This means when new information contradicts an existing fact (e.g., "I live in Paris" updates "I live in Berlin"), the old fact is not deleted. Instead, it is marked with a valid_until timestamp and remains in the database as a superseded record. The new fact becomes the current truth. This provides a full, queryable audit history of belief changes, which is critical for debugging, trust, and compliance, and avoids the problem of silent, untraceable overwrites common in simpler stores.