Loams v0.1.0 is out: run the whole stack yourself with Docker Compose. See the roadmap

Roadmap

What runs today, and what comes next.

Loams is more than its retrieval engine: reactive transactions, durable stores, native RPCs, 13 SDKs, connector contracts, graph and analytics engines, SQL/WAL infrastructure, agent tools and applications are present in the repo, and the first release,v0.1.0, is out as a self-hosted stack. This roadmap separates implemented scope from integration and future work. Checked against the full engine checkout and design documents on 2026-10-12.

AvailableNow: the named component is implemented, with source and test evidence.

In progressNext: implementation or end-to-end integration is still being completed.

PlannedLater: designed future capability, beyond the implemented building blocks.

Retrieval engine

Hybrid retrieval on open formats, with durable writes and independently scalable query compute.

  1. Now

    Foundation and collection storage

    Object-store I/O, Raft metadata, partitioned log, fenced workers, exactly-once links and GC. Collections bind Lance versions, Tantivy splits and delete bitmaps under one manifest.

    Available
  2. Now

    Hybrid query and Arrow

    Dense vectors, BM25, sparse retrieval, filters, RRF/DBSF/weighted fusion, tail merge, SQL table functions, Flight SQL, DoPut ingest and pinned scans.

    Available
  3. Now

    Hot tier and cluster routing

    RAM/NVMe range cache, HNSW artifacts and delta indexes, pinned text splits, maintenance, rendezvous placement, remote reads and write backpressure.

    Available
  4. Now

    Qdrant and Elasticsearch gateways

    Qdrant REST/gRPC and the Elasticsearch 8 Phase A subset. Official Python client jobs cover qdrant-client 1.15.1/1.19.1 and elasticsearch-py 8.19.

    Available
  5. Now

    CloudEvents and trigger edge

    CloudEvents codecs and HTTP ingest, a stream gRPC endpoint with idempotent produce and streaming subscribe, and a Dapr trigger-edge implementation with deployment manifests.

    Available
  6. Later

    Retrieval-quality exit gates

    Broader LangChain/LlamaIndex, BEIR, Recall@10 and ADBC gates, with a complete M1 exit report. Implemented compatibility subsets are already usable from source.

    Planned
  7. Later

    Production hardening and stream expansion

    Roles, per-namespace authorization, tenant quotas, OTLP ingest, Kafka wire compatibility and larger-scale metadata/WAL work. Engine authentication (Tailscale identity, OIDC or hashed API keys) ships in Loams 0.1.0.

    Planned
  8. Later

    Native GraphRAG and Iceberg

    Graph expansion in the retrieval query plan and Iceberg analytics remain future retrieval-engine features. The separate embedded Graph and chDB analytics foundations are tracked below.

    Planned
Native APIs and SDKs

One port speaks Connect, gRPC and gRPC-Web. Thirteen language runtimes share one conformance contract.

  1. Now

    Collection, document and hybrid Search RPCs

    18 implemented RPCs across namespace, collection, document and query services. Typed hybrid Search supports retrievers, filters, fusion, sorting, highlights and groups. Document scrolling accepts pageToken; REST and RPC handlers share the engine.

    Available
  2. Now

    13 SDK runtimes

    TypeScript, Python, Go, Rust, Swift, Kotlin, Java, C#, Dart, Ruby, PHP, C++ and Objective-C implementations. All 13 runtime commands are marked verified in the required-fixture runner. Registry publication remains separate.

    Available
  3. Now

    Generation and runtime contracts

    Protobuf bindings, facade generator, typed errors, consistency tokens, idempotency, pagination and required-fixture enforcement. Ruby/PHP have Connect-unary fallbacks with explicit streaming limits.

    Available
  4. Next

    Complete native-service migration

    SQL, stream and other native RPC migration, facade coverage and REST retirement proceed service by service. Hybrid Search and collection/document RPCs are implemented; generated SDK facades for these newer services remain a separate task.

    In progress
  5. Later

    Retrieval MCP and analytics helpers

    The engine-native retrieval MCP surface and to_arrow()/to_polars() convenience work remain planned. Implemented plugin MCP and desktop MCP code are separate surfaces.

    Planned
Loams Live

