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 Brain2, 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.
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 Brain2)
- 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
- Cache invalidation on plugin enable and disable and on agent registry changes
- Full-map queries through the execution_intelligence tool
- The canonical implant registry all five consumers read from
- Custom implant registration, so third-party plugins can report their own health into the map
- Configurable schema sections for teams that want to extend what the system reflects on
Planned means not yet in the product. The schema is fixed in the current release.
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