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 injects a compact multi-section summary into each agent prompt: a few hundred tokens, inside a 1,200 token budget for the whole self-knowledge block, 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.
An illustrative sample of the injection format. The real block is a longer sectioned summary built server-side; values shown are examples, and N stands for the agent count read when the map is built.
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 server-side, per organisation, from each owning service's own data, and caches it for 30 seconds. Rebuilt lazily on the next read, so it costs nothing while nobody is looking.
Prompt injection
A compact multi-section Mirror summary injected into each agent prompt, so agents know what exists before they act. A few hundred tokens, inside a 1,200 token budget for the whole self-knowledge block.
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, health, memory, capabilities, plugins, implants and codebase fabric. Every entry reports live values, and every implant carries a status and its primary metric, plus a health score where the service reports one.
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": "2.0.0",
"generatedBy": "server",
"identity": { "name": "CommanderQ", "role": "Multi-Agent Executive" },
"health": { "overall": 92, "status": "operational" },
"memory": { "total": 1247, "entities": 89, "relations": 310 },
"capabilities": { "tools": 24, "workflows": 1340, "agents": { "count": 12 } },
"plugins": [ { "name": "Advanced Memory", "enabled": true } ],
"implants": [
{ "name": "QuoxMemory", "health": 85,
"status": "healthy", "primaryMetric": "1,247 memories" }
],
"codebaseFabric": { "..." }
}Abridged and illustrative; values are examples, not a live read.
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 server caches the map for 30 seconds and rebuilds it lazily on the next read. Three events refresh the dashboard's local view, and the server map follows within about 30 seconds.
The Regenerate button
One click in the Mirror tab clears the dashboard's copy and re-reads the map from the server. The server rebuilds when its 30 second cache has expired.
Plugin enable or disable
Changing a plugin's state clears the dashboard's copy as part of the enable and disable flow. The server map follows within about 30 seconds.
Agent registry changes
When the entity registry changes, the dashboard's copy is cleared. The server map follows within about 30 seconds.
The server refreshes at most every 30 seconds; a read just past that may return the previous map while it rebuilds.
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
A compact summary 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: memories, entities, relations
- 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 v2.0.0, built server-side from live system state
- The Mirror tab in Cognitive Topology, with the JSON viewer and Regenerate button
- The compact Mirror summary injected into each agent prompt, inside a 1,200 token self-knowledge budget
- 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