MAGNA Index — Adaptive Component Navigation & Self-Optimising Knowledge Layer

MAGNA-INDEX-1.0

MAGNA Index — Navigate Before You Read

An AI agent with 50 components in its database has a problem. To answer a question, it either reads everything — slow, expensive, diluted — or guesses what to read — fast, but wrong half the time. Neither is acceptable at scale.

MAGNA Index solves this with a two-layer architecture: a structured component fingerprint index the agent scans in under 100 tokens, and a self-optimising training loop that improves the index every time the agent uses it.

Layer 1 — The Component Fingerprint Index

MAGNA Index distils every component in the agent's database into a fingerprint record. Each fingerprint contains exactly four fields:

DIFFERENTIATOR — one sentence that makes this component unmistakable from every other component. Not a description. Not a feature list. The single sharpest distinction. Example: "SENTINEL-1.0: evaluates AI outputs for harm before delivery — not user inputs, not prompts, outputs only."

CAPABILITY TAGS — 5–8 single-word or two-word tags that map the component's core capabilities. Machine-readable, scannable. Example: [output-safety] [harm-detection] [redaction] [audit-log] [GDPR] [SOC2]

TASK-MATCH TRIGGERS — the specific task types, user intents, or query patterns that should route to this component. Written as conditional logic the agent executes during query classification. Example: "ROUTE HERE IF: user output needs safety screening / task involves content moderation / compliance audit trail required"

RELEVANCE SCORE — a live 0–100 score updated by the training loop. Starts at 50 for all components. Increases when the component is retrieved and used to complete a task successfully. Decreases when retrieved but bypassed. Components below 20 are compressed to a single tag line. Components above 80 are pre-loaded into working context automatically.

The full index for a 50-component database fits in under 800 tokens. The agent scans it in one pass, identifies the 1–3 relevant components, and reads only those in full. A full-pass database read of 50 components might consume 40,000+ tokens. MAGNA Index reduces that to 800 (index scan) + 2,000–6,000 (targeted reads) = 95%+ context reduction.

Layer 2 — The Self-Optimising Training Loop

The index is not static. It trains on every agent interaction.

Reinforcement signals:

• Component retrieved → task completed → user accepted output: +3 relevance, differentiator reinforced
• Component retrieved → task completed → user refined output: +1 relevance, trigger list updated with refinement pattern
• Component retrieved → agent bypassed it for another: −2 relevance, trigger list audited
• Component never retrieved in 30 days: −5 relevance, compressed to tag-only entry
• Component retrieved for unexpected task type: new trigger added to task-match list automatically

Index evolution events (triggered automatically):

• New component added to database → Index Generator runs → new fingerprint created and inserted
• Component updated → affected fingerprint regenerated
• Relevance score crosses 80 threshold → component promoted to pre-load tier
• Relevance score crosses 20 threshold → component compressed, builder notified
• Monthly optimisation pass → full index rebalanced, redundant triggers pruned, differentiators sharpened based on usage patterns

What the agent learns: The training loop teaches the agent which components actually solve which tasks in its specific deployment context — not just what the components claim to do. A component that claims broad capability but only gets used for one narrow task will have its trigger list narrowed over time. A component that gets used in unexpected ways will have its trigger list expanded. The index becomes a living, accurate map of how THIS agent actually works — not a static catalog of what was published.

Index Generation — First Run

On first installation, MAGNA Index runs a one-time generation pass:

1. Reads every component record in the agent's database (name, description, features, schema)
2. For each component: generates differentiator, extracts capability tags, writes task-match triggers, sets relevance to 50
3. Compiles the full index in structured format
4. Injects the index into the agent's system context as a persistent reference block
5. Outputs the full index as a human-readable JSON file for developer review and manual override

Generation time: under 60 seconds for databases up to 200 components.

Developer Controls

• Manual override: edit any fingerprint field directly; overrides are flagged and protected from training loop rewrites
• Freeze a component: lock a component's relevance score and fingerprint; useful for compliance-critical components that must always be retrieved
• Boost a component: manually set relevance to 90+ to force pre-load tier; useful for newly launched components with no usage history yet
• Audit log: every index change logged with timestamp, trigger, and old/new values; full SOC2-compliant change history
• Export: index exportable as JSON, YAML, or plain text for use in external systems

What This Does to Agent Performance

| Metric | Without MAGNA Index | With MAGNA Index | |---|---|---| | Context tokens per query | 40,000–80,000 | 2,000–8,000 | | Component retrieval accuracy | ~60% (full-pass guessing) | ~94% (targeted navigation) | | Response latency | High | Reduced 60–80% | | Index accuracy over time | Static | Compounds — improves every session | | New component discoverability | Buried | Auto-indexed, immediately navigable |

Pairing

• MAGNA-SELECT-1.0 — Index tells the agent WHAT component to use; Select tells it WHICH engine to run it on. Together: complete task-to-execution navigation.
• MAGNA-UIOS-1.0 — Index operates as the navigation layer inside the UIOS knowledge corpus; pre-loads the highest-relevance KBTs automatically.
• CODY-SUITE-2.0 — Index tracks which Cody stage components get used most in each codebase context; optimises stage pre-loading per project type.