Live runs in the default build on an embedded store or on TiKV, with functions in QuickJS; versioned deployments and tenancy extend it next.

  1. Now

    TiKV metadata and transactions

    Opt-in TiKV metastore with catalog, leases, timestamp oracle, retry/commit-token handling and backend conformance tests.

    Available
  2. Now

    Reactive core and sync service

    Documents, indexes, LiveTxn, commit journal, read-set subscriptions, sessions, versioned transitions, built-in system functions and the dedicated Connect LiveServer; TypeScript client code is present.

    Available
  3. Now

    Embedded store and functions

    An embedded MVCC store on redb (snapshot isolation, group commit, a restart-safe oracle, incremental GC) is the default. Query and mutation functions run in QuickJS, in sandboxed worker processes, with argument validators and pagination.

    Available
  4. Next

    Deployments and multi-tenant Live

    Versioned deployments with compare-and-swap activation and rollback are in progress. Cross-node pickup can take up to 60 s; multi-tenant serving and namespace routing follow.

    In progress
  5. Later

    Search bridge and restore

    Live changes feeding searchable collections, point-in-time restore and supported multi-tenant deployment.

    Planned
Loams Durable

Embedded Resonate and an in-process Rust runtime on SQLite, with TiKV and MySQL/TiDB stores behind features.

  1. Now

    Embedded execution

    Durable promises, tasks, schedules and the Rust in-process runtime with SQLite behind the durable build feature. Resonate protocol and runtime tests accompany the implementation.

    Available
  2. Next

    TiKV and MySQL/TiDB stores

    Native TiKV store and a MySQL-protocol backend are implemented behind durable-tikv and durable-mysql. Loams 0.1.0 keeps Durable state in SQLite; Durable on TiKV for clusters is in progress.

    In progress
  3. Later

    Tenant workflows and operations

    Per-namespace execution, full operations/import orchestration and integrated durable agents remain future work. Existing execution primitives already support application-defined workflows.

    Planned
Flow, House and Graph

Graph serves GQL on the main port; House and the connector catalog live in the separate Fabric workspace.

  1. Now

    204-entry connector catalog

    204 manifests and configuration schemas, including 21 priority connectors. Registry filtering, protobuf/YAML conversion, capability validation and license gates are implemented; catalog entries do not claim 204 working adapters.

    Available
  2. Now

    chDB analytics engine

    Pinned libchdb bindings and a safe engine/session wrapper with byte/Arrow streaming and cancellation. House implements ClickHouse error codes and rendering, including mid-stream failures.

    Available
  3. Now

    Embedded GQL graph engine

    Grafeo-based graph engine with persistent graphs, GQL execution, batch statements, JSON/protobuf result conversion and engine tests. This is distinct from retrieval-plan GraphRAG expansion.

    Available
  4. Now

    Loams Graph service

    loams.graph.v1 on the main port behind the graph feature, with a graph catalog and admin service, statement limits, streaming results and writes through the Loams log before acknowledgement. Crash recovery is not done yet.

    Available
  5. Next

    Loams House service

    The loams-fabric binary serves the ClickHouse HTTP interface and loams.house.v1 from sandboxed chDB workers with session affinity. In 0.1.0 the engine reaches the House over TLS on a private network (LOAMS_HOUSE_ENDPOINT) and the House writes and compacts lake tables; the House is experimental.

    In progress
  6. Later

    Connector execution and Event Fabric

    Runtime adapters, streaming/CDC contracts, route deployment and the Iggy/Fluss Event Fabric extend the validated catalog; declarations alone are not running connectors.

    Planned
SQL and bucket-backed OLTP

Loams SQL runs on a patched TiDB, read-only wire access covers collections, and Loams Postgres keeps its storage on the bucket.

  1. Now

    Postgres and MySQL wire reads

    Optional pgwire and mysql-wire listeners query collections. Postgres includes read-only session/prepared-query handling; MySQL supports text SELECT and rejects writes and prepared statements.

    Available
  2. Now

    Neon-compatible WAL service

    loams-safekeeper implements the acceptor, wire protocol, fenced TiKV stores and local NVMe journal paths. The loams-wal service publishes to the storage broker with an in-process interpreted sender; the interim feeder is gone.

    Available
  3. Now

    Router verification kernel

    Sans-I/O shard maps, key ranges and hash functions, TLA+ model checks, Lean partition proofs, differential oracle, compatibility replay and browser spec/test visualization.

    Available
  4. Now

    Loams SQL on TiDB

    MySQL-compatible SQL on a patched TiDB (v8.5.8-loams.1) over TiKV, with a SQL gate for TLS, auth, limits and session migration between TiDB members, and a lifecycle that suspends, resumes and wakes on connect.

    Available
  5. Next

    Loams Postgres control plane

    A Neon fork with storage on the bucket. The control plane runs projects, branches, roles, databases, reconcilers and the Neon upcall API; computes and endpoints are not provisioned through it yet.

    In progress
