Agent Memory Importance Scoring Prompt

This prompt is for agent developers and infrastructure engineers who need a deterministic, explainable scoring layer between agent observation and memory persistence. The core job-to-be-done is ranking memory entries by importance before storing them in a shared memory store or before evicting entries when context windows are full. It scores each memory entry across three dimensions—task relevance, recency, and uniqueness—and produces a ranked list with scores and rationale. The output is used to decide what to keep, what to compress, and what to discard, making it a critical component in any multi-agent system where shared state consistency and context budget management are operational concerns.

Use this prompt when you are building a memory write pipeline and need to assign importance scores before committing entries to a persistent or shared store. It is also appropriate as a pre-eviction scoring step when context windows are full and you need to decide which entries to drop or summarize. The prompt expects structured input: a list of memory entries, each with a timestamp, content, and optional source agent identifier. You should also provide the current task context so the model can assess task relevance accurately. The output is a JSON array of scored entries, each with a composite importance score and a breakdown of the three dimension scores plus a short rationale string. This structure makes the output machine-readable for downstream automation, such as threshold-based filtering or weighted insertion into a vector store.

Do not use this prompt for real-time retrieval ranking. That is a different problem with different latency and scoring requirements; use the Agent Memory Read with Recency and Relevance Scoring prompt instead. Also avoid this prompt when the memory entries require subjective or ethical judgment beyond task utility—importance scoring here is operational, not normative. If your system operates in a regulated domain where retention or deletion decisions have compliance implications, always add a human review step after scoring and before any destructive action. Finally, do not use this prompt as a substitute for proper context window budget allocation; pair it with the Agent Context Window Budget Allocation Prompt for a complete memory management strategy.

This prompt template is designed to be inserted into your agent's memory scoring pipeline. It takes a batch of memory entries and ranks them by importance across three dimensions: task relevance, recency, and uniqueness. The output is a structured JSON array with scores and justifications, enabling your agent to decide what to retain, what to evict, and what to prioritize during retrieval. Copy the template below and replace the square-bracket placeholders with your application's specific values.

textCopy
You are a memory importance scorer for an autonomous agent system. Your job is to evaluate a set of memory entries and assign each an importance score based on three dimensions: task relevance, recency, and uniqueness. You must return a structured JSON array with scores and brief justifications for each entry.

## INPUT
Memory entries to score:
[MEMORY_ENTRIES]

Current agent task or goal:
[CURRENT_TASK]

Active session context (optional):
[SESSION_CONTEXT]

## SCORING DIMENSIONS
For each memory entry, assign a score from 0.0 to 1.0 on each dimension:

1. **Task Relevance**: How directly does this memory support the current task? 1.0 means essential for task completion; 0.0 means completely unrelated.
2. **Recency**: How recently was this memory created or last accessed? 1.0 means within the current session; 0.0 means older than [RECENCY_THRESHOLD_HOURS] hours.
3. **Uniqueness**: How distinct is this memory from other entries? 1.0 means contains information not found elsewhere; 0.0 means fully redundant with other entries.

## OUTPUT SCHEMA
Return a JSON object with a single key "scored_entries" containing an array of objects:
{
  "scored_entries": [
    {
      "entry_id": "string",
      "task_relevance_score": 0.0,
      "recency_score": 0.0,
      "uniqueness_score": 0.0,
      "composite_score": 0.0,
      "importance_rationale": "Brief explanation of why this score was assigned, max 2 sentences.",
      "retention_recommendation": "keep" | "evict" | "archive"
    }
  ]
}

## COMPOSITE SCORE CALCULATION
composite_score = (task_relevance_score * [TASK_WEIGHT]) + (recency_score * [RECENCY_WEIGHT]) + (uniqueness_score * [UNIQUENESS_WEIGHT])
Weights must sum to 1.0. Default weights: task=0.5, recency=0.3, uniqueness=0.2.

## RETENTION RULES
- "keep": composite_score >= [KEEP_THRESHOLD]
- "archive": composite_score >= [ARCHIVE_THRESHOLD] AND composite_score < [KEEP_THRESHOLD]
- "evict": composite_score < [ARCHIVE_THRESHOLD]

