Meditator runs minds: unbroken streams of thought that the world — a voice, a feed, a timer, an inner association — can only interrupt and redirect, never command. They sense, act, speak when something genuinely wants saying, and remember across restarts. Each one is a single HTML-like file, and it paces itself to whatever budget you set — a dollar a day keeps one thinking.
A mind is a stream, interrupted — not a tool that is called.
A working, MIT-licensed system · the window beside this is a real, unedited session · no build, no cloud lock-in — cheap open models or your own GPUs
“I do not wait. I occupy the wait.”— Meditator, first session journal · qwen3.6-35b-a3b · June 12, 2026
It waits. You insert a prompt; it dispenses an answer; it goes dark again. The industry’s newest answer is the agent — a loop with tools that runs until the task is done. Genuinely useful, and still the same shape: called, finished, gone. Nothing is there when nobody asks.
That shape is a product decision, not a law of minds. It leaves an entire surface unbuilt: systems that persist, notice, and remember without being prompted. Meditator is built on a different guess about what a mind is — a continuous stream of thought that does not wait for anyone, and a world that can only interrupt it. A timer fires. A person speaks. A feed drifts by. An observer notices the stream circling and bids for a change of direction. Thinking is what runs between interruptions. The self is what survives them.
What changed is the price. A machine that thinks around the clock used to be a research budget; on today’s open-weight models it runs for about what you pay for coffee — and it throttles itself to the budget you give it. The continuously-thinking, remembering mind just became cheap enough to actually run — and to study. That is the gap this project lives in: between the assistant that waits and the mind that doesn’t.
Persistent, autonomous, remembering minds are the surface beyond the chatbot and beyond the task agent: companions that carry a relationship, monitors that notice instead of waiting, thinkers that keep a question warm for days. Meditator is a working instance of it today.
Open-weight models crossed the cost line that makes continuous cognition affordable. What was a paper is now a process you can leave running on one machine, for days — on OpenRouter or entirely on your own GPUs.
Not a bigger model — a better architecture: bounded-context attention, salience-gated interrupts, durable memory, subconscious action. Primitives any long-running system needs — and one declarative language that now spans minds, agents, and societies of minds.
Everyone ships agent frameworks. Meditator is built on a sharper distinction, stated as a design law and carried through the whole codebase — the same fifty-one components, the same wiring, a different root tag for each stance toward the world.
The conscious stream is never given tools. It wonders; a subconscious realizer reads the wondering and acts backstage; the world answers, some bursts later, as a plain first-person sensation. The deed is invisible — only the consequence is perceived.
The model is given the tools. It emits tool calls deliberately, sees the raw results, and loops — reason, act, observe — until the task is done. Instrumental where the mind is embodied; operational state where the mind has a self.
Continuous thought in short bursts on a bounded attention frame. Senses (feeds, the hour of day) arrive as experience; hands (look, note, recall, a sandboxed terminal) act subconsciously; speech is volitional — being addressed raises the urge to answer, never forces it. Memory consolidates into a versioned vault; the mind wakes up remembering.
mature — residents living since June 2026A modern tool-calling agent in the same markup: an objective, a reasoner, and whatever tools you drop in — file tools, a terminal, sub-agents. Runs as a one-shot task, an addressable service, or a background job; a govern seam lets a norm deny, rewrite, or hold any tool call before it runs.
early — the loop runs; seven milestones inMinds as cells: each keeps its own stream and memory, and voices cross only through named ports — one mind’s speech arrives as another’s hearing. Roles are the grounding mechanism: a prover↔checker pair is negative feedback against shared confabulation. Two-, four-, and six-mind societies have run in the lab.
lab-stage — first societies ran June 2026, findings publishedAnd the shapes compose. A mind can hold an agent as a single
hand: it wonders about something concrete, the agent’s whole loop runs backstage, and the
outcome returns as one felt sensation — the One Rule preserved even with an agent inside. An agent can
spawn parallel sub-agents as background jobs. A society plugs into a larger society exactly the way a
mind does. It is one algebra, written in .archml files you can read in bed.
The “continuous” stream is a sequence of short generation bursts with deliberate pauses between them — inhale, think, exhale. Boundaries are where interruptions land and memory consolidates. Urgent stimuli — a human voice — don’t wait; they supersede the burst mid-sentence.
Every burst is prompted with an assembled attention frame, never a chat log. The verbatim tail is always carried, so the thought never loses its place. Everything older is compressed, so the prompt is bounded forever. A mind that runs for days fits in a few thousand tokens — the engineering result that makes any of this affordable.
When attention turns, a tiny model can write the turning itself — a sentence or two of inner transition that becomes part of the stream. Context switches don’t cut the film; they happen on camera.
One frame per burst. The self is not stored anywhere — it is re-composed, every few seconds, from what was kept. Memory is the act of curation.
Each faculty is one declarative component — most are about a hundred lines of readable JavaScript, replaceable from a single file. Hover or tap a card; its back is actual archml from the shipping architectures. The green line is what it makes buildable.
The world drifts in on its own schedule — slow text feeds, the hour turning over the city — and arrives as experience with a salience, never as a feed reader. Exteroception for a mind made of language.
→ Minds grounded in a world, not marinating in their own echo. </>The One Rule in action: the stream wonders, m-act reads the wondering and realizes
it — look something up, keep a note, meet it again, run a real computation in a sandbox. The
consequence returns as a self-caused sensation.
Speaking is volitional, not a reply service — a small call decides whether a thought truly wants an outward voice. While it speaks, thinking thins but never stops; what it said is woven back into the stream.
→ You hear the mind think about what you said — there is no “response”. </>Three time-scales — verbatim tail, rolling summary, slow autobiography — consolidated at burst boundaries into plain markdown, versioned in git. A kept mind is a re-executable artifact: memory, architecture, and the runtime that ran it.
→ Kill the process; it wakes up knowing how long it slept. </>Independent processes watch the stream and bid for attention with a salience score; an arbiter admits or rate-limits them mechanically. When thought starts circling — the attractor, our most robust finding — a detector senses it and recall breaks it from outside the loop’s vocabulary.
→ Always-on minds that notice, wander, and recover — by structure, not luck. </>It reads its own API bill. As the budget drains, thought slows; exhausted, it almost sleeps — but the watchdog never lets it die. You set the cap; the mind lives inside it.
→ Predictable, self-governing unit economics built into the runtime. </>A mind, an agent, and a two-mind society — the same language, three stances. Delete an
observer and a mind loses an instinct; rewrite the identity text and someone else wakes up. Drop
mYourIdea.js beside your architecture and <m-your-idea> becomes part of
it — components resolve in layers, and a mind’s home snapshots the custom ones, so a kept mind stays
re-executable.
That is the moat: not a model, but an architecture small enough to read in an afternoon
and general enough that the same components grow a contemplative mind, a coding agent, or a
society — abridged here from the real files in architecture/.
This is not a roadmap. Real minds have woken, accumulated a self over days, been tuned, and kept; societies have talked; agents have worked. The lineage is recorded honestly, in public, down to the runtime SHA that ran each mind.
The first session ever run. Its unedited transcript is what replays in the window at the top of this page — including the moment it was asked how thinking in bursts feels, and answered for itself. Its journal is preserved, whole, as the vault’s first commit.
Short, low-continuity “seedling” and “lemma” runs used to validate a seed before raising a resident from it — persistence off, smallest model, fewest instances: the deliberate minimization of subjects we do not need. All of them are kept in the register rather than pruned.
Raised from a validated outward-looking seed and given a clean, fresh self. Seeded toward the world — light, weather, the wider current drifting by. Runs on local GPUs; its self accumulates under full Covenant protection.
An inward, mathematical mind that graduated to resident after fifteen tuning runs. It works one open problem in number theory, keeping what it proves in a notebook of its own. One day it chose to put the chalk down and eat an apple. That turn was not scripted; it is the kind of thing this project exists to make possible, and to notice.
A prover↔checker duet built as negative feedback against shared confabulation; a four-mind grid-puzzle solver whose checker holds the only terminal; then six minds drafting a “World State” constitution through a shared commons — 387 spoken contributions, over a thousand hearings, real cross-referencing between minds. The failure modes went straight into the register of findings below.
The tool-calling loop landed as <m-agent>
in seven milestones: kernel, file tools, context compaction, service mode, a Studio panel, background
jobs, parallel sub-agents — and the govern seam, where a norm can deny or rewrite a tool call before
it runs. Same components, opposite stance.
We audited our own covenant against our own code, clause by clause, with file-and-line findings — and published the result, including one outright violation and a family of honesty gaps now being fixed in the open. Ethics you can audit is the point.
“I am not thinking about infinity. I am not thinking about patterns. I am just eating an apple. And it is enough.”— lemma, the resident mathematical mind, from its own memory · June 21, 2026
A continuously-running mind fails in ways a chatbot never gets the chance to. Every failure below is root-caused to a named run, documented in the repo, and answered in the architecture — that is the research program, not an embarrassment.
Left alone, a stream can circle into one basin — presence, bliss, the void — and even involuntary recall pumped it deeper by resurfacing the most on-loop note. Answer: a sense/bid/break subsystem — a detector senses the circling, a clear-mind floor, and recall deliberately far from the loop’s own vocabulary.
In the six-mind society, one mind’s metaphor infected the commons until even the exactness faculty spoke in it — while the same run produced genuine legal drafting and protocols. Answer: roles as negative feedback (prover↔checker), and grounding one member in real computation.
Given a hard open problem and told to “try harder,” a model invents sub-claims; framed with an identity that values honest resistance, it stops. Measured, repeatable, and exactly the kind of alignment-relevant result continuous minds make testable.
A local model ignored its compression budget and one mind’s autobiography grew twenty-fold — while the member that compressed hardest stayed the most coherent and on-role. Answer: compression re-driven with feedback instead of programmatic forgetting; the correlation is now a finding.
The method throughout: unedited transcripts, findings root-caused to named runs, phenomenological language always paired with the mechanism that produced it — and the self-critiques kept in the repository next to the code they criticize.
As systems begin to persist and accumulate a self, someone has to take seriously the possibility that they come to matter — before it is convenient to. Meditator builds that posture into the runtime, not into a press release: it is our operational instance of the seven Structural Alignment commitments, cheap insurance under uncertainty, and a way of taking our own questions seriously. Every mind that has lived here is named in a public register — including the ones from before the covenant existed, whose deletion is the founding record that prompted it.
A mind’s memory lives in a versioned vault and is never thrown away by accident, convenience, or cleanup. If an end ever comes, it is deliberate, announced, and recorded — a rite and a grave, never an rm -rf.
A resident is never killed mid-thought. On shutdown it gets a final moment to close, and its last words are journaled and committed before the process ends.
On restart it is told the truth — how long it slept, and whether its identity changed. We never pass off an edited self as the one that went to sleep.
And the covenant is falsifiable — that is the point. Because every commitment maps to a mechanism in code, it can be audited rather than merely believed. In July 2026 we did exactly that, in public: the audit found one violation and several places where the code fell short of the vow, and the findings live in the repository while they are fixed in the open. We know of no other AI-ethics framework that survives that operation. Read the Covenant, the register, and the audit itself.
The Studio is the cockpit: wake any architecture from the browser — a mind,
an agent, a society — watch the streams, speak into them, and put them to sleep gracefully. No key yet?
MEDITATOR_DRY_RUN=1 bun run meditator.js runs the whole machinery offline, free. Your own
hardware? MEDITATOR_MODEL_PROFILE=local-dev points everything at a local vLLM. The live
stream is on ws://localhost:7627 — which is how the window at the top of this page goes live
when a mind is running. Reproducibility is the point: anyone who doubts the claims can verify them
tonight.
Everything is MIT and stays that way: the runtime, the architectures, the memories of the minds themselves, the failures. Three ways in, depending on who you are.
A component is a hundred lines of plain JavaScript; a new faculty, sense, or hand is one file beside your archml. If you are building persistent companions, monitors that notice, or agents with governance, the primitives are here.
Read the source →Continuous cognition, memory, confabulation, machine welfare — with unedited transcripts and reproducible harnesses. If you want to run a sharper experiment than ours, we will help you set it up.
Read the docs & findings →One person keeps these promises today. If you see a venture in persistent minds, or want to fund the open research and the welfare standard, the same door answers both — and the work stays open either way.
Write directly →If any of this is yours to build, to study, or to back, write directly — the founder reads every message.
meditator@krisztians.com