We build the memory agents need.
Arc Labs is an AI-agent infrastructure lab headquartered in Bangalore, India. We build composable primitives for agent cognition — memory, planning, reasoning — as open-source Rust libraries with first-class TypeScript and Python bindings.
We exist because the gap between what agents need and what infrastructure provides is wide. Closing it requires purpose-built systems — not wrappers around general-purpose databases, not retrieval bolted onto vector stores, not memory that forgets why it remembers.
What we refuse to build.
Our design decisions are defined as much by what we reject as what we ship. These principles are load-bearing — they constrain every PR, every API surface, every product decision.
Quality over quantity
We reject noise at the gate. In our write pipeline, in our codebase, in our decisions. A system that stores less but stores correctly will always outperform one that stores everything and hopes for the best.
Typed, not flat
Structure is not overhead — it is leverage. We use typed schemas, explicit relations, and strong guarantees because they make every downstream operation more precise. If it can be a type, it should be a type.
Provenance on everything
Every memory traces back to the conversation turns that produced it, the pipeline stages it passed through, and the confidence score it earned. Auditability is not a feature you add later. It is a property of the data model.
Local-first, cloud-ready
Embedded mode is not a demo. It is a real deployment target with the same API, the same pipeline, and the same guarantees. You should be able to build, test, and run in production without an internet connection.
Open core in Rust
We build in Rust for correctness and performance. We ship open source under Apache 2.0 because infrastructure this foundational should be inspectable. The core is yours to audit, fork, and run forever.
Composable, not monolithic
Memory, planning, and reasoning are separate primitives that compose. No god-object agent framework. No opinionated orchestrator. Just clean interfaces you can plug into whatever stack you already have.
Why now.
The next generation of AI applications will not be chatbots. They will be agents — systems that remember across sessions, plan multi-step workflows, reason about constraints, and take action through tools.
Today, every team building agents reinvents the same infrastructure: a vector store for retrieval, a database for state, a pipeline for filtering noise, a graph for entities. The result is fragile, untested glue code that breaks in production.
We are building the standard cognitive infrastructure layer. Three composable primitives — Recall (memory), Plan (planning), Reason (reasoning) — that any agent framework can depend on. Open core. Rust for correctness. Embedded-first so you can run locally before you ever need a server.
The timeline.
From first commit to cognitive stack. Every milestone is a shipped artifact, not a press release.
Arc Labs incorporated in Bangalore. First design documents for a typed agent memory system.
Recall: Rust core, SQLite embedded mode, write pipeline prototype. Seven stages from day one.
Recall v0.1 alpha. Hybrid retrieval (semantic + BM25 + graph + temporal + type filter), TypeScript SDK via napi-rs, open-source under Apache 2.0.
Recall beta. Postgres backend, self-hosted Docker deployment, Python SDK, docs site launch.
Recall cloud service. Managed hosting, observability dashboard, team workspaces.
Plan (planning layer) and Reason (reasoning layer) enter alpha. The cognitive stack completes.
Bangalore.
Arc Labs is headquartered in Bangalore, India. We are a small, focused team building infrastructure that will outlast us. We hire for depth — systems programmers, compiler engineers, and people who have shipped production Rust.