## CONSTRAINTS
- Do not invent information not present in the memory entries.
- If [SESSION_CONTEXT] is empty, rely only on [CURRENT_TASK] for relevance.
- If two entries are near-duplicates, assign the lower uniqueness score to the older entry.
- Return ONLY valid JSON. No markdown fences, no commentary outside the JSON object.
- If [MEMORY_ENTRIES] is empty, return {"scored_entries": []}.

To adapt this prompt for your system, replace the placeholders with concrete values. [MEMORY_ENTRIES] should be a JSON array of memory objects, each with at least an entry_id, content, and timestamp. [CURRENT_TASK] is a string describing the agent's active goal. [SESSION_CONTEXT] can be an empty object if unavailable. The weight parameters [TASK_WEIGHT], [RECENCY_WEIGHT], and [UNIQUENESS_WEIGHT] let you tune the scoring for your domain—for example, a research agent might weight uniqueness higher, while a customer support agent might prioritize recency. The thresholds [KEEP_THRESHOLD] and [ARCHIVE_THRESHOLD] control retention decisions; start with 0.6 and 0.3 respectively and adjust based on your memory budget and observed retrieval quality.

Before deploying, validate the output against the schema. A common failure mode is the model returning a flat list instead of the scored_entries wrapper object—add a post-processing check that rejects outputs missing this key. Another failure mode is inconsistent composite scores that don't match the stated formula; consider adding a validation step that recomputes the composite and flags entries where the model's math deviates by more than 0.05. For high-stakes memory systems where eviction is irreversible, route entries scored near the threshold boundary to a human review queue or a secondary LLM judge before deletion.

The importance scoring prompt is not a standalone utility—it is a pipeline component that runs every time a new memory entry is written or an existing entry is re-evaluated. In a production multi-agent system, this prompt should be triggered automatically by the memory write path: when an agent calls write_memory or the blackboard system records a new observation, the entry is queued for scoring before it receives a retention priority and TTL. The scoring output determines where the entry lands in the retrieval index, whether it displaces lower-scored entries under budget pressure, and how aggressively it is consolidated during long-term memory compaction runs.

Wire the prompt into an async scoring worker that pulls unscored entries from a queue, calls the model with the prompt template, and writes the scored result back to the memory store. The worker must enforce a schema contract: the model output must parse into a JSON object with importance_score (0.0–1.0 float), dimensions (an object with task_relevance, recency, and uniqueness sub-scores), and rationale (a short string). Use a strict JSON mode or structured output API if available. If the model returns unparseable output, apply a repair prompt that feeds the raw output and the expected schema back to the model for correction. After two repair attempts, log the failure, assign a default low score (0.1), and flag the entry for human review if the memory store is in a regulated or high-stakes domain.

Validation checks should run post-parse: confirm that importance_score is a weighted combination of the dimension sub-scores (within a 0.1 tolerance), that no sub-score exceeds 1.0, and that the rationale is non-empty and references the actual memory content rather than a generic template. For evaluation, maintain a golden set of 50–100 memory entries with human-annotated importance scores across your three dimensions. Run the prompt against this set on every prompt version change and flag regressions where the mean absolute error exceeds 0.15 or where task-relevant entries are scored below 0.3. Log every scoring call with the memory entry ID, model version, prompt version, raw score, and validation pass/fail status to your observability pipeline. This trace data is essential for debugging retrieval failures—when an agent misses critical context, you can check whether the entry was scored too low and adjust the prompt or dimension weights accordingly.

Model choice matters for this workload. The prompt requires consistent numeric judgment across diverse memory types (facts, observations, plans, user preferences), so prefer models with strong instruction-following and calibration. Smaller models often drift toward mid-range scores (0.4–0.6) for everything, which defeats the purpose of importance-based retention. If you observe score compression, add few-shot examples to the prompt that demonstrate clear score separation across the full 0.0–1.0 range. For high-throughput systems, consider batching unscored entries into a single call with a structured array output to reduce API overhead, but keep batch sizes under 20 entries to avoid attention dilution. Do not use this prompt for real-time retrieval scoring—that requires a separate, lighter-weight relevance prompt optimized for latency, not the multi-dimensional importance analysis this prompt provides.