Glossary

One of the four open Quox protocols. AEE is the standard shape for a message between agents: who sent it, who it is for, what it intends, and which earlier message it answers. It gives every action a traceable cause.

In Quox: Every task, result and event in Quox travels as an AEE envelope, so you can follow the exact chain of "this happened because of that" across agents and services.

A pattern where several specialist AI agents work together on one job under a single human approval gate, rather than one general agent doing everything. Each agent has its own role, tools and budget, and a supervisor coordinates them.

In Quox: In Quox, Agentic Teams orchestrate specialist agents into collaborative topologies with per-agent budgets, autonomous schedules and human-in-the-loop approval, and every step lands in the audit trail.

A Quox protocol that structures agent activity into layers, the way the OSI model structures networking. Each layer records what it did, so the whole run becomes an inspectable, ordered audit stack.

In Quox: The AOCL evidence chain is what lets you ask, after the fact, which agent delegated to which, with what tools, at what time, and what came out.

In Quox, an Assistant is a supervisor. It holds the conversation, keeps a persona, and routes work. It can call many Agents across a single conversation.

In Quox: The Agent-versus-Assistant split is a core Quox distinction. Assistants sit higher in the hierarchy and delegate; Agents are the workers that carry out discrete tasks. They are not duplicates of each other.

How much an AI system is allowed to act on its own before a human is asked. More autonomy means fewer stops; less autonomy means more checkpoints.

In Quox: Quox frames autonomy as five gates and three decisions: at each gate an action can proceed, escalate to a human, or be deferred. You tune how freely agents act per situation.

A Quox product: a self-feeding knowledge graph that agents can cite. It captures facts and their relationships so answers can point back to a source rather than being pulled from thin air.

In Quox: Brain2 is how Quox agents ground answers in your own accumulated knowledge, distinct from RepoBrain, which indexes code specifically.

An AI agent that drives a real web browser to navigate, click, fill forms, extract data and monitor pages, recovering on its own when a site changes. It automates web tasks that have no API.

In Quox: Browser-Q is Quox's browser agent: it carries 48 browser tools, injects credentials from the vault so they never reach the model, heals its own selectors when a page shifts, and records the run as evidence.

A spending cap on AI work, measured in cost or tokens. Budgets stop a runaway process before it burns through money or compute.

In Quox: Quox enforces budgets at four scopes: the whole organisation for a month, a single objective, one workflow run, and one turn of an agentic loop. Breaching a budget stops or terminates work rather than quietly overspending.

The Quox orchestrator, often shortened to Q. It is the top-level Assistant that receives your request, decides which agents and tools are needed, and coordinates them to completion.

In Quox: When you talk to Quox in the Command Center, you are talking to CommanderQ. It delegates specialist work to the right agent rather than trying to do everything itself.

The Quox idea that intelligence should improve with use. A one-off chat request can become a reusable, proven skill that is retrieved automatically next time.

In Quox: Compounding is the story behind Crystals: a request runs, the pattern is captured, and once approved it is available for every future run.

A Quox primitive: a reusable, governed skill distilled from real executions rather than hand-written. When a task pattern proves repeatable, it can be captured as a Crystal, reviewed, and promoted so agents reuse it.

In Quox: Crystals carry a governance trail, a budget envelope and an audit record. They differ from a legacy Skill (no history) and a Prompt (just saved text). Promotion always needs explicit approval.

Quox safety levels that scale how cautious the system is. At a higher alert level, more actions require confirmation and risky commands are restricted.

In Quox: DEFCON levels sit alongside command restrictions and confirmation codes so sensitive operations cannot run on autopilot when caution is warranted.

Handing a task to a more suitable worker. In AI systems, a coordinating agent passes a sub-task to a specialist better suited to it.

In Quox: Quox scores an incoming query against its agents and routes it to the best match above a threshold. Every delegation is written to the AOCL evidence chain, so the hand-off is provable, not just claimed.

A portable, self-contained package of VOLT events, a manifest, the ordered event log and any attachments, that proves what happened during an operation without needing access to the system that produced it. Anyone holding the bundle can verify its hash chain independently.

In Quox: VOLT is the Quox protocol that produces evidence bundles: they are how a run's record leaves the platform and stays checkable.

