Sigma Runtime Standard - Public Specification Notice
This document is part of the Sigma Runtime Standard (SRS) public specification layer.Specification License: CC BY 4.0.
Implementation Safe Harbor: independent implementation permitted under public SRS/SRIP terms.
Machine-readable artifacts: Apache License 2.0 where explicitly marked.
Marks / Certification: governed by Sigma Marks and Certification Policy.
Proprietary Runtime Assets: not licensed by this SRIP.Independent implementations of public SRS/SRIP normative requirements are welcome under the public specification terms.
Product assets, protected Sigma marks, official certification, compatibility badges, CC BY-NC commercial use, and patent commitments use the relevant policy or explicit covenant. Independent implementation, attribution, or citation does not imply certification, endorsement, partnership, official compatibility, or permission to use Sigma marks as product identity.
Runtime-Governed Semantic Recall, Optional External Retrieval, and Structured Memory Injection
| Field | Value |
|---|---|
| SRIP | SRIP-14 |
| Title | Retrieval and Memory Integration Layer (RMI) |
| Version | Public Draft v0.3 |
| Status | Active Proposal / Partial Implementation |
| Date | 2026-05-20 |
| Authors / Contributors | Sigma Stratum Research Group (SSRG) |
| Owning Layer | Memory / Retrieval / Runtime Governance |
| Parent Specs | SRIP-09, SRIP-11 |
| Related Specs | SRIP-01, SRIP-03, SRIP-04, SRIP-06, SRIP-07, SRIP-10, SRIP-12, SRIP-13 |
| Specification License | CC BY 4.0 |
| Implementation Safe Harbor | Independent implementation permitted under public SRS/SRIP terms |
| Machine-Readable Artifacts | Apache 2.0 where explicitly marked |
| Marks / Certification | Governed by Sigma Marks and Certification Policy |
| Proprietary Runtime Assets | Not licensed by this SRIP |
| Independent Implementation | Permitted under the public specification terms |
| Commercial Runtime Boundary | Relevant policy or explicit covenant for protected Sigma marks, official certification, managed deployment, white-label, resale, CC BY-NC commercial use, and patent commitments |
| Information Class | Open |
| Change Class | SRS-only |
| Normative Status | Defines the RMI contract for runtime-governed recall, bounded memory injection, provenance, compression, and optional external retrieval. It does not require a specific vector database, embedding model, or provider. |
| Conformance Level | Partial Conformance / Bounded Implementation |
| SRD Synchronization Action | Completed in /srd/memory.md and /srd/attractors.md. |
| Release Alignment Status | aligned |
Independent implementations of the public normative requirements in this SRIP are welcome under the applicable public specification terms.
No Sigma commercial runtime license is needed solely because an independent implementation follows those public normative requirements.
Product assets, protected Sigma marks, official certification, compatibility badges, CC BY-NC commercial use, and patent commitments use the relevant policy or explicit covenant. Independent implementation, attribution, or citation does not imply certification, endorsement, partnership, official compatibility, or permission to use Sigma marks as product identity.
SRIP-14 defines the Retrieval and Memory Integration Layer (RMI) for Sigma Runtime.
RMI governs how runtime-owned memory, semantic recall, compression, provenance,
and optional external retrieval are:
Its core principle remains:
Retrieval may be external.
Memory must remain runtime-governed.
RMI exists so that recall strengthens continuity and reasoning instead of
becoming an uncontrolled prompt-expansion path.
Naive RAG architectures commonly collapse into this pattern:
user input -> retrieve chunks -> append chunks to prompt -> generate
That pattern creates several failure modes:
Sigma Runtime requires recall to be governed by runtime state, not by raw
search output.
SRIP-14 does not:
SRIP-14 defines the normative contract for retrieval-governed memory
integration.
Bounded implementations may satisfy parts of this contract before full
conformance is complete. Typical bounded conformance may include:
Full conformance requires explicit retrieval-governance semantics across
internal and optional external retrieval surfaces, with sufficient provenance,
auditability, and interoperability with SRIP-09, SRIP-11, and SRIP-15 when
retrieval is used as a perturbation source.
| Term | Definition |
|---|---|
| Retrieval Source | External or internal system capable of returning candidate knowledge records. |
| External Retrieval Source | Third-party API, vector DB, document service, search system, or partner knowledge backend. |
| Internal Semantic Store | Runtime-owned semantic recall substrate containing embeddings, summaries, hashes, and scoped metadata for the active runtime/session layer. |
| Structural Memory Store | Runtime-owned lineage, graph, topology, attractor, and temporal memory substrate as defined by SRIP-09 and SRIP-11. |
| Retrieval Decision | Runtime decision about whether recall is needed for the current turn. |
| Query Shaping | Transforming user intent and runtime state into bounded recall queries. |
| Retrieval Envelope | Limits applied to recall: scope, result count, confidence, freshness, and semantic load budget. |
| Retrieved Evidence | Candidate records returned by retrieval sources. |
| Recall Compression | Compression of retrieved evidence into structured runtime state. |
| Memory Injection | Controlled insertion of compressed recall into interpretation or reasoning layers. |
| Source Provenance | Metadata identifying origin, timestamp, scope, confidence, and retrieval path. |
| Memory Resolution Snapshot | Runtime summary of what recall was considered, injected, suppressed, or degraded for a turn. |
| Perturbation Retrieval | Optional retrieval mode that provides exploratory contrast or adjacent signal under SRIP-15 control, without treating retrieved evidence as authoritative memory. |
RMI sits inside the canonical runtime loop, primarily during interpretation and
pre-generation control:
User Input
-> State Ingestion
-> Interpretation Pass
-> Retrieval Decision
-> Query Shaping
-> Internal Recall and/or Optional External Retrieval
-> Recall Compression
-> Structured Memory Injection
-> Memory Resolution Snapshot
-> Stabilization / Control
-> Generation
-> Output Validation
-> Field Update
RMI is not a direct prompt-append layer.
It is a runtime-governed semantic recall layer.
Bounded implementations may realize this layer through internal semantic
recall, nucleus anchoring, retrieval filtering, checkpoint-aware bounded
recovery, or other runtime-governed memory integration strategies.
SRIP-14 permits three storage levels, but their maturity need not be equal in
every implementation.
External storage may include:
External retrieval is allowed by SRIP-14, but it is not required for minimum
conformance.
The runtime should maintain its own semantic store for:
Bounded implementations may realize this through runtime-owned semantic memory,
checkpoint-aware bounded state, and memory-resolution diagnostics.
For full SRIP-14 alignment with SRIP-09 and SRIP-11, the runtime should
maintain or integrate with a structural memory store containing:
Bounded implementations may realize this through graph-like lineage,
compression topology, or equivalent structural machinery. Full SRIP-09
structural-memory conformance remains a stronger target than minimum SRIP-14
conformance.
RMI must decide whether retrieval is needed before invoking internal or
external recall.
Retrieval SHOULD be triggered when:
Retrieval SHOULD NOT be triggered when:
Retrieval should remain runtime-mediated rather than automatic prompt stuffing.
Queries must be shaped by runtime state before dispatch.
Minimum shaping inputs are:
Bounded implementations may realize query shaping through session-scoped recall,
phase-aware filters, nucleus anchoring, recall suppression, and checkpoint-aware
memory resolution.
Query shaping must not leak hidden policy, private memory, or unrelated session
context into external retrieval systems.
Every retrieval request must carry a bounded retrieval envelope.
Minimum shape:
{
"source": "internal_or_external",
"scope": "session|agent|workspace|public",
"max_results": 5,
"max_tokens": 1200,
"freshness_required": false,
"confidence_floor": 0.65,
"session_id": null,
"participant_scope": null,
"provenance_required": true
}
The envelope exists to prevent uncontrolled recall expansion.
Bounded implementations may enforce retrieval envelopes through result limits,
compression budgets, recall suppression, fallback narrowing, and scope-aware
constraints.
Retrieved evidence must be compressed before injection.
Recall compression should produce structured runtime state, not raw prompt
walls.
Recommended compressed form:
{
"facts": [],
"constraints": [],
"source_notes": [],
"conflicts": [],
"confidence": 0.0,
"provenance": [],
"memory_scope": "session|agent|workspace|public"
}
Compression must preserve:
Compression must remove:
Bounded implementations may realize compression through semantic summarization,
compressed memory artifacts, topology-aware compression, fact layers, and
memory-resolution outputs rather than raw recall dumps.
Compressed recall may be injected only into controlled runtime layers.
Allowed injection targets:
Disallowed:
Bounded implementations should follow this model by integrating memory through
runtime state, bounded summaries, or structured recall artifacts rather than raw
retrieved text walls.
Every retrieved item should carry provenance when possible.
Minimum provenance fields:
If provenance is missing, the runtime must downgrade confidence instead of
silently treating evidence as verified.
Bounded implementations may realize provenance through record IDs, semantic
hashes, phase markers, scope markers, confidence signals, and memory-resolution
diagnostics.
SRIP-09 defines what memory records are, how lineage is preserved, and how
structural memory should eventually be traced.
SRIP-14 defines:
SRIP-14 depends on SRIP-09 normatively, but does not require every
implementation to satisfy full structural-memory conformance before bounded
retrieval-governance behavior exists.
SRIP-11 supplies the topology and compression layer that makes SRIP-14 richer
than flat semantic similarity.
Relevant SRIP-11-compatible contributions may include topology-aware
compression, graph propagation, phase-aware retrieval compatibility, anchor
buffers, fact extraction, and adaptive compression parameters.
RMI must respect prompt-density, throughput, and degradation constraints.
If recall exceeds the current semantic load budget, the runtime must be able
to:
Recall should reduce uncertainty without causing prompt-density collapse.
RMI must preserve identity and participant boundaries.
Retrieval must not:
Bounded implementations should apply recall filtering and scoped memory
sanitization. Full RIS-aware governance of optional external retrieval remains
an advanced conformance target.
RMI should expose authorized diagnostics without leaking private content or
hidden policy text.
Diagnostics must remain audit-safe and must not expose private memory or hidden
control text to normal user-facing output.
A runtime minimally conforms to SRIP-14 when:
A runtime more fully conforms when it additionally:
| Capability | Status |
|---|---|
| External retrieval API support | Optional / future baseline |
| Runtime-controlled retrieval decision | Baseline |
| Query shaping | Baseline / evolving |
| Recall compression | Baseline / evolving |
| Structured memory injection | Baseline / evolving |
| Internal semantic store | Partial / evolving |
| Structural memory store | Partial / evolving |
| Attractor-aware / phase-aware retrieval | Partial / advanced |
| Retrieval audit telemetry | Partial / evolving |
| Cross-session retrieval governance | Partial / evolving |
RAG gives access to knowledge.
Memory gives that knowledge a place in the runtime.
SRIP-14 exists to ensure that retrieval strengthens cognition instead of
flooding it.
External sources may answer what is known.
Sigma Runtime must still decide what is relevant, bounded, scoped, coherent,
and safe to inject.
RMI may be used not only for semantic recall, but also as a controlled source of
divergence when the runtime detects over-convergence, attractor fixation, or
insufficient behavioral variance.
This mode treats retrieval as a perturbation operator, not as authoritative
knowledge injection.
Perturbation-oriented retrieval is optional. It is valid only when it remains
inside the same runtime-governed envelope as standard recall.
Perturbation-oriented retrieval should be considered when:
Perturbation must not be triggered when:
When operating in perturbation mode:
Perturbation retrieval must not bypass query shaping, retrieval envelopes,
provenance, compression, or memory injection rules defined elsewhere in
SRIP-14.
Retrieved data in perturbation mode must be treated as:
non-authoritative exploratory signal
It must not be treated as:
ground truth or required context
The runtime must:
Perturbation retrieval must follow standard RMI constraints:
Injection should:
Perturbation behavior must be governed by the runtime control stack:
If a conflict occurs, perturbation must yield to the higher-priority control
layer.
The runtime should provide a path back to stable operation when:
In such cases, the runtime must:
Perturbation usage should be observable through authorized diagnostics:
These diagnostics must not leak hidden control text, private memory, or
proprietary implementation detail into user-facing output.
Retrieval is not only a tool for remembering.
In controlled contexts, it can also be a tool for changing trajectory.
Recall reinforces what is known.
Perturbation reveals what is possible.