There's an open source repository whose contributing guide is refreshingly blunt: don't send us code. If you want a feature, write a plain-English description of the change you want — the team will burn tokens to implement it themselves.
The project is called qm (as in "queuing machines"), YC-backed, summarized by one tagline: a multiplayer agent harness for work. MIT licensed, 37,000+ lines of TypeScript, 377 test files, commits as of yesterday.
I read through it. It's not yet another agent framework.
What it actually does
Most AI tools default to the "personal assistant" model: one agent per person, helping you write email, look things up, run code. You can let that one agent serve several colleagues, but that's just adding chat windows — it's still an assistant.
qm flips the model. It provisions agents like newly hired employees:
- Each "employee" gets an isolated workspace: memory, files, credentials, permissions, scheduled jobs, sandbox — all separate
- Every room and project has its own scope
- People work alongside agents in Slack channels, groups, and projects, collaborating with each other too
- Strict: every harness tool call pauses for human approval, except two side-effect-free turn-ending tools
- Auto (default): a classifier screens data before it reaches the model, detecting injection attacks that try to redirect the agent, steal credentials, or exfiltrate data — can point to its own screening agent
- Dangerous: no content screening, no pauses between tools
- It accepts that agents are coworkers, not tools — so it provisions each one a full working environment
- It accepts that model vendors will change — so the engine is pluggable
- It accepts that AI-written code needs human scrutiny — so it redefines contribution entirely
- It accepts that security can't rest on promises — so the threat model is printed on page one of the docs
In their own words: *Most agents are designed like personal assistants. You can make one work for a whole company, but it quickly gets complex. QM is designed for startups.*
Translation: making one assistant serve an entire company isn't impossible — it just quickly becomes a mess. So give everyone a digital coworker instead.
That's the watershed. Let's look at how it's implemented.
Architecture: a headless core, four swappable brains
qm's core is headless: TypeScript on Node, Fastify for HTTP, Postgres for sessions, memory, queues, and other persistent state.
The key differentiator is the harness layer. A harness is the engine that drives the agent, and qm supports four — Pi, OpenCode, Codex, and Claude Code — all driving the same core. You pick one at deploy time; no vendor lock-in, swap whenever you like.
Every turn goes through the central core, which exposes only a small, fixed tool surface. One of those tools is execute — it runs commands inside the scope's own isolated sandbox. That sandbox isn't ephemeral: tools installed there stay installed. It's the agent's "persistent computer."
Scheduler, cron, and monitor keep background work running; web UI, admin console, and external portals are optional plugins layered on the core's HTTP API. Slack runs as an in-process plugin spawned and supervised by the core.
Architecture philosophy in one line: the core stays generic, everything company-specific goes into the deployment directory.
Three counterintuitive design choices
1. Zero comments allowed in the codebase
AGENTS.md states it plainly: a zero-comment standard. No explanatory comments, no TODOs, no lint suppressions, no commented-out code. Intent is expressed through naming, structure, and tests; rationale goes into commit messages and PR descriptions.
While many teams still debate "to comment or not," qm closes off the comment path entirely, forcing you to write code that speaks for itself. It echoes Feynman: if you can't explain it simply, you don't understand it — qm's version: if your code needs comments, you didn't write it well.
2. Contributions accepted in plain language, not code
As mentioned, the contributing guide says outright: since the underlying code is mostly written by coding agents now, they'd rather receive PRs as human-written text. Casual is fine — like pitching an idea to a coworker in Slack. Once aligned, they handle the implementation.
There's one more line: don't use AI to inflate your idea into a formal proposal.
That's a subtle signal. It reveals the team's stance on AI-written code — not resistance, but full acceptance followed by a redistribution of labor: humans figure out what they want; the machine writes the code.
3. Never review your own code
AGENTS.md has a hard rule: before changes merge to main, they must pass a "fresh-context" review — an independent reviewer agent that hasn't seen the code being written, whose sole job is finding problems. The context that wrote the code already believes it's correct; that belief is exactly the bias review must defeat. Green CI is not review. Self-review is not review.
There's also a post-merge habit: fix bugs across all similar instances in the repo, not just the reported one. Fixing one spot while five twins remain is a landmine waiting to be rediscovered.
Security: it's about posture, not trust
qm's security model may be its most honest design.
The organization picks a security posture; smaller scopes can tighten but never loosen it:
Note the honesty: pre-declared command policies — hard rejections for recursive deletes, destructive SQL, and the like — apply in every posture, Dangerous included. Audit records support after-the-fact investigation, but they don't block actions.
SECURITY.md goes further and admits outright: this is early experimental software. The design goal is isolating each person's data and activity, but that goal is not a promise that data won't leak. No hype, no packaging — threat models and known limitations laid out page by page.
That kind of honesty is the scarcest thing in engineering. Feynman said it: *For a successful technology, reality must take precedence over public relations, for nature cannot be fooled.* Nature can't be fooled; neither can data breaches.
Deployment: the whole company is one directory
qm's deployment philosophy is also counterintuitive. It's not a docker-compose-and-done setup. Instead: one deployment = one commitable, portable directory.
qm init generates the deployment directory with everything inside: config, sandbox Dockerfile, tools, skills, Slack manifest, deployment docs. The qm CLI is the directory's sole legitimate interpreter — it validates inputs and renders containers, task definitions, and secret routing from it.
Target options: Docker locally, Fly as Fly apps, AWS ECS Fargate with digest-pinned ARM64 tasks, and Lambda MicroVMs for agent computers.
Organizations wanting deep customization can open a private fork: a separate private repo whose history starts from cloning qm, with everything org-specific tucked into deploy/layers/<org>/ while everything outside stays byte-identical to upstream. Two skills maintain the boundary — update-qm merges upstream, and upstream-pr pushes org-agnostic fixes back upstream, never carrying anything from deploy/layers/.
In one line: the core stays the product; the layer is the company.
Is this just cargo culting?
After reading the repo, I asked myself: is this another "everything looks right but the plane never lands" cargo cult?
Let me try restating what it actually does:
But the direction is real: when AI lands inside organizations, the hard part was never how smart a single agent is — it's whether it can behave like a person, with its own desk, its own memory, its own permissions, able to sit in meetings and work alongside everyone else.
Treating agents as employees may be the most consequential shift in organizational form to watch over the next decade.