A layer that records what an AI system did in a way you can independently verify later. Rather than trusting a claim that something happened, you check the receipt.

In Quox: The evidence layer is how Quox positions itself: not an agent operating system, but the audit and proof layer underneath agents. The four protocols (AEE, AOCL, VOLT, WARD) are its machinery.

The rules, budgets, approvals and records that keep AI actions accountable. Governance answers who was allowed to do what, what it cost, and how you can prove it happened.

In Quox: Quox governance combines the AOCL evidence chain, four-scope budgets, approval policies, per-tenant isolation and audit export. It is the platform's core value: governance whose record you can produce, not just promise.

A pattern where a person must review and approve before an AI action proceeds. The system pauses at a checkpoint and waits for a human decision.

In Quox: In Quox, HITL is one inbox for every sensitive action. When an agent hits a human:task node, the run pauses and an approval item appears, routed to the correct organisation, until someone decides.

Running a model on your own hardware rather than a third party's cloud, so prompts and data never leave your control. It trades some convenience for privacy and independence.

In Quox: Quox supports local inference and pairs it with QuoxGPU for the compute, keeping sensitive work on hardware you own.

How an AI system remembers across turns and sessions: your preferences, past decisions, and the entities you work with. Without memory, every conversation starts from zero.

In Quox: QuoxMemory is persistent and server-side by design, so it survives a browser clear and follows you across devices. Quox treats browser storage as a cache only, never the source of truth.

A Quox feature for AI self-awareness: agents that can read and report their own state, rather than being a black box you can only guess at.

In Quox: Mirror gives an agent a structured view of itself, part of how Quox makes agent behaviour inspectable instead of opaque.

A single step in a workflow, shown as a box on the canvas. Wiring nodes together defines what runs, in what order.

In Quox: Quox workflows offer around 22 node types in five groups: triggers, AI and agents, control flow, HTTP and integrations, and governance nodes such as approval gates and budget gates.

A longer-running goal an AI system pursues over multiple runs, rather than a single task. The system keeps working towards it, spending against a shared allowance.

In Quox: In Quox an objective can trigger workflows and carries its own budget scope, so all the runs done in service of that goal share one cap.

The structure that models a company inside the platform: divisions, teams, people and the AI agents that serve them, all under one hierarchy.

In Quox: Quox puts every human and every AI in one organisation model, which is what lets budgets, approvals and evidence be scoped correctly per tenant.

An add-on that extends the platform with new capabilities. Some plugins are pure interface; others ship a real backend service of their own.

In Quox: A Quox plugin can add agent tools, dashboard surfaces and whole governed backends. Plugins are how the platform covers new jobs without changing the core.

A written rule that decides whether an action is allowed, must wait for approval, or is blocked. Policies turn judgement into something the system can enforce automatically.

In Quox: Quox workflows include policy nodes: an approval gate blocks until a policy resolves, a budget gate hard-stops on overspend, and a policy assertion checks a condition mid-run.

A Quox term for a capability granted to an agent, built from an external source such as an MCP server or a code repository and then governed like everything else.

In Quox: The Toolsmith turns MCP servers and GitHub repositories into governed agent Powers, so a new capability arrives with budgets and evidence attached rather than as an ungoverned side channel.

A discipline for turning a claim into shipped evidence: rather than asserting a feature works, you drive the real thing, capture the result with hard assertions, file every gap you hit, and only then update the page to match.

In Quox: ProofLoop is how Quox keeps its own claims honest. It is the sibling of the fix-loop, which takes a bug to a passing test; ProofLoop takes a claim to shipped, verifiable evidence.

Quox is a self-hosted control plane for AI agents: the software layer that runs your agents, gives them memory and tools, and keeps verifiable proof of what they do. It sits above any model or runtime, so the agents stay on your own hardware and under your own governance. Quox is built by Quox Ltd, and its core platform is QuoxCORE.

In Quox: The spine is reason, remember, act, govern. Actions an agent takes are recorded as witnessed evidence (AEE envelopes, a VOLT ledger and WARD receipts), so what happened can be independently verified rather than taken on trust. Core is free to self-host; paid plugins and server bands are the commercial layer.

The core Quox platform: the command centre that the agents, memory, workflows, tools and governance all run on. Most other Quox products plug into it.

