The agent runtime, not the parts to build one.
memQL is a Go harness and memory substrate that runs the agent loop, enforces a cost-and-safety spine, and remembers across restarts. Other frameworks hand you pieces to assemble a runtime — memQL is the runtime. Ship better AI, faster.
- the agent loopA terminating tool-calling loop, run as a service — not your for-loop.
- cost & safety spineRate ceiling, per-plan budgets, and loop breakers. On by default.
- memory substrateAn append-only time-series graph. Recall blends recency and relevance.
- multi-node & observableOne Go source tree compiles into a secured, traced node mesh.
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 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. Why memQL is a harness →
// the field· the others give you the pieces to build an agent runtime; memQL is the agent runtime. memQL vs. other harnesses →
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 harness underneath.
The strongest proof that this is a harness 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 runtime you'd build if you had a year.
// the Go platform engineer
You want a Go-native agent runtime, not a Python stack to operate. memQL is one substrate: the loop, the memory, 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 go-to Golang LLM harness — the runtime, the memory, and the safety spine your agents run on.