Reason · Mirror · AI self-awareness
The AI that sees itself.
Mirror is the cognitive index at the heart of QuoxMind: a structured reflection map built from the platform's real state. Fourteen cognitive implants, the live agent roster, memory, plugins and service health in one verifiable JSON document. Agents read it before they answer, and you can inspect every byte of it.
In plain words
What it is, where it lives, when to reach for it
- What is it
- A live JSON document QuoxCORE keeps about itself: agents, memory, plugins, implants and service health.
- Where do I use it
- In the dashboard, on the Topology page's Mirror tab; agents read the same map in chat.
- When would I use it
- When you want to know what your instance can actually do right now, from real state.
- How do I use it
- You do not build it; agents read it automatically, and the Mirror tab has a Regenerate button.
QuoxCORE is the free, self-hosted platform underneath this. What is QuoxCORE
The self-model
What every agent reads before it answers.
Mirror appends a compact self-awareness summary to every system prompt. About 50 tokens, drawn from the reflection map, never from the model's imagination.
### Self-Awareness Your reflection map is available. Core: 92% | Memory: 1,247 | Agents: N | Implants: 11/14 healthy You can introspect your own capabilities when asked.
The exact injection format. Values shown are the example from the Mirror documentation; N is the live agent count, read from the entity registry at build time, never hardcoded.
Why it exists
Most AI systems have no idea what they can do.
Ask a typical assistant about its capabilities and you get one of three failure modes. It has no access to its own runtime state: no persistent self-model, no way to verify its own claims.
Hallucinate
It invents features that do not exist, because inventing plausible text is what it is built to do.
Infer
It guesses from training-data patterns, describing what systems like it usually have, not what it has.
Deflect
It retreats to vague, non-committal answers that sound safe and tell you nothing.
Mirror changes this. When CommanderQ reports 14 implants, 11 healthy, he is reading a reflection map generated from actual system state. That is 14 tracked: the 12 QuoxMind faculties plus RepoBrain and Qortex, which are separate products that report health into the same topology. The data is real, sourced from live components, and verifiable by opening the JSON.
How it is built
Four layers of self-awareness.
Each layer serves a different consumer. Together they form complete introspection.
Reflection service
Builds the map from the canonical implant registry, agents, plugins, memory and health, and caches it with a 30 second TTL. Rebuilt lazily on the next read, so it costs nothing while nobody is looking.
Prompt injection
A compact self-awareness summary appended to every system prompt, so agents know what exists before they act. Lean enough to leave the context budget alone.
Tool queries
Agents call the execution_intelligence tool to fetch the full JSON map on demand. Self-query at runtime, not hallucination.
Visual display
The Cognitive Topology view renders the map as identity, memory, capability, implant, agent and plugin cards, with the raw JSON one click away.
The artefact
One map, seven sections, all of it checkable.
The reflection map is a single JSON document with a fixed schema: identity, cognitive implants, memory, agents, plugins, capabilities and health. Every entry reports live values, and every implant carries a health score, a status and its primary metric.
It is JSON on purpose. Human-readable, so you can see exactly what the system believes about itself. Portable, so you can export it. Simple, so it needs no extra infrastructure. And verifiable, so a claim like “11 of 14 implants healthy” can be checked line by line.
See how the pieces fit →{
"version": "1.0.0",
"generatedBy": "auto | manual | plugin-event",
"identity": { "name": "CommanderQ", "role": "Multi-Agent Executive" },
"cognitiveImplants": [
{ "name": "QuoxMemory", "health": 85,
"status": "healthy", "primaryMetric": "1,247 memories" }
],
"memory": { "episodic": 847, "semantic": 234,
"entities": 89, "learned": 77, "total": 1247 },
"agents": [ { "name": "WARDEN", "active": true } ],
"plugins": [ { "name": "Advanced Memory", "enabled": true } ],
"capabilities": { "totalTools": 24, "totalWorkflows": 1340 },
"health": { "overall": 92, "status": "operational" }
}Abridged from the published schema; values are the documentation example.
Show, not just tell
The reflection map, captured live.
Not a mockup of what the Mirror tab might look like: this is the Consciousness Map and its raw JSON, captured from a running QuoxCORE organisation.
- 1An identity card, not a sloganName, role, version and a live core health percentage, read from the reflection map rather than written by hand.
- 2Implant health reported as it isRepoBrain shows unreachable here because it genuinely was at capture time. The grid reports real state, including the bad news.
- 3The agent count comes from the registryThe mesh total is read off the entity registry, not a fixed number in a diagram.
- 4A hierarchy you can inspectCommanderQ orchestrates at L0; ARCHITECT, SENTINEL, CIPHER and the rest of the L1 managers are named individually, not summarised as "agents".
Captured from the live Mirror tab on demo.quox.ai, not a mockup.
Awareness is half the answer
Knowing what you can do, without carrying all of it.
Awareness is cheap. Authority is not. An agent that is aware of hundreds of tools cannot afford to carry hundreds of tool definitions on every turn, and for years there were only three ways to handle that, all bad.
Send every tool
Every schema rides every turn. Cost scales with the catalogue, not the task, and it runs straight into provider limits: one provider caps a request at 128 tool definitions, and the day a wide agent crossed that line its governed failover died silently.
Truncate the list
Cap the tools and drop the rest. Now the platform quietly lies about what it can do, and which capabilities vanish has nothing to do with what the user asked for.
Go narrow and delegate
Small kits, routed between agents. The right instinct, and where most teams get stuck: delegation dies without awareness. An orchestrator cannot hand work to a specialist it cannot see.
The hidden assumption behind all three is that to know about a tool, an agent has to carry it. QuoxHat unbundles awareness from authority. The Mirror stays the cheap, total index of everything. A hat is the small, bounded set of tools a turn actually wears, resolved on the server and witnessed.
Carries a small manifest
Each turn resolves a hat on the server into a frozen set of tools with a cryptographic digest. The agent carries that, nothing else.
Loads depth on request
Need more than the hat holds? One governed, audited step loads a bundle, in effect from the next turn. Never a silent reach outside the manifest.
Delegates to specialists
Breadth is delegation. A specialist's own turn automatically wears its own focused hat, so handing off makes the receiving agent sharper, not blinder.
Asks before privilege
A privileged mode is never auto-selected. The agent proposes the switch; a human approves it. Authority only ever widens through a person.
Measured, not asserted
The cost stops scaling with the catalogue.
These are the collector's own estimates of tool-schema weight per turn, for the same agent on a running organisation. An unbounded turn carries about 23,790 tokens of schema before the user has said anything. Under its hat the same agent carries about 2,545. A delegated specialist carries about 362.
That is the only efficiency claim we make. Whether a tighter tool set also improves the answers is a reasonable guess we have not measured, so we do not tell you it does.
See governed execution end to end →{
"hat": "default", "source": "auto_agent_match",
"enforced": true,
"tools_known": 179, "tools_carried": 10,
"manifest_digest": "66c7504628…",
"witnessed": "ward:chain"
}Every turn's manifest is digested and witnessed in a tamper-evident chain: what an agent could do at a moment is answerable after the fact.
Freshness
Fresh when it matters, cheap when it does not.
There is no background timer burning cycles. The map is cached for 30 seconds and rebuilt lazily on the next read. Three events force an immediate rebuild, so real change is never invisible.
The Regenerate button
One click in the Mirror tab invalidates the cache directly and rebuilds the map on the spot.
Plugin enable or disable
Changing a plugin's state invalidates the cache as part of the enable and disable flow itself.
Agent registry changes
When the entity registry changes, the stale reflection goes with it. The next read rebuilds.
The guarantee: outside those triggers, the map you read is never more than 30 seconds stale.
Who reads it
Two audiences. One source of truth.
Agents and humans read the same map through different surfaces, so what the system says about itself and what you see about it can never drift apart.
What agents see
~50 tokens in every prompt, the full map on demand
- All 14 tracked implant names with live health status (12 QuoxMind faculties, plus RepoBrain and Qortex)
- Which implants are healthy, degraded, locked or offline
- Agent roster, tool count and workflow count
- Memory totals: episodic, semantic, entities, learned
- Overall health score and active service counts
- How to query deeper via the execution_intelligence tool
What users see
Cognitive Topology → Mirror tab
- Identity, memory and capability cards from live data
- The implant grid with health status for all 14 tracked implants
- Tier badges on each implant: Free, Pro, Complete
- Neuroscience labels: hippocampus, amygdala, prefrontal cortex
- Agents grouped by hierarchy level, drawn from the entity registry
- COREY agent chat for self-awareness queries
- The raw reflection JSON, expandable, with a Regenerate button
What it tracks
Fourteen implants. One canonical registry.
Every implant is modelled on a region of the brain and reports a health score, a status and its primary metric into the map.
The registry is canonical: cognitiveImplants.js is the single source of truth for the list. The reflection service, the mirror index, the context injector, the execution_intelligence tool and the topology visualiser all read that one module, so the count cannot drift between the docs and the running system.
Why it is load-bearing
The foundation of QuoxMind.
Without the Mirror, the cognitive implants are metrics nobody sees. The Smart Router delegates to agents without knowing whether their services are healthy. The Decomposer plans objectives without knowing fleet state. CommanderQ answers questions about himself by guessing.
With the Mirror, every component reads from one source of truth. The delegator can warn when implants are degraded, health checks include cognitive status, and every prompt carries live self-knowledge. Same index, every consumer.
This is functional self-awareness, not consciousness. Mirror gives the system the ability to accurately report on its own internal state. It is not sentience, and it is not simulation either: the data is real, sourced from actual components, and checkable by anyone who opens the JSON.
Where it stands
Shipped today, planned next.
- The reflection map, schema v1.0.0, generated from live system state
- The Mirror tab in Cognitive Topology, with the JSON viewer and Regenerate button
- The ~50 token self-awareness injection in every system prompt
- QuoxHat: per-turn tool manifests resolved on the server, digested and witnessed
- Two-level delegation, where a specialist's turn wears its own hat automatically
- Governed bundle loading and human-approved switching into privileged hats
- Custom implant registration, so third-party plugins can report their own health into the map
- Hat enforcement across more organisations: it runs today on our own working org plus a test org, not fleet-wide
- Live-driving one provider's mid-walk failover under an enforced hat, which is unit-tested today
Planned means not yet in the product. We state what runs and what does not; the numbers on this page are measured, and no claim about answer quality is made.
Ready when you are
Give your agents a mirror.
Mirror ships with every QuoxCORE installation as part of the QuoxMind cognitive implant suite. Install it, open the Mirror tab, and read what your system knows about itself.
Go deeper