The AI platform, not the parts to build one.
MemQL is an open-source AI platform built on a time-series memory graph: typed data, queries and mutations, model routing, durable agent work and event-driven automations, declared in one .memql language and run on a cluster you own.
- typed dataDeclare concepts, validate fields, query rows, and keep every version and relationship.
- behaviorQueries, mutations, logic, tools, prompts, and event or schedule automations, in the same language.
- ai routingA call's required level routes through policies and rules to a configured source, local models included.
- agent workGoals, runs, steps, approvals, budgets, and recovery records, all of them inspectable.
- sites & appsStatic bundles served by hostname, with their sources, builds, and deployments.
One engine, seven node types, one language.
The engine runs the system. MemQL OS is an application connected to it, and so are the VS Code and Cursor extension and your own sites and applications. Every node type below ships as a product-agnostic engine image; your product’s .memql reaches it at runtime.
agent
Runs agent work: task execution, model calls and tool calling. It also holds the stream of every machine in the fleet.
bff
The API head clients dial: the engine's gRPC stream and its bridge for browsers.
edge
Serves the cluster's hosted sites by hostname, MemQL OS among them.
identity
Sign-in and tokens: magic links, passkeys, OAuth with PKCE, and the published signing keys.
mcp
A Model Context Protocol server: the engine's tools, offered to external MCP hosts.
planner
Plans goals into runs and steps, and orchestrates them.
workbench
A sandboxed Linux working directory for each plan.
// MemQL OS, at os.<your domain>
The browser workspace for one cluster. Its apps are views and controls for particular jobs, sharing one session and one connection; the engine performs the operations and enforces who may.
- Identity
- Accounts
- Campaigns
- Cluster
- Concepts
- Files
- Deployables
- Fleet
- Logs
- Materializer
- Users
- Training
- Nexus
- Settings
- Bin
Ask and voice in MemQL OS. Ask is the workspace’s shared interaction surface. Inference and voice are there when the cluster’s configuration provides them.
// the model · What is MemQL? → · MemQL OS → · Machines →
What a production agent actually needs.
An agent in a demo is a while loop around one model call. In production it has to terminate for the right reason, remember across restarts, and not bankrupt you when a model gets stuck repeating itself. MemQL’s harness module — one module of the platform — makes those the substrate.
A plan fans into steps, each step leaves an observation, recall pulls the relevant ones back, and the whole run replays. Watch.
// the agent loop
The turn loop, tool dispatch, and reply contract are part of the engine. An agent ends every turn through one structured envelope, and client tools relay across nodes. You declare the tools and the reply shape — not the for loop.
// cost & safety spine
On by default: a process-wide LLM rate ceiling, per-plan token budgets enforced before each call, and loop breakers that stop the apologize-and-retry-forever failure. Expensive plans park for approval before they spend.
// memory substrate
An append-only time-series graph: a write adds a version, keyed by the row’s id and its createdAt, and never overwrites one. Provenance and replay are free; recall() blends semantic similarity with recency, and episodic rows consolidate into durable semantic knowledge.
// the proof · every claim above points at the code. The harness module →
// the field · the others give you the pieces to build an agent runtime; MemQL is the platform whose harness module is the agent runtime. MemQL vs. agent libraries and frameworks →
What the platform measures about itself.
Figures from this release’s proving scorecard: the platform against the same model in a plain, bounded tool loop with the platform’s machinery switched off. Scorecard 2026-09-27, commit 9a93b7682.
A resume re-executes no completed step.
Completed steps a resumed run executed again. Must be zero.
replayed from recorded responses in CI; live tier not yet run
MemQL 0bare loop 2N=1A stopped run resumes with no duplicated effect.
Side effects delivered twice across a mid-run kill and a resume. Must be zero.
replayed from recorded responses in CI; live tier not yet run
MemQL 0bare loop 1N=1Repair runs from the failed step.
Already-completed steps re-executed while recovering. Repair from the failed step re-executes none.
replayed from recorded responses in CI; live tier not yet run
MemQL 0bare loop 3N=1A stalled loop escalates instead of retrying.
Runs that reached a passing verifier after an injected failure.
replayed from recorded responses in CI; live tier not yet run
MemQL 100.0%bare loop 0.0%N=1
// the record · tokens, dollars and answer quality stay unmeasured until the live tier runs. The full scorecard →
Three readers.
// the agent product builder
You're shipping a product where memory and reliability matter. You've outgrown stuffing context into prompts, and outgrown a vector DB next to a Postgres next to a custom event bus. MemQL is the platform you'd build if you had a year.
// the Go platform engineer
You want a Go-native AI platform, not a Python stack to operate. MemQL is one system: the harness, the memory graph, the cost guardrails, the node mesh, and the identity layer — already built, not assembled.
// the agentic-os curious
The next interesting layer of infrastructure is the one between models and applications. MemQL is what that layer looks like when it actually runs.
MemQL and its Cockpit are open source. Alpha.
Pre-1.0: APIs and language syntax can change between releases, and the docs here always describe the current one.