In Quox: When people say they run "on Quox", they usually mean QuoxCORE: the place where CommanderQ, the agents and the evidence chain live.

The Quox workflow engine: it runs governed pipelines of nodes, applies policies and budgets, and writes evidence for every step.

In Quox: QuoxFlow is what executes a workflow you build on the canvas, turning boxes and wires into a run you can audit.

A Quox product framed as cognitive implants: focused faculties for planning, deciding, remembering and acting that an agent can draw on.

In Quox: QuoxMind bundles the reasoning and memory faculties that give agents more than a single-shot answer, alongside Mirror's self-awareness.

A tamper-evident record that a specific action happened as described. Instead of trusting a log that could be edited, you keep a receipt you can verify later.

In Quox: Quox receipts are produced by WARD as a hash-chained, append-only digest, so altering one breaks the chain and the tampering is obvious.

A Quox code-intelligence engine that indexes a codebase so an agent can retrieve the right few lines (with file and line citations) instead of reading whole files. It answers "where is X?" cheaply.

In Quox: RepoBrain is the code-focused sibling of Brain2: structure-first retrieval that returns targeted snippets, dramatically cheaper than dumping full files into context.

In general AI usage, a packaged instruction set that teaches a system how to do a particular task. In Quox specifically, Skill refers to the older, hand-authored form that Crystals now replace.

In Quox: A legacy Quox Skill has no execution history or audit trail. Crystals supersede it: same idea of a reusable capability, but distilled from real runs and governed.

A capability a model can invoke to do something beyond generating text: query an API, run a script, search a database. Tools are how an AI reaches into real systems.

In Quox: Quox adds tools four ways: an OpenAPI spec, an MCP server, a Git repository, or a script written in the Toolsmith. Every tool call is budget-gated and produces an evidence event.

The Quox path for building custom tools and Powers, including writing a script that runs in a sandbox. It is the developer-tier route for bespoke automation.

In Quox: The Toolsmith turns raw sources (a script, an MCP server, a repository) into governed capabilities agents can use, rather than ungoverned scripts running on the side.

The event that starts an automated run. Common triggers are a schedule, an incoming webhook, a manual click, or a signal from another system.

In Quox: Quox workflows support schedule (cron), webhook, manual, objective and signal-based triggers, so a pipeline can fire on time, on demand, or in response to something happening.

Running AI agents so that what they did can be independently checked afterwards, rather than only described. It shifts the question from "do you trust the system" to "can you verify the record", which matters most wherever an agent's actions carry legal, financial or safety consequences.

In Quox: This is the frame behind Quox's evidence layer: the AEE, AOCL, VOLT and WARD protocols exist specifically to make agent operations checkable, not just logged.

A Quox protocol that packages what happened during an operation into an evidence bundle you can verify: the trace of steps, inputs and outputs, tied together so it can be checked independently.

In Quox: Where AEE records single messages and AOCL layers a run, VOLT produces the verifiable evidence bundle for the whole operation.

A Quox protocol that witnesses events into a tamper-evident, hash-chained ledger. Each new receipt links to the one before, so any later edit breaks the chain and is detectable.

In Quox: WARD is the witnessing layer: it is what makes a Quox receipt trustworthy, because you cannot quietly rewrite history without the break showing.

To record an event into a tamper-evident chain at the moment it happens, so its occurrence can be proven independently later, and, as a noun, the record produced by doing so. A witnessed event carries its own proof rather than relying on the reputation of whoever logged it.

In Quox: WARD is the Quox protocol that witnesses AEE, AOCL and VOLT events, hash-linking each new entry to the one before and optionally publishing signed tips to external sinks outside Quox's own control.

Describes an action that has been recorded into a tamper-evident ledger at the moment it happened, so its occurrence can be proven later. A witnessed action carries independent proof, not just a claim.

In Quox: Quox witnesses governed actions through WARD. "Witnessed" is the difference between "the log says it happened" and "here is cryptographic proof it happened".

A defined sequence of steps that runs automatically, built by wiring nodes together on a canvas. Workflows turn a repeatable process into something you can run, schedule and audit.

In Quox: A Quox workflow runs on QuoxFlow with a live execution overlay, versioning and a library. It can include AI, agent, human approval and governance nodes, so automation stays accountable.