Three composable primitives for autonomous AI — memory, planning, reasoning. Embedded-first. Rust core. Polyglot SDKs. The stack you would build yourself, if you had the time.
“Agents forget between sessions, plan with no grounding, and reason without evidence. We are fixing that — one layer at a time.”
AI agents are stateless by default. Every conversation starts from zero. The memory solutions that exist today dump unstructured text into a vector store and call it done — the result is junk extraction, temporal blindness, and no way to audit what an agent actually remembers.
Arc Labs builds the cognitive infrastructure that agents are missing. We started with memory because it is the foundation — an agent that cannot remember cannot plan, cannot reason, cannot improve. Our first product, Recall, is a typed, structured memory layer with a write pipeline that rejects noise before it ever reaches storage.
We build in Rust for correctness and performance. We ship open source under Apache 2.0 because infrastructure this foundational should be inspectable. We design embedded-first so you can run locally before you ever need a server. The goal is not another SaaS — it is a stack of primitives you own.
Rust-core memory layer that fixes junk-heavy extraction, temporal blindness, and operational friction. Seven-stage write pipeline rejects noise before storage. Typed schema with facts, preferences, events, entities, and relations. Drops into any agent framework.
Turns goals into executable plans atop Recall context. Plans are DAGs of steps with subgoals, expected tools, and risk types. Maps steps to MCP tool calls, infers parameters from memories, replans on failures.
Structured, policy-aware reasoning for multi-step workflows. Combines chain-of-thought, self-consistency, Recall retrieval, and MCP tool coordination. Grounds answers in memories and tool outputs — not vibes.
The next decade of AI isn't bigger models —Arc Labs · Founding Thesis · 2026
it's the infrastructure around them.
Memory. Planning. Reasoning.
Primitives you can own, audit, and run locally.
Constraints are design decisions. Here are the ones we won't compromise on — even when it would be easier to.
The engine is free, forever. We make money on hosting, not by paywalling basic features. Nothing that ships free today will ever become a paid tier.
Every primitive runs on your laptop — single binary, SQLite storage, zero dependencies. The cloud tier is a convenience, never a requirement.
Flat text memories lose temporal and relational signal. Everything we store has a type, a provenance chain, a valid-from timestamp. Structure is the whole game.
200 high-signal memories beat 10,000 noisy ones. Every pipeline has a pre-write filter that rejects more than it keeps. Fewer, better.
Every memory links back to its source turn. Every retrieval is auditable. Every reasoning step cites its evidence. No black boxes.
No 'basic feature is $249/mo' trap. LLM costs pass through at zero markup. If you can read a spreadsheet, you can predict your bill.
A 10,000-entry audit of production memory stores. What gets stored, what shouldn't, and the pre-write filter design that changes the ratio.
Recall's typed schema vs Mem0's flat extraction on the same 500-turn eval. Where structure wins, where it doesn't, and why we still chose it.
What we learned building Recall's N-API bindings. Async streaming, zero-copy FFI, and the bits of Rust error handling that don't survive the boundary.
What they hate about Mem0. What they rolled themselves. Why most of them said 'I'd pay for this if it was self-hostable.'
How the cognitive stack unfolds — what we're shipping, what we're waiting on, and how Plan and Reason will compose on top of memory.
How we're building Zep-competitive temporal reasoning on top of Postgres + pgvector. No graph database required. Coming May 2026.
A quickstart for Tuesday afternoon, a Learn track for the deep dive, a glossary for quick lookups, and a playground when you want to see the system in motion.
From zero to a working memory-enabled agent. TypeScript, Python, or Rust.
Five tracks on agent memory: foundations, write pipeline, read pipeline, math, production.
Every term used in agent memory engineering, with definitions and links to depth.
Patterns and pitfalls for support, coding, personal assistants, sales, research.
Every formula, threshold, and constant — one printable page.
Watch a single turn travel through the entire memory pipeline.
Engineering notes, research drops, occasional product updates. Roughly monthly.