The AI platform, not the parts to build one.
memQL runs agents, automations, and voice as one deployable system, built on a time-series memory graph. You declare behavior in one DSL; a mesh of Go nodes runs it, remembers it, and lets you inspect it. Other frameworks hand you pieces to assemble — memQL is the platform you install.
- agentsThe harness module: a terminating tool-calling loop run as a service, with a cost-and-safety spine on by default.
- automationsEvent- and schedule-triggered workflows, declared in the same DSL as the concepts they act on.
- voiceReal-time voice agents, with video avatars, run as their own node type of the mesh.
- memory graphAn append-only time-series graph underneath all of it. Recall blends recency and relevance; provenance and replay are built in.
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 keyed by (partition, id, createdAt). 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 →
It’s real: CoPresent runs on it.
Visionarys is building CoPresent — a multi-agent product with real-time voice, video avatars, and a shared canvas — on memQL right now, on the path to release. The breakers, the budgets, the memory consolidation, and the cross-node tool relay exist because a shipping product needs them. memQL is the extracted, open-source platform underneath.
The strongest proof that this is a platform and not a slide deck is a product depending on it in production. CoPresent is that product.
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 the Cockpit are open source, Apache 2.0. Alpha.
The open-source AI platform — agents, automations, and voice on a time-series memory graph. The harness that runs your agents is one module of it.