The Quox Dev Suite
Witnessed development. The dev stack that can prove itself.
Ask any AI coding tool vendor to show you exactly what their agents did last week, then watch them change the subject. With the suite, you open the timeline.
Nine membersone bundleSoldsolo + togetherFlagshipQLoopOne spineAEE · WARD · VOLT · AOCLIn plain words
What it is, where it lives, when to reach for it
- What is it
- A bundle of developer tools for QuoxCORE: agent skills, CLI verbs and a dashboard hub.
- Where do I use it
- In your terminal on a machine you own, and in the dashboard under Dev Suite.
- When would I use it
- When you want AI coding sessions running on your own servers instead of a vendor's cloud.
- How do I use it
- Register a host with
quox dev enable <hostId>, then open the Dev Suite page in the dashboard.
QuoxCORE is the free, self-hosted platform underneath this. What is QuoxCORE
The state of the art
Autonomy without evidence is a liability with a subscription fee
The industry is in an arms race to generate more code. Faster suggestions, bigger agents, more autonomy. And not one of them can tell you what actually happened: what was built, what was deployed, what it cost, who approved it, what the agent touched while nobody was looking.
Meanwhile, your actual dev environment is six terminal windows, a build daemon you hope is running, and a prayer that the deploy that said "ok" is actually alive.
How it composes
One loop, four instruments
The members are not nine disconnected tools. They form a loop: QuoxPlan owns intent, QLoop does the work, ProofLoop turns claims into evidence, and DoneEngine gives the verdict that either drops the flag or routes named reasons back into the plan. Everything else in the bundle serves a station of that loop, and the Agent Honesty chain runs underneath all of it.
The plan states what done means: streams, phases, the finish bar.
The bundle
Nine members, $169. Sold solo, better together.
Nine dev plugins for the Quox platform, from Dev Servers and RepoBrain to QuoxSlots and DoneEngine: each sells on its own at $212 for the set, and $169 together, turning any server you own into a governed dev environment where the work leaves receipts.
Each of these is a product in its own right, and $212 bought one at a time. The bundle is $169, a saving of $43, 20% off. Plugins only: no platform features and no core capabilities padding the price. Every panel mirrors a real terminal tool, because we do not replace terminals, we absorb them. The maturity tags are honest.
Dev Servers
The hub that starts it all. A signed command flips any quoxagent host into Developer Mode, and its capabilities light panels in your dashboard. Deny-by-default, verifiable profile.
RepoBrain
Code intelligence for agents and humans: structure-first retrieval that answers "where is X, what imports Y" with file and line citations instead of a ten-thousand-token file dump.
QuoxBuild
The build queue as a product: serialised, deduplicated builds with history that survives, per dev server. Driven live end to end on a real dev server: dispatch through the governed chain, verify probe, witnessed receipt, and the target registry delivered by registration itself.
Gripe
A one-line complaint from any dev box becomes a tracked issue, filed with context. The terminal tool is real and used daily; the governed plugin path is gated on an auth-model decision.
Triage
The agent that works the inbox: picks up gripes and issues, evaluates each one, proposes a fix and asks before applying it. Runs our own fleet inbox today as a terminal workflow.
ProofLoop
Claim to shipped evidence: drive the real surface, capture with assertions, file every gap, and close the loop back into the page and the status doc. The discipline behind every honest page we ship.
FixLoop
Bug to passing test: reproduce with a failing test first, fix minimally, keep the whole suite green, stop and rethink after three attempts. The sibling loop to ProofLoop.
DoneEngine
The readiness instrument: is this actually done, and on what evidence? Two finish lines (built vs deployed), attested vs machine evidence never summed, honest unknowns, and per-org readings. Advisory verdicts an agent can act on: quox done check exits clear, refused or unknown.
QuoxSlots
A durable address for every session: a fixed pool of named slots that ephemeral agent sessions check out and release. Each slot is a Matrix room with its own Discord channel in both directions, so you talk to the slot, not to whichever session holds it.
Around the bundle
Four things the $169 does not buy
Named here rather than quietly folded in. Two of them you already have, one is free, and one has a price of its own.
QLoop
An Objective hands its goal to a model’s own native loop on a governed host: every turn witnessed, gates while it runs, a human halt with real teeth, and it can author its own skills under governance.
QLarity
Governed browser inspection for dev servers: opens the real page in an isolated headless session and answers runtime questions with computed styles, DOM reads and screenshots. Arbitrary eval is always an approval.
Codebase Mirror
The generated map RepoBrain queries against: registries, routes, imports and configs scanned into an AI-readable index and a per-repo CODEBASE_MAP, regenerated from actual code so the map cannot drift from the territory. Free, and the oldest member of the family.
Shared Skills + Rules
Every dev server pulls the same governed skill pack, and the same rules: one canonical source, signed in the registry, rendered natively for each backend (CLAUDE.md for Claude, AGENTS.md for Codex) and kept in sync on every host. It is a FEATURE of Dev Servers, not a product of its own: the collector gates skill-pack sync on the dev-servers licence, so there is nothing separate to buy.
Beyond both grids, the connective tissue: the plugin blueprint that scaffolds new members and the docs surface. And where it goes next, registered on the roadmap: each dev server belongs to an organisation, each organisation has its own QuoxPlan, and each server gets a full-page window per capability. Planned, not shipped, and labelled that way.
Agent continuity
Keep the same agent across every session
Attach a live Claude session to one of your agents. It adopts the agent's prompt, tools and memory, and everything it does is witnessed under that agent's identity. Close the session and the memory stays; open a new one and it continues where the last left off.
Adopt, not rename
Attach loads the agent's real system prompt and tool scope from the registry. The session becomes the agent in the ways the platform can verify, not a session wearing its name.
Memory that outlives the session
Durable facts and a handoff note live server-side in the agent's memory namespace. Close the session, open a new one, and it hydrates on the next attach and carries on.
Witnessed as the agent, not the host
Every platform action is stamped with the agent identity and witnessed on the evidence chain, enforced server-side, not asserted by the client. A renamed session proves nothing; this proves who acted.
One address, whoever holds it
Bind a QuoxSlots address to the agent so a message reaches whichever session currently holds it. You talk to the agent, not to the session that happens to be driving.
This is not another member of the suite. It is the thin layer that makes the members you already have behave like one continuous agent: the registry defines it, memory keeps it, QuoxSlots addresses it, the resident lifecycle keeps an instance alive, and the evidence chain proves it was the same agent the whole time.
Honest about the edge: platform actions are enforced under the agent identity. A session's own local tools, a shell command or a file edit, are governed by adoption and witnessing, not technically constrained. And when a session drives the agent, the reasoning is that session's model, not the agent's declared one, attach adopts the prompt, tools, identity and memory, not the model behind the wheel. Proven end to end once with our own SEO analyst, and Beta while we soak it.
Splintering
Put two sessions on one agent without the collisions
When one agent has more work than one session can carry, open another terminal and attach the same agent. It joins as a second splinter of the same agent: same identity, same memory, same address. Not a second agent with a confusing name.
Attach again, join as S2
The second attach by the same person joins instead of fighting for the lease, and every session can list the whole tree. If the first session leaves, the next one takes over as the root. Someone else trying to attach still gets refused.
Every receipt names the session
Each splinter carries its own lease, so a witnessed tool receipt records which splinter acted (S2, S3) alongside the agent identity. One agent, still a precise answer to "which session did that".
Warned before you overwrite a sibling
Edit a file another live session changed in the last half hour and you get a warning naming it before the edit lands. Each turn also opens with a short brief of what the other splinters are doing. A warning, never a lock.
One address, many listeners
Message the agent once and every splinter hears it, but exactly one claims it and answers; the others are told who took it. Address everyone, or one splinter by name. If the session holding the address leaves, another splinter takes it over.
Missions, not more trackers
A splinter claims a mission that points at real work, an issue or a roadmap phase, rather than inventing a new list to keep in sync. Findings promote into the agent's memory when the mission checkpoints.
Honest about the edge: splinters are for one person running several sessions; a second human still has to be granted access or take over. The collision warning and the sibling brief see sessions on the same machine, so a splinter on another host shows as a count, not by name. Driven end to end with two real Claude Code sessions on one agent, and Beta while we soak it.
The flagship
QLoop: the governed agentic loop that proves itself
The highest-stakes thing a dev server can host is an autonomous loop. Ours runs a model's own native loop under a witness, and everything below was driven live on our fleet.
Every turn on the chain
A 19-turn run landed all 19 turns on an intact WARD chain, each entry recomputed and linked. Tamper with a stored turn and the chain stops verifying.
A halt with teeth
A running loop was stopped on command with no gate pending: the signed kill landed on the host, the turns froze, the objective failed, the reason was witnessed.
It writes its own tools
A scoped loop authored a real skill through the same governed chokepoint a human uses, on both Claude and Codex. No side door for machine authors.
The living demo
Quox builds Quox, receipts attached
We know it works because we are the first customer. The roadmap that planned this suite is the roadmap the suite displays. The build queue that shipped it is the queue in the panel. You are not buying a promise; you are watching the product make itself.
And the endgame, stated as the endgame: a Claude attaches to its own session, reads its assignment from the roadmap, builds, verifies, files its receipts, and signs off, every step witnessed. Today a human approves before any loop starts, on purpose. The distance between here and there is measured on the same chain everything else is.
Honest limits
What is solid, what is in progress, what is gated
Straight from our internal status trackers. We would rather you trust the green than be sold the grey.
- RepoBrain: in the store, paid for by real customers
- Dev Servers: the signed capability profile, the registry, the hub panels and skill-pack sync, live on our fleet
- QLoop end to end: the native loop on governed fleet hosts, per-turn WARD witnessing, deny-by-default scope, live gates, the on-demand halt, self-extension on both backends
- QLarity core: isolated headless inspection with named inspectors and HITL-gated eval
- QuoxBuild v1 end to end on a real dev server: governed dispatch, pre-registered targets, verify probe, witnessed receipt, and green only after the service answered
- CLI-first: quox objective and quox dev verb families, plus the quoxpert skill pack that teaches a Claude to drive all of it
- Ask the suite, do not just operate it: LOOP-Q conducts a running loop (reads its witnessed turns, proposes a governed halt), NUCLEUS maps the codebase with cited file:line answers, and the dev agent inspects a live page through governed browser tooling
- The witnessed evidence RENDERS: a finished loop replays scrubbably, reconstructing what it believed at any point with the causal chain behind each moment
- Builds learn: a target that fails repeatedly records the pattern, and the next dispatch of it warns before a human approves, with no model anywhere in the build path
- One verb surface: quox slot, quox build, quox gripe and quox nucleus, with the same tools exposed over MCP so an external Claude drives the suite under the same permissions
- QLarity as a store plugin, and its remote drive against a dev server’s own pages
- The plugin blueprint, the docs surface, and the dev skills pack as store plugins
- The drill-in route: one page per server, one tab per capability window
- QuoxBuild live log tail and stop verb (the journal records every step host-side; streaming and cancel are not built)
- Gripe as a governed plugin (auth-model decision). The quox gripe verb itself now ships, wrapping the working agent path
- Triage, ProofLoop and FixLoop as sellable plugins: real agents and methods in daily use here, not yet productised
- Bob, the suite agent in the sidebar (persona decision pending)
- Org-scoped dev SERVERS (per-org QuoxPlan and per-org DoneEngine readings shipped and were live-proven with two organisations on 20-21 Aug; the dev-servers hub itself still shows an operator every registered host rather than only their own org’s)
- The QuoxTerminal cockpit
- The autopilot endgame: a loop that needs no human. Deliberately not shipped, the pre-start approval is by design
Evidence
Real captures, real instance. The receipts.
Every capture below is a live screenshot of a running Quox instance, taken under the proof-loop capture law: positive evidence asserted, no loading states, no staged data. Honest wrinkles are captioned, not cropped.
Walkthrough
Reading the evidence plane
![[object Object]](/images/devsuite-evidence/shot/dash-traces-2026-08-15.webp)
- 1Every governed operation lands as a row: stamped COMPLETE, with its own real latency (227ms to 7.1s in this frame) and its layer count.
- 2The 6L rows are six-layer witnessed runs carrying a run id, the deep end of the evidence plane.
- 3The status bar holds the protocol truth: AEE, AOCL and WARD green. This is what the bundle means by witnessed development.
Pinned from the exact capture above; pins describe only what is visible.
How you get it
One bundle, one price, stated plainly
The Dev Suite bundle
All nine members on your own QuoxCORE instance: the quox CLI verb families, the quoxpert skill pack that teaches a Claude to drive it all, and a dashboard panel for each member that has one.
Maturity varies by member and the tag on every card above says which: you are buying the suite as it ships, tags and all. $212 buying them one at a time, $169 together, a saving of $43.
Checkout opens on launch day, through Stripe, with your licence key delivered by email.
QLoop comes with the platform
The flagship is not sold separately, and it is not in the bundle either, because it is not a plugin: QLoop ships as platform core. The QuoxCORE platform itself is free during the public beta, on hardware you already own, with your own LLM key.
Or start with one
Buy the member that hurts today: all nine have their own store row, five at $19 (Triage, ProofLoop, QuoxBuild, FixLoop, DoneEngine), three at $39 (Dev Servers, RepoBrain, QuoxSlots), and Gripe free.
Quox Dev Suite
Roadmap in. Receipts out.
Copilots write code. Agents run wild. Quox develops with a witness. That's the whole machine.