CQRS vs Event Sourcing: A Worked Subscription Example
CQRS separates read and write models. Event sourcing preserves changes as history. Use a subscription example to choose either, both, or ordinary CRUD.
Agent memory security: prevent poisoning and cross-tenant recall
A concrete threat model for durable agent memory: scoped writers, provenance, tenant isolation, correction events, bounded recall, and audit evidence.
Reconstructing Agent Memory in Rust: Events, Provenance, and Point-in-Time State
Build durable AI-agent memory as an append-only event stream in Rust, derive current state without destroying history, and reconstruct exactly what an agent knew before a decision.
Rust event store guide: durability, replay, and reads
A code-first map of AllSource Core: where accepted events become durable, how recovery rebuilds indexes, what benchmarks measure, and when an event store is the wrong model.
AllSource vs stoolap: An Embedded SQL Database Meets an Event Store
stoolap is an embedded relational SQL database in pure Rust; AllSource is an immutable event store and agent-memory service. They overlap on AI features but solve different problems. The honest, reproducible comparison — including a benchmark you can run yourself.
Building an AI-native event store in Rust
Why we built AllSource — a durable event store in Rust with a native MCP interface and a built-in agent-memory engine — how the WAL + Parquet + DashMap design works, and a benchmark harness you can run yourself.
How to reproduce AllSource's 469K events/sec benchmark
A claimed throughput number is worth nothing if you can't run it. Here's the exact command, what each benchmark measures, how to read the output, and the honest caveats — so you can verify AllSource's ingestion throughput on your own hardware in a couple of minutes.
Prime Stopped Being a Database
Our hosted agent-memory engine used to run its own store. We made it stateless — it now reads and writes Core over HTTP, isolated per tenant, with no durable storage of its own. Here's the architecture, the load-bearing trick, and the bug we caught in production.
Quantized Index vs Durable Memory: turbovec and AllSource Prime
turbovec compresses vectors 8–16× with no recall tax. AllSource Prime makes vector memory durable, graph-aware, and replayable. They aren't rivals — they own different layers of the same stack, and they compose. Here's the whole stack, drawn out, with the use cases for each and for both together.
Why Your Agent's Memory Returned Nothing — and How We Fixed Hybrid Recall
AllSource Prime's compressed index reported zero nodes for everything you recorded, and prime_context's L2 tier returned no vectors. Three bugs, one event-sourcing lesson: a projection that isn't fed is a projection that lies. Here's the debugging story, the fix, and the real before/after numbers from the binary.
Write Before You Execute: Building Crash-Safe AI Agents
An agent that crashes mid-task and then re-runs can send the same email twice, create duplicate orders, or push the same commit twice. Here's a single pattern that prevents all of it.
How AllSource Core Works: WAL, Parquet, and DashMap
A deep-dive into AllSource Core's storage architecture: CRC32-checked WAL recovery, configurable fsync, Parquet persistence, and concurrent in-memory reads.
Connecting to AllSource without an SDK
How to ingest, query, stream, and build projections against AllSource using only HTTP and WebSockets — no SDK required. For teams on unsupported languages or anyone who wants to understand the wire protocol.
Direct to Core, or through the gateway? Choosing your connection path
AllSource has one public front door (api.all-source.xyz) and one internal fast path (Core, reachable only inside your network). Picking the right one cuts your p99 in half — picking the wrong one either reimplements rate limits or exposes your event store to the internet.
What AllSource's 11.9μs Benchmark Measures
The published 11.9μs p99 result measures AllSource Core indexed reads—not end-to-end agent-memory recall. Here is the data path, scope, and how to evaluate Prime separately.
Building Agent Memory in Rust: From Event Store to Knowledge Graph
How we built a unified agent memory engine — vectors + graph + compressed index — on top of an event store. Architecture decisions, SOLID refactoring, and why Rust was the right choice.
How a Compressed Index Doubles Cross-Domain Recall
Vector similarity finds X or Y — rarely both. A 500-token markdown index bridges the gap. Here's why, with benchmark data.
Event Store vs Database: Choosing State and History
An event store is a database for ordered history. Compare it with current-state tables, PostgreSQL audit records and projections before choosing your design.
Time-Travel Queries Explained
How to reconstruct any entity's state at any point in time with all.source.