Agents, plugins and browsers

Implemented plugin lifecycle, agent tooling and browser providers form the foundation of the Software Factory.

  1. Now

    Plugin host, agent tools and live dashboards

    Cordis host, persisted lifecycle, route teardown, scope checks, agent bus, A2A-style endpoint, stdio MCP and adapters. The loams-live plugin shares resumable app watch streams across dashboard tiles, with cursor replay and reconnect backoff. A2A binding deviations are documented.

    Available
  2. Now

    Browser providers and recording

    Local and Cloudflare Browser Run providers, plus an Obscura-based docked browser with isolated profiles and optional WebM/MP4 recording. Remote live validation needs credentials; real Obscura playback has a documented validation limit.

    Available
  3. Now

    WebMCP action registry

    Manifest-declared console actions, permission/risk checks, destructive-action approval gate and browser capability detection. Exposure depends on the browser; the stdio consumer of this new registry is not wired yet.

    Available
  4. Next

    Software Factory end-to-end loop

    Loams Desktop embeds the collaboration and observability apps as panels and full UIs, beside agent tools and browser foundations. The complete error-to-issue-to-patch-to-approved-deploy workflow and hosted install remain in development.

    In progress
  5. Next

    Desktop agent daemon

    loams-agentd, a headless per-user daemon that becomes the desktop agent system: single instance, discovery, token, Origin, Host and role checks on its RPC, and an optional container image. Its design is proposed and implementation is under way.

    In progress
Native applications and console

Desktop, mobile and console sources are integrated in the monorepo, with explicit platform and mock boundaries.

  1. Next

    Loams Desktop

    Electron app: a console against any server, a supervised local engine with Data Studio, local Postgres, Loams SQL and TiKV stacks, Software Factory apps and an agent panel. The release pipeline (Linux packages, Windows installer, macOS builds, signed update manifests) is present; nothing is published yet.

    In progress
  2. Next

    Android and iOS

    Native Kotlin/Compose and SwiftUI apps implement mock-first pairing, signed approvals, watch streams and sealed push flows. Shared contracts and platform CI targets exist; real-server auth and store publication remain ahead.

    In progress
  3. Now

    Console and design system

    The React console ships with Loams 0.1.0, hosted at console.loams.dev and calling your own engine. Several pages (Jobs, Connectors, SQL, Postgres control plane, Live deployments) still run on mocked clients; website console pages remain previews.

    Available
Packaging and deployment

Release engineering is implemented alongside focused integration deployment paths.

  1. Now

    Linux and Windows package pipeline

    Debian, RPM and Arch packages, Windows zip, service units, packaging self-tests, signing workflows and repository-generation tooling. Publishing waits for owner-managed signing and release configuration.

    Available
  2. Now

    Self-hosted stack

    v0.1.0: container images on ghcr.io and a Docker Compose stack (engine, TiDB, TiKV, PD, the Postgres stack and a Tailscale sidecar), locally or on your VMs over SSH, reachable only over your tailnet. Experimental features (House, Studio, Git, graph expansion) may change more. Not production ready.

    Available
  3. Now

    Integration deployment layouts

    TiKV, Neon, Loams SQL and Dapr deployment assets and test/benchmark harnesses exist. They are scoped integration paths, not a released all-in-one Compose distribution.

    Available
  4. Later

    Supported BYOC and GitOps operations

    Open-source multi-tenant BYOC, Knative, Argo CD, identity and operator design. A Helm chart, the Kubernetes operator, Headscale networks and full provisioning remain planned.

    Planned
  5. Later

    Loams Cloud

    Managed hosting and fleet operations. Billing, metering and the marketplace APIs are moving into the open repo now; there is no paid edition. The hosted console connects to an engine you run; it does not provision one.

    Planned
  6. Later

    Functions, Jobs and SystemOne

    CPU-time functions, Celery/BullMQ/Sail/RisingWave jobs and the SystemOne decision service are designed future services.

    Planned

Milestones close on conformance suites and exit gates, not feature lists. Read the gates and the risk register in §12 Roadmap, testing and risks, and why the scope is shaped this way in the decision index.