Memory without the memory tax. Knowledge graphs, entity extraction, temporal facts, and hybrid retrieval - built into the database, not bolted on top.
THE PROBLEM
Agents without memory are chatbots
Every conversation starts from zero. Every user preference is forgotten. Every entity relationship is re-discovered. Without structured memory, agents cannot learn, cannot accumulate context, and cannot coordinate with each other.
No continuity
Agents re-discover the same facts in every session. Past interactions are lost the moment the context window scrolls.
No entity awareness
Without entity disambiguation, 'Apple' the company and 'apple' the fruit are indistinguishable in retrieval.
No temporal reasoning
Facts change over time. Without temporal awareness, agents treat outdated information as current truth.
No coordination
Multi-agent systems share nothing. Each agent builds its own isolated understanding, duplicating work and diverging.
HOW IT WORKS
Ingest, extract, connect, query
Spectron processes agent interactions through a four-stage pipeline that transforms raw conversation into structured, queryable knowledge.
1. Ingest
Feed conversations, documents, tool outputs, and observations. Spectron accepts unstructured input and normalises it for processing.
2. Extract
Entity extraction, relationship mapping, fact generation, and embedding creation happen automatically. The knowledge graph grows with every interaction.
3. Connect
Background processes autonomously analyse the knowledge graph - discovering connections between entities, consolidating fragmented facts, inferring implicit relationships, and resolving ambiguities. Understanding deepens between conversations, not just during them.
4. Query
Hybrid retrieval combines graph traversal, vector similarity, and structured filters. The agent gets precisely the context it needs in one call.
Ingest
Raw Text
Text chunks
Extract
LLM
Entities & Facts
name + type, subject→verb→object
Embeddings
1536-dim vectors
Store
SurrealDB
ACID Transaction
memory
memory_chunksHNSW
entitiesembeddings
predicatesrelations
derived_fromlinks
CAPABILITIES
Memory that understands structure
Knowledge graph
Entities, relationships, and facts stored as a graph. Traverse connections to discover context that vector search alone would miss.
Entity disambiguation
Spectron resolves entity mentions across conversations. 'My manager', 'Sarah', and 'the VP of Engineering' are correctly linked to the same entity.
Temporal awareness
Bi-temporal, append-only facts track when things were true and when they were recorded. Agents reason over time, not just snapshots.
Hybrid retrieval
Combine vector similarity with graph traversal and structured filters in a single query.
Preference accumulation
User preferences, interaction patterns, and feedback accumulate over time. Agents personalise without re-learning from scratch.
Multi-agent shared memory
Multiple agents read from and write to the same memory graph. Coordination happens through shared context, not message passing.
memory_chunk
embedding[1536]
text
chunk_of
memory
text
metadata
created_at
memory_label
label
key
value
derived_from
entity
type
name
embedding[1536]
predicate
label (verb)·created_at·invalid_at
entity
type
name
embedding[1536]
AUTONOMOUS UNDERSTANDING
Memory that keeps thinking
Most memory systems are passive stores - they record what agents write and return what agents ask for. Spectron's memory is active. Between conversations, background processes autonomously deepen the knowledge graph - discovering connections, consolidating fragmented facts, and inferring relationships that no single interaction could reveal.
Connection discovery
Entities mentioned in separate conversations are linked when accumulated context reveals a relationship. No single interaction needs to state it explicitly.
Knowledge consolidation
Fragmented facts scattered across dozens of interactions merge into coherent, unified entity profiles. Understanding becomes structured over time.
Implicit inference
Facts that were never explicitly stated are derived from the graph. If Alice manages Atlas and Atlas is in Infrastructure, Spectron infers Alice works in Infrastructure.
Ambiguity resolution
Early mentions of 'the project' gradually resolve to 'Project Atlas' as evidence accumulates. Disambiguation improves autonomously.
Pattern recognition
Recurring themes, preferences, and behavioural patterns surface from episodic memory without explicit annotation.
Continuous enrichment
The knowledge graph doesn't just grow when agents write to it. It deepens autonomously between interactions - richer than the sum of its inputs.
AGENT-NATIVE ACCESS
MCP server for memory
Ingest memories, query the knowledge graph, retrieve entities and facts - all through standard MCP tool calls. Any MCP-compatible client connects instantly. No custom SDK required.
Natural language query
Generate embeddingstext-embedding-3-small
Vector Searchmemory_chunks
HNSW · COSINE
Entity Searchentities
HNSW · COSINE
Fact Chain Traversalentity → predicate → entity
3-depth recursive DFS
Memories + Facts
ARCHITECTURE
Memory in the database, not above it
This is the fundamental difference. Spectron is not middleware stitching together separate databases. It runs on SurrealDB - the same engine, the same transaction, the same permission model. When an agent writes memory, the entity, the relationship, the embedding, and the temporal metadata all commit atomically. No other memory system can guarantee this.
ACID transactions
Memory writes are transactional. No partial updates, no orphaned entities, no inconsistent graph state.
One permission model
RBAC, record-level permissions, and JWT auth apply to memory the same way they apply to application data.
No middleware tax
Competitors layer memory on top of external databases. Every layer adds latency, failure modes, and consistency gaps.
Full vertical stack
From object storage to multi-model database to agent memory - one stack, one vendor, one transaction boundary.
SPECTRON VS. MEMORY MIDDLEWARE
Mem0 hides the problem. Spectron eliminates it.
Memory middleware abstracts over fragmented databases but does not eliminate the fragmentation. The consistency gaps, latency penalties, and semantic drift persist underneath the API. Spectron does not abstract over fragmentation - it removes it entirely by putting memory in the database.
Memory Middleware
Agent
MiddlewareMem0 / custom
Vector DB
Graph DB
Relational DB
✕No ACID
Multiple round trips
Spectron
Agent
Spectron
SurrealDB
Vectors
Graph
Documents
Temporal
✓ACID
Single round trip
Mem0: middleware on fragments
Sits on top of separate vector, graph, and relational databases. Can't guarantee consistency between stores. Can't scale to zero. Can't branch a memory environment. Every layer adds latency and failure modes.
Spectron: memory in the database
Built directly on SurrealDB. One ACID transaction for memory writes. Inherits compute-storage separation from the storage engine - scale down to zero when idle. Clone a petabyte knowledge graph in seconds. No middleware tax.
Consistency
Mem0 can't enforce transactions across its backend databases. Spectron writes entities, facts, embeddings, and graph edges in one ACID transaction.
Mem0 can't clone a memory environment. Spectron branches an entire knowledge graph in seconds for testing or evaluation.
No extra infra
Mem0 requires you to provision and operate separate databases. Spectron runs on the same SurrealDB you already use for application data.
Mem0 and similar tools are middleware layers that sit on top of external databases. Spectron is built directly on SurrealDB - the memory layer and the database are the same system. This eliminates the consistency gaps, latency penalties, and operational overhead of coordinating separate services.
Yes. Spectron runs on SurrealDB as its storage and query engine. This is by design - the vertical integration is what enables ACID-safe memory operations, unified permissions, and hybrid retrieval across structured data and agent memory.
Yes. Spectron supports multi-agent shared memory. Multiple agents can read from and write to the same knowledge graph, with ACID transactions ensuring consistency. Coordination happens through shared context rather than explicit message passing.
Spectron supports working memory (current session context), semantic memory (facts and knowledge), episodic memory (past interactions and experiences), procedural memory (learned patterns and workflows), and preference memory (accumulated user preferences and feedback).
GET STARTED
Give your agents memory that doesn't leak
The first agent memory system with ACID transactions across all data models. No middleware. No consistency gaps. No fragmented memory tax.
