# PRD-108 — Complete Algorithm Specification

**Inventor:** Gerard Kavanagh **Date:** March 21, 2026 **Implementation:** `orchestrator/modules/context/adapters/vector_field.py` **Git Evidence:** Commits `674474722` and `f2e4a4e6f`

This document describes every algorithm, formula, data structure, and decision step in the Resonance Field Coordination system. Each section includes the mathematical definition, pseudocode, implementation reference, and rationale.

***

## Table of Contents

1. [System Constants](#1-system-constants)
2. [Data Structures](#2-data-structures)
3. [Algorithm 1: Field Creation](#3-algorithm-1-field-creation)
4. [Algorithm 2: Pattern Injection](#4-algorithm-2-pattern-injection)
5. [Algorithm 3: Content Deduplication](#5-algorithm-3-content-deduplication)
6. [Algorithm 4: Semantic Query with Resonance Scoring](#6-algorithm-4-semantic-query-with-resonance-scoring)
7. [Algorithm 5: Temporal Decay](#7-algorithm-5-temporal-decay)
8. [Algorithm 6: Access Boost](#8-algorithm-6-access-boost)
9. [Algorithm 7: Resonance Score Computation](#9-algorithm-7-resonance-score-computation)
10. [Algorithm 8: Archival Filtering](#10-algorithm-8-archival-filtering)
11. [Algorithm 9: Hebbian Reinforcement (Single)](#11-algorithm-9-hebbian-reinforcement-single)
12. [Algorithm 10: Hebbian Reinforcement (Batch with Co-Access)](#12-algorithm-10-hebbian-reinforcement-batch-with-co-access)
13. [Algorithm 11: Field Stability Measurement](#13-algorithm-11-field-stability-measurement)
14. [Algorithm 12: Field Destruction](#14-algorithm-12-field-destruction)
15. [Algorithm 13: Mission Lifecycle Integration](#15-algorithm-13-mission-lifecycle-integration)
16. [Algorithm 14: A/B Backend Selection](#16-algorithm-14-ab-backend-selection)
17. [Algorithm 15: Experiment Instrumentation](#17-algorithm-15-experiment-instrumentation)
18. [Complete Query Pipeline (End-to-End)](#18-complete-query-pipeline-end-to-end)
19. [Complete Inject Pipeline (End-to-End)](#19-complete-inject-pipeline-end-to-end)
20. [Proof Results](#20-proof-results)

***

## 1. System Constants

All values are configurable via environment variables. Defaults are tuned for mission durations of 1-48 hours.

```
FIELD_EMBEDDING_DIM     = 2048      # Dimensions of semantic embedding vectors
FIELD_DECAY_RATE        = 0.1       # lambda (λ) — exponential decay rate
FIELD_REINFORCE_BONUS   = 0.05      # Per-access strength multiplier increment
FIELD_REINFORCE_CAP     = 2.0       # Maximum access boost multiplier
FIELD_ARCHIVAL_THRESHOLD = 0.05     # Below this decayed strength, pattern is filtered
FIELD_BOUNDARY_PERMEABILITY = 1.0   # Injection strength scaling factor (0.0 to 1.0)
```

**Derived constants:**

```
Half-life = ln(2) / λ = 0.693 / 0.1 = 6.93 hours
Time to archival (no access) = ln(S₀ / threshold) / λ
  For S₀=1.0, threshold=0.05:  ln(20) / 0.1 = 29.96 hours
Max access boost accesses = (cap - 1.0) / bonus = (2.0 - 1.0) / 0.05 = 20 accesses
```

**Implementation:** `orchestrator/config.py` lines 393-401

***

## 2. Data Structures

### 2.1 Pattern (stored in Qdrant)

Each knowledge pattern is a point in a Qdrant vector collection.

```
Pattern {
    id:             UUID        — Unique identifier (v4 UUID string)
    vector:         float[2048] — Semantic embedding of "{key}: {value}"
    payload: {
        agent_id:       int         — ID of the agent that created this pattern
        key:            string      — Semantic label (e.g., "compliance_deadline")
        value:          string      — Knowledge content (up to 4000 characters)
        strength:       float       — Current strength (mutated by co-access bonus)
        created_at:     string      — ISO-8601 UTC timestamp of creation
        last_accessed:  string      — ISO-8601 UTC timestamp of most recent access
        access_count:   int         — Number of times retrieved in query results
        content_hash:   string      — SHA-256 hex digest of "{key}: {value}"
    }
}
```

**Implementation:** `vector_field.py` lines 139-155

### 2.2 Query Result (returned to agents)

```
QueryResult {
    id:                 string  — Pattern UUID
    key:                string  — Pattern semantic label
    value:              string  — Pattern content
    score:              float   — Resonance score (Algorithm 7)
    agent_id:           int     — Contributing agent ID
    decayed_strength:   float   — Current S(t) after decay + access boost
    cosine_similarity:  float   — Raw cosine similarity from vector search
}
```

**Implementation:** `vector_field.py` lines 196-204

### 2.3 Stability Report

```
StabilityReport {
    stability:          float   — Composite convergence metric [0.0, ~1.4]
    pattern_count:      int     — Total patterns in field
    avg_strength:       float   — Mean decayed strength across all patterns
    organization:       float   — Strength distribution uniformity [0.0, 1.0]
    active_patterns:    int     — Patterns above archival threshold
    decayed_patterns:   int     — Patterns below archival threshold
}
```

**Implementation:** `vector_field.py` lines 254-261

### 2.4 Field Collection (Qdrant)

```
Collection name:    "field_{context_id}"
Vector config:      size=2048, distance=COSINE
Payload indexes:
    content_hash:   KEYWORD     — For deduplication lookups
    agent_id:       INTEGER     — For agent-filtered queries (future)
    created_at:     KEYWORD     — For temporal range queries (future)
```

**Implementation:** `vector_field.py` lines 75-93

### 2.5 Metric Event (Instrumentation)

```
FieldMetricEvent {
    timestamp:          string      — ISO-8601 UTC
    operation:          string      — "create" | "inject" | "query" | "destroy"
    context_id:         string      — Field UUID
    agent_id:           int         — Acting agent
    latency_ms:         float       — Wall-clock duration
    pattern_key:        string?     — For inject operations
    query_text:         string?     — For query operations
    results_returned:   int?        — For query operations
    top_score:          float?      — Highest resonance score in results
}
```

**Implementation:** `instrumentation.py` lines 17-31

***

## 3. Algorithm 1: Field Creation

**Purpose:** Initialize a shared semantic field for a multi-agent mission.

**Input:**

* `team_agent_ids: list[int]` — IDs of agents participating in the mission
* `initial_data: dict[str, str]?` — Optional seed data (e.g., mission goal)

**Output:**

* `field_id: string` — UUID identifying the created field

**Steps:**

```
FUNCTION create_context(team_agent_ids, initial_data):
    1. field_id ← generate UUID v4
    2. collection_name ← "field_" + field_id
    3. CREATE Qdrant collection:
         name = collection_name
         vector_size = FIELD_EMBEDDING_DIM (2048)
         distance_metric = COSINE
    4. CREATE payload indexes on collection:
         "content_hash" → KEYWORD type
         "agent_id" → INTEGER type
         "created_at" → KEYWORD type
    5. IF initial_data is not empty:
         FOR EACH (key, value) in initial_data:
             CALL inject(field_id, key, value, agent_id=0, strength=1.0)
    6. RETURN field_id
```

**Rationale:**

* UUID prevents collision across concurrent missions
* Payload indexes enable O(1) dedup lookups and filtered queries
* `agent_id=0` for seed data marks it as system-provided, not agent-generated
* Each mission gets its own collection for isolation and clean destruction

**Implementation:** `vector_field.py` lines 67-104

***

## 4. Algorithm 2: Pattern Injection

**Purpose:** An agent adds a knowledge pattern to the shared field.

**Input:**

* `context_id: string` — Field UUID
* `key: string` — Semantic label
* `value: string` — Knowledge content
* `agent_id: int` — Contributing agent
* `strength: float` — Injection strength (default 1.0)

**Output:** None (side effect: pattern added to field)

**Steps:**

```
FUNCTION inject(context_id, key, value, agent_id, strength):
    1. content ← key + ": " + value
    2. content_hash ← SHA-256(content) as hex string
    3. existing ← CALL _find_by_hash(context_id, content_hash)  [Algorithm 3]
    4. IF existing is not None:
         CALL _reinforce_single(context_id, existing.id)  [Algorithm 9]
         RETURN  // Dedup: reinforce instead of duplicate
    5. embedding ← CALL embedding_model.generate(content)  // 2048-dim float vector
    6. effective_strength ← strength × FIELD_BOUNDARY_PERMEABILITY
    7. now ← current UTC timestamp as ISO-8601
    8. point_id ← generate UUID v4
    9. UPSERT into Qdrant collection "field_{context_id}":
         id = point_id
         vector = embedding
         payload = {
             agent_id: agent_id,
             key: key,
             value: value,
             strength: effective_strength,
             created_at: now,
             last_accessed: now,
             access_count: 0,
             content_hash: content_hash
         }
```

**Rationale:**

* Content string is `"{key}: {value}"` — the key provides semantic context for the embedding
* SHA-256 dedup prevents the same knowledge from cluttering the field
* Reinforce-on-collision means repeated injection strengthens existing knowledge
* Boundary permeability allows future experimentation with injection barriers
* `access_count` starts at 0 — strength builds only through actual usage

**Implementation:** `vector_field.py` lines 116-156

***

## 5. Algorithm 3: Content Deduplication

**Purpose:** Check if identical content already exists in the field.

**Input:**

* `context_id: string` — Field UUID
* `content_hash: string` — SHA-256 hex digest

**Output:**

* `existing_point` or `None`

**Steps:**

```
FUNCTION _find_by_hash(context_id, content_hash):
    1. collection ← "field_" + context_id
    2. results ← Qdrant SCROLL with filter:
         MUST match: payload["content_hash"] == content_hash
         LIMIT 1
    3. IF results is not empty:
         RETURN results[0]
    4. RETURN None
```

**Rationale:**

* SHA-256 is collision-resistant — two different contents will not produce the same hash
* Payload index on `content_hash` makes this an O(1) lookup, not a full scan
* Returns the full point so the caller can access its ID for reinforcement

**Implementation:** `vector_field.py` lines 283-293

***

## 6. Algorithm 4: Semantic Query with Resonance Scoring

**Purpose:** An agent queries the field for relevant knowledge. This is the core algorithm.

**Input:**

* `context_id: string` — Field UUID
* `query: string` — Natural language query
* `agent_id: int` — Querying agent
* `top_k: int` — Maximum results to return (default 10)

**Output:**

* `results: list[QueryResult]` — Ranked by resonance score, descending

**Steps:**

```
FUNCTION query(context_id, query, agent_id, top_k):
    1. query_embedding ← CALL embedding_model.generate(query)  // 2048-dim

    2. raw_results ← Qdrant QUERY_POINTS:
         collection = "field_" + context_id
         query_vector = query_embedding
         limit = top_k × 3  // Over-fetch to compensate for archival filtering

    3. now ← current UTC timestamp
    4. scored ← empty list

    5. FOR EACH hit in raw_results:
         a. payload ← hit.payload
         b. last_accessed ← parse ISO-8601(payload["last_accessed"])
         c. age_hours ← (now - last_accessed) in hours
         d. decayed_strength ← CALL _compute_decayed_strength(  [Algorithm 5+6]
              payload["strength"], age_hours, payload["access_count"]
            )
         e. IF decayed_strength < FIELD_ARCHIVAL_THRESHOLD:  [Algorithm 8]
              CONTINUE  // Skip archived patterns
         f. resonance ← (hit.score)² × decayed_strength  [Algorithm 7]
         g. APPEND to scored: {
              id: hit.id,
              key: payload["key"],
              value: payload["value"],
              score: resonance,
              agent_id: payload["agent_id"],
              decayed_strength: decayed_strength,
              cosine_similarity: hit.score
            }

    6. SORT scored by score DESCENDING
    7. top_results ← scored[0 : top_k]

    8. accessed_ids ← [r.id for r in top_results]
    9. IF accessed_ids is not empty:
         CALL _reinforce_batch(context_id, accessed_ids)  [Algorithm 10]

    10. RETURN top_results
```

**Rationale:**

* Over-fetch at 3× ensures enough results survive archival filtering
* Decay is computed at query time, not stored — patterns are never destructively aged
* Resonance scoring (Algorithm 7) combines semantic relevance with temporal strength
* Hebbian reinforcement (step 9) is a side effect of querying — reading strengthens
* Results include both resonance score and raw cosine for transparency

**Implementation:** `vector_field.py` lines 160-221

***

## 7. Algorithm 5: Temporal Decay

**Purpose:** Compute how much a pattern's strength has diminished since last access.

**Mathematical Definition:**

```
decay(t) = e^(-λt)

where:
    λ = FIELD_DECAY_RATE (default 0.1)
    t = age in hours since last access
```

**Decay curve:**

```
t=0h:   e^(-0.1 × 0)  = 1.0000  (100% — just accessed)
t=1h:   e^(-0.1 × 1)  = 0.9048  (90%)
t=3h:   e^(-0.1 × 3)  = 0.7408  (74%)
t=7h:   e^(-0.1 × 7)  = 0.4966  (50% — half-life)
t=12h:  e^(-0.1 × 12) = 0.3012  (30%)
t=24h:  e^(-0.1 × 24) = 0.0907  (9%)
t=48h:  e^(-0.1 × 48) = 0.0082  (0.8%)
t=72h:  e^(-0.1 × 72) = 0.0007  (0.07%)
```

**Key property:** Half-life = ln(2) / λ = 6.93 hours

**Verified:** Test 2 in stress tests — fresh pattern 1.0000, 24h-old pattern 0.0907

**Implementation:** `vector_field.py` line 277

***

## 8. Algorithm 6: Access Boost

**Purpose:** Frequently accessed patterns resist decay.

**Mathematical Definition:**

```
B(n) = min(1.0 + n × FIELD_REINFORCE_BONUS, FIELD_REINFORCE_CAP)

where:
    n = access_count (number of times retrieved in query results)
    FIELD_REINFORCE_BONUS = 0.05 (5% per access)
    FIELD_REINFORCE_CAP = 2.0 (maximum 2× multiplier)
```

**Boost curve:**

```
n=0:    min(1.0 + 0 × 0.05, 2.0)  = 1.00  (no boost)
n=1:    min(1.0 + 1 × 0.05, 2.0)  = 1.05  (+5%)
n=5:    min(1.0 + 5 × 0.05, 2.0)  = 1.25  (+25%)
n=10:   min(1.0 + 10 × 0.05, 2.0) = 1.50  (+50%)
n=15:   min(1.0 + 15 × 0.05, 2.0) = 1.75  (+75%)
n=20:   min(1.0 + 20 × 0.05, 2.0) = 2.00  (+100% — cap reached)
n=100:  min(1.0 + 100 × 0.05, 2.0)= 2.00  (still capped)
```

**Key property:** Cap at 2.0 prevents runaway reinforcement

**Verified:** Test 3 in stress tests — 10 accesses = strength 1.50, 0 accesses at 6h = 0.55

**Implementation:** `vector_field.py` lines 278-280

***

## 9. Algorithm 7: Resonance Score Computation

**Purpose:** Combine semantic relevance with temporal strength into a single ranking score.

**Mathematical Definition:**

```
R(pattern, query) = cos(θ)² × S(t)

where:
    cos(θ) = cosine similarity between query embedding and pattern embedding
    S(t)   = decayed strength = S₀ × decay(t) × B(n)  [Algorithms 5 + 6]
    S₀     = stored strength value
    t      = age in hours since last access
    n      = access count
```

**Full expansion:**

```
R = cos(θ)² × S₀ × e^(-λt) × min(1.0 + n × 0.05, 2.0)
```

**Why squared cosine:**

| Cosine Similarity      | Raw  | Squared | Effect                |
| ---------------------- | ---- | ------- | --------------------- |
| 0.95 (highly relevant) | 0.95 | 0.9025  | Preserved (95% → 90%) |
| 0.80 (relevant)        | 0.80 | 0.6400  | Slightly reduced      |
| 0.50 (marginal)        | 0.50 | 0.2500  | Halved — pushed down  |
| 0.30 (noise)           | 0.30 | 0.0900  | Suppressed to 9%      |
| 0.10 (irrelevant)      | 0.10 | 0.0100  | Effectively zero      |

Squaring amplifies the gap between relevant and irrelevant matches. A pattern with cosine 0.95 scores 9× higher than one with cosine 0.30 after squaring (vs only 3× with raw cosine). This creates sharper relevance discrimination.

**Example calculation:**

```
Pattern: strength=1.0, last_accessed=2h ago, access_count=5, cosine=0.85

decay(2) = e^(-0.1 × 2) = 0.8187
B(5) = min(1.0 + 5 × 0.05, 2.0) = 1.25
S(t) = 1.0 × 0.8187 × 1.25 = 1.0234
R = 0.85² × 1.0234 = 0.7225 × 1.0234 = 0.7394
```

**Implementation:** `vector_field.py` line 194

***

## 10. Algorithm 8: Archival Filtering

**Purpose:** Exclude effectively dead patterns from query results.

**Rule:**

```
IF decayed_strength < FIELD_ARCHIVAL_THRESHOLD (0.05):
    EXCLUDE from results
```

**Time-to-archival (no access, initial strength 1.0):**

```
S(t) < 0.05
1.0 × e^(-0.1t) × 1.0 < 0.05
e^(-0.1t) < 0.05
-0.1t < ln(0.05)
t > -ln(0.05) / 0.1
t > 29.96 hours
```

A pattern with no accesses is archived after \~30 hours.

**With access boost (n=20, cap reached):**

```
1.0 × e^(-0.1t) × 2.0 < 0.05
e^(-0.1t) < 0.025
t > -ln(0.025) / 0.1
t > 36.89 hours
```

Maximum reinforcement extends life by \~7 hours.

**Key property:** Patterns are NOT deleted — they remain in the collection but are invisible to queries. Direct retrieval by ID still works.

**Verified:** Test 4 in stress tests — 72h-old pattern at strength 0.000747, well below 0.05

**Implementation:** `vector_field.py` lines 190-191

***

## 11. Algorithm 9: Hebbian Reinforcement (Single)

**Purpose:** When a duplicate injection is detected, reinforce the existing pattern instead of creating a new one.

**Input:**

* `context_id: string` — Field UUID
* `point_id: string` — ID of existing pattern to reinforce

**Steps:**

```
FUNCTION _reinforce_single(context_id, point_id):
    1. collection ← "field_" + context_id
    2. points ← Qdrant RETRIEVE(collection, ids=[point_id])
    3. IF points is empty: RETURN
    4. point ← points[0]
    5. now ← current UTC timestamp as ISO-8601
    6. new_count ← point.payload["access_count"] + 1
    7. Qdrant SET_PAYLOAD on collection:
         points = [point_id]
         payload = {
             access_count: new_count,
             last_accessed: now
         }
```

**Rationale:**

* Incrementing `access_count` increases future `B(n)` (Algorithm 6)
* Updating `last_accessed` resets the decay clock (Algorithm 5)
* Combined effect: duplicate injection makes the pattern stronger and younger
* The `strength` field is NOT modified here — only access metadata changes

**Implementation:** `vector_field.py` lines 294-312

***

## 12. Algorithm 10: Hebbian Reinforcement (Batch with Co-Access)

**Purpose:** Reinforce all patterns returned in a query result. Patterns retrieved together get an additional co-access bonus.

**Input:**

* `context_id: string` — Field UUID
* `point_ids: list[string]` — IDs of all patterns in the query result

**Mathematical Definition (Co-Access Bonus):**

```
S_new = min(S₀ × (1.0 + 0.02 × (k - 1)), S₀ × FIELD_REINFORCE_CAP)

where:
    S₀ = current stored strength
    k  = number of co-retrieved patterns (len(point_ids))
    0.02 = co-access bonus rate (2% per co-pattern)
```

**Co-access bonus table:**

```
k=1 (solo):     no bonus (S_new = S₀)
k=2:            S₀ × 1.02  (+2%)
k=3:            S₀ × 1.04  (+4%)
k=5:            S₀ × 1.08  (+8%)
k=10:           S₀ × 1.18  (+18%)
k=50 (capped):  S₀ × 1.98  (approaches cap)
```

**Steps:**

```
FUNCTION _reinforce_batch(context_id, point_ids):
    1. collection ← "field_" + context_id
    2. now ← current UTC timestamp as ISO-8601
    3. all_points ← Qdrant RETRIEVE(collection, ids=point_ids)
    4. IF all_points is empty: RETURN
    5. point_map ← {str(p.id): p for p in all_points}

    6. FOR EACH pid in point_ids:
         a. point ← point_map[pid]
         b. IF point is None: CONTINUE
         c. new_count ← point.payload["access_count"] + 1
         d. initial_strength ← point.payload["strength"]

         e. IF len(point_ids) > 1:  // Co-access bonus
              boosted ← min(
                  initial_strength × (1.0 + 0.02 × (len(point_ids) - 1)),
                  initial_strength × FIELD_REINFORCE_CAP
              )
            ELSE:
              boosted ← initial_strength  // No bonus for solo retrieval

         f. Qdrant SET_PAYLOAD on collection:
              points = [pid]
              payload = {
                  access_count: new_count,
                  last_accessed: now,
                  strength: boosted
              }
```

**Key distinction from Algorithm 9:**

* Algorithm 9 (single): Only updates `access_count` and `last_accessed`
* Algorithm 10 (batch): Also mutates the stored `strength` via co-access bonus

**Rationale for co-access:**

* "Neurons that fire together wire together" (Hebb, 1949)
* Patterns frequently retrieved together are semantically related
* Strengthening co-retrieved patterns makes clusters of related knowledge persist longer
* The 2% rate is conservative — prevents runaway reinforcement while still rewarding association
* Cap at `FIELD_REINFORCE_CAP × initial_strength` prevents unbounded growth

**Implementation:** `vector_field.py` lines 314-356

***

## 13. Algorithm 11: Field Stability Measurement

**Purpose:** Quantify how converged the field is — are agents building shared understanding or is knowledge fragmented?

**Mathematical Definition:**

```
avg_strength = (1/N) × Σ S(t_i) for all N patterns

stddev = sqrt((1/N) × Σ (S(t_i) - avg_strength)² )

organization = max(0.0, 1.0 - (stddev / avg_strength))  if avg_strength > 0
             = 0.0                                        if avg_strength = 0

stability = avg_strength × 0.6 + organization × 0.4
```

**Component interpretation:**

| Component      | Range         | Meaning                                                                                                                                                     |
| -------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `avg_strength` | \[0.0, \~2.0] | How alive is the field? Fresh, accessed patterns → high. Old, ignored patterns → low.                                                                       |
| `organization` | \[0.0, 1.0]   | How uniform is the strength distribution? All patterns similar strength → high (agents referencing same things). Wide variance → low (mix of hot and cold). |
| `stability`    | \[0.0, \~1.6] | Weighted composite. 60% aliveness, 40% uniformity.                                                                                                          |

**Example calculations:**

```
Empty field:
  N=0, avg=0, org=0, stability=0

One fresh pattern:
  N=1, avg=1.0, stddev=0, org=1.0, stability = 1.0×0.6 + 1.0×0.4 = 1.0

10 fresh patterns (uniform):
  N=10, avg≈1.0, stddev≈0, org≈1.0, stability ≈ 1.0

10 fresh + 5 old (mixed):
  N=15, avg≈0.70, stddev≈0.40, org = 1-(0.40/0.70) = 0.43
  stability = 0.70×0.6 + 0.43×0.4 = 0.42 + 0.17 = 0.59
```

**Steps:**

```
FUNCTION measure_stability(context_id):
    1. collection ← "field_" + context_id
    2. points ← Qdrant SCROLL(collection, limit=10000)
    3. IF points is empty:
         RETURN {stability: 0, pattern_count: 0, avg_strength: 0}

    4. now ← current UTC timestamp
    5. strengths ← empty list

    6. FOR EACH point in points:
         a. age_hours ← (now - parse(point.payload["last_accessed"])) in hours
         b. ds ← CALL _compute_decayed_strength(
              point.payload["strength"], age_hours, point.payload["access_count"]
            )
         c. APPEND ds to strengths

    7. avg ← mean(strengths)
    8. IF avg > 0:
         stddev ← population_standard_deviation(strengths)
         organization ← max(0.0, 1.0 - (stddev / avg))
       ELSE:
         organization ← 0.0

    9. stability ← avg × 0.6 + organization × 0.4

    10. RETURN {
          stability: round(stability, 4),
          pattern_count: len(points),
          avg_strength: round(avg, 4),
          organization: round(organization, 4),
          active_patterns: count(s >= ARCHIVAL_THRESHOLD for s in strengths),
          decayed_patterns: count(s < ARCHIVAL_THRESHOLD for s in strengths)
        }
```

**Verified:** Test 6 in stress tests:

* Empty: stability 0.0
* 1 fresh: stability 1.0
* 11 fresh: stability 1.0
* Mixed (fresh + old): stability 0.57

**Implementation:** `vector_field.py` lines 224-261

***

## 14. Algorithm 12: Field Destruction

**Purpose:** Clean up a field when the mission ends.

**Steps:**

```
FUNCTION destroy_context(context_id):
    1. collection ← "field_" + context_id
    2. TRY:
         Qdrant DELETE_COLLECTION(collection)
    3. CATCH Exception:
         LOG warning (non-fatal — collection may already be gone)
```

**Rationale:**

* Deleting the entire collection is O(1) in Qdrant — no need to iterate points
* Failure is non-fatal — the field may already have been destroyed (idempotent)
* No data needs to be preserved after mission completion (experiment metrics are captured separately by instrumentation)

**Implementation:** `vector_field.py` lines 106-112

***

## 15. Algorithm 13: Mission Lifecycle Integration

**Purpose:** Automatically manage field lifecycle during mission execution.

**Steps in coordinator\_service.py:**

```
MISSION START (or approval):
    1. field_id ← CALL create_context(team_agent_ids, {mission_goal: run.goal})
    2. Store field_id in run.config JSONB column
    3. Emit orchestration event: field.created

TASK COMPLETION:
    1. field_id ← run.config["field_id"]
    2. IF field_id exists AND task.output exists:
         CALL inject(field_id, task.title, task.output[:4000], agent_id)
    // Downstream tasks now find this output by semantic query

TASK EXECUTION:
    1. field_id is passed to agent via task.input_context
    2. Agent can call platform_field_query, platform_field_inject, platform_field_stability
    // Agent interacts with field during execution, not just at completion

MISSION END (completed/failed/cancelled):
    1. CALL destroy_context(field_id)
    2. Remove field_id from run.config

TICK-BASED CLEANUP:
    1. Query for terminal runs where config["field_id"] is not null
    2. Limit to 5 per tick (throttle)
    3. For each: destroy field, remove field_id from config
```

**Implementation:** `coordinator_service.py` lines 85-210

***

## 16. Algorithm 14: A/B Backend Selection

**Purpose:** Select between vector field and Redis baseline for controlled experiments.

**Steps:**

```
FUNCTION get_shared_context(backend_override=None):
    1. backend ← backend_override OR config.SHARED_CONTEXT_BACKEND OR "vector_field"
    2. IF backend already initialized (singleton cache):
         RETURN cached instance
    3. IF backend == "vector_field":
         inner ← new VectorFieldSharedContext()
       ELIF backend == "redis":
         inner ← new RedisSharedContext()
       ELSE:
         LOG error, RETURN None
    4. instrumented ← new InstrumentedSharedContext(inner, backend_name=backend)
    5. Cache instrumented instance
    6. RETURN instrumented
```

**Key property:** The `InstrumentedSharedContext` wrapper captures metrics for BOTH backends identically, enabling fair comparison.

**Implementation:** `factory.py` lines 19-50

***

## 17. Algorithm 15: Experiment Instrumentation

**Purpose:** Capture metrics for every field operation to support A/B comparison.

**Steps (for each operation):**

```
FUNCTION instrumented_operation(operation_args):
    1. start ← monotonic_clock()
    2. result ← CALL inner.operation(operation_args)  // Delegate to real backend
    3. elapsed_ms ← (monotonic_clock() - start) × 1000
    4. event ← new FieldMetricEvent(
         timestamp = current UTC ISO-8601,
         operation = operation_name,
         context_id = ...,
         agent_id = ...,
         latency_ms = elapsed_ms,
         // operation-specific fields (pattern_key, query_text, results_returned, top_score)
       )
    5. APPEND event to ExperimentMetrics for this context_id
    6. RETURN result
```

**Aggregation properties on ExperimentMetrics:**

```
total_injections = count(events where operation == "inject")
total_queries = count(events where operation == "query")
avg_query_latency_ms = mean(latency_ms where operation == "query")
avg_results_per_query = mean(results_returned where operation == "query")
injections_by_agent = {agent_id: count} grouped by agent
queries_by_agent = {agent_id: count} grouped by agent
```

**Implementation:** `instrumentation.py` lines 96-212

***

## 18. Complete Query Pipeline (End-to-End)

This traces a single agent query from request to response through every algorithm.

```
Agent C calls: platform_field_query(field_id="abc", query="biometric restrictions", top_k=5)

STEP 1 — Tool Handler (handlers_field.py)
    Receives params, extracts field_id, query, top_k, agent_id
    Calls factory.get_shared_context()

STEP 2 — Factory (factory.py)
    Returns InstrumentedSharedContext wrapping VectorFieldSharedContext

STEP 3 — Instrumentation (instrumentation.py)
    Records start time via monotonic clock
    Delegates to inner VectorFieldSharedContext.query()

STEP 4 — Embedding Generation
    query_embedding = embedding_model.generate("biometric restrictions")
    Returns float[2048]

STEP 5 — Vector Search (Qdrant)
    Search collection "field_abc" for nearest neighbors to query_embedding
    Distance metric: COSINE
    Limit: 5 × 3 = 15 (over-fetch)
    Returns 15 ScoredPoints with cosine similarity scores

STEP 6 — For each of 15 raw results, compute resonance:
    a. Parse last_accessed timestamp
    b. age_hours = (now - last_accessed) / 3600
    c. decay = e^(-0.1 × age_hours)                    [Algorithm 5]
    d. access_boost = min(1.0 + access_count × 0.05, 2.0)  [Algorithm 6]
    e. decayed_strength = strength × decay × access_boost
    f. IF decayed_strength < 0.05: SKIP                 [Algorithm 8]
    g. resonance = cosine² × decayed_strength           [Algorithm 7]

STEP 7 — Sort by resonance descending, take top 5

STEP 8 — Hebbian Reinforcement                          [Algorithm 10]
    For each of the 5 returned patterns:
    a. access_count += 1
    b. last_accessed = now
    c. IF 5 patterns co-retrieved:
         strength = min(strength × (1 + 0.02 × 4), strength × 2.0)
         (each gets +8% co-access bonus)

STEP 9 — Instrumentation records:
    latency_ms, results_returned=5, top_score, query_text

STEP 10 — Tool handler formats results for agent:
    [{key, value, relevance, from_agent, strength}, ...]

Agent C receives 5 patterns ranked by resonance.
Patterns it accessed are now stronger for next query.
```

***

## 19. Complete Inject Pipeline (End-to-End)

```
Agent A calls: platform_field_inject(field_id="abc", key="biometric_ban", value="Real-time remote biometric...")

STEP 1 — Tool Handler
    Validates key and value are non-empty
    Caps value at 4000 characters
    Calls factory.get_shared_context()

STEP 2 — Instrumentation
    Records start time, delegates to inner.inject()

STEP 3 — Content Hash
    content = "biometric_ban: Real-time remote biometric..."
    content_hash = SHA-256(content) → "a7f3b2..."

STEP 4 — Dedup Check                                   [Algorithm 3]
    Qdrant SCROLL with filter: content_hash == "a7f3b2..."
    IF found: reinforce existing (Algorithm 9), RETURN

STEP 5 — Embedding Generation
    embedding = embedding_model.generate(content)
    Returns float[2048]

STEP 6 — Strength Calculation
    effective_strength = 1.0 × BOUNDARY_PERMEABILITY (1.0) = 1.0

STEP 7 — Qdrant Upsert
    Insert point with UUID, embedding, and full payload
    access_count = 0, last_accessed = now

STEP 8 — Instrumentation records:
    latency_ms, pattern_key="biometric_ban"

Pattern is now in the field. ANY agent can find it by semantic query.
```

***

## 20. Proof Results

### 20.1 Unit Tests (57/57 passing)

| Test Class                 | Tests | What's Verified                                                             |
| -------------------------- | ----- | --------------------------------------------------------------------------- |
| TestComputeDecayedStrength | 11    | Decay math, access boost, cap boundary, scaling, combined effects           |
| TestCreateContext          | 5     | UUID generation, collection creation, payload indexes, initial seeding      |
| TestInject                 | 6     | Embedding generation, payload structure, dedup, reinforce-on-collision      |
| TestQuery                  | 9     | Resonance formula, archival filtering, sorting, over-fetch, Hebbian trigger |
| TestDestroyContext         | 3     | Collection deletion, error handling                                         |
| TestHebbian                | 7     | Batch retrieval, access count, timestamp update, co-access bonus            |
| TestStability              | 7     | Empty field, single pattern, uniform vs varied, organization metric         |
| TestHelpers                | 9     | Hash lookup, single reinforcement, filter construction                      |

### 20.2 Stress Tests (16/16 assertions passing)

| Test              | Assertion                               | Measured Value      |
| ----------------- | --------------------------------------- | ------------------- |
| Resonance ranking | Python ML pattern in top 2 for ML query | Position 2          |
| Resonance ranking | Go concurrency NOT #1 for ML query      | Position 5          |
| Temporal decay    | Fresh > 24h-old strength                | 1.0000 > 0.0907     |
| Temporal decay    | 24h-old below 0.15                      | 0.0907              |
| Hebbian           | Popular has 10 accesses                 | 10                  |
| Hebbian           | Lonely has 0 accesses                   | 0                   |
| Hebbian           | Popular stronger than lonely            | 1.50 > 0.55         |
| Archival          | Alive pattern returned                  | Yes                 |
| Archival          | 72h-old below threshold                 | 0.000747 < 0.05     |
| Stress            | 150 patterns from 50 agents             | 150                 |
| Stress            | Returns 5 results                       | 5                   |
| Stress            | >50 queries/sec                         | 4,000 qps           |
| Stability         | Empty = 0                               | 0.0                 |
| Stability         | One pattern > 0                         | 1.0                 |
| Stability         | Old patterns reduce stability           | 0.57 < 1.0          |
| Telephone         | Agent C finds finding #7                | Found at position 3 |

### 20.3 A/B Comparison (Vector Field vs Message Passing)

Same 3-agent EU AI Act mission. 10 research findings, 3 analyses, 7 test queries.

> **Editorial comment:** This is best described as a **controlled preliminary A/B comparison**, not a general proof of superiority across all missions. The measured result is useful evidence for the mechanism, but broader claims still require more mission types, larger samples, and production-scale evaluation.

| Metric                      | Vector Field  | Message Passing           |
| --------------------------- | ------------- | ------------------------- |
| Context coverage            | **86% (6/7)** | 43% (3/7)                 |
| Information loss            | **1 finding** | 4 findings                |
| Patterns visible to Agent C | **13 (all)**  | 6 (only what B forwarded) |

**Findings lost by message passing:** biometric\_ban, social\_scoring, employee\_monitoring, transparency\_rules — all findings Agent B never referenced but Agent C needed.

**Finding lost by vector field:** penalties — a bag-of-words embedding limitation, not a system limitation. Real 2048-dim embeddings would likely resolve this.

> **Editorial comment:** The sentence above is a reasonable hypothesis, but it is still a hypothesis. If you want this document to read as strictly evidentiary, say that the miss may be attributable to the embedding choice used in the test, rather than stating that better embeddings would resolve it.

***

## Appendix A: File Inventory

| File                                        | Lines | Purpose                                       |
| ------------------------------------------- | ----- | --------------------------------------------- |
| `core/ports/context.py`                     | 63    | SharedContextPort abstract interface          |
| `modules/context/adapters/vector_field.py`  | 357   | Vector field implementation (Algorithms 1-12) |
| `modules/context/adapters/redis_context.py` | 199   | Redis baseline implementation                 |
| `modules/context/instrumentation.py`        | 213   | Metric capture wrapper (Algorithm 15)         |
| `modules/context/factory.py`                | 51    | Backend selection factory (Algorithm 14)      |
| `modules/context/experiment.py`             | 89    | A/B comparison report generator               |
| `modules/tools/discovery/actions_field.py`  | 48    | Tool definitions for agents                   |
| `modules/tools/discovery/handlers_field.py` | 152   | Tool handler implementations                  |
| `services/coordinator_service.py`           | +143  | Mission lifecycle integration (Algorithm 13)  |
| `config.py`                                 | +9    | Configuration constants                       |
| `tests/test_vector_field.py`                | 770   | 57 unit tests                                 |
| `tests/demo_field_stress.py`                | 403   | 16 stress assertions                          |
| `tests/demo_ab_comparison.py`               | 374   | A/B comparison test                           |
| `tests/demo_field.py`                       | 275   | Integration demo                              |

**Total new code:** \~3,100 lines across 14 files

## Appendix B: Prior Art Differentiation

| Feature                                 | This System | Mitra (2026)       | Blackboard (1985) | Stigmergy       |
| --------------------------------------- | ----------- | ------------------ | ----------------- | --------------- |
| Multi-agent shared field                | YES         | No (single agent)  | YES (symbolic)    | YES (spatial)   |
| High-dim semantic embeddings            | YES (2048)  | YES (2D reduced)   | No                | No              |
| cos² resonance scoring                  | YES         | No (PDE diffusion) | No                | No              |
| Exponential temporal decay              | YES         | YES (PDE-based)    | No                | YES             |
| Hebbian access reinforcement            | YES         | No                 | No                | YES (pheromone) |
| Co-access bonus                         | YES         | No                 | No                | No              |
| Content-hash dedup with reinforce       | YES         | No                 | No                | No              |
| Field stability metric                  | YES         | No                 | No                | No              |
| Mission-bound lifecycle                 | YES         | No                 | No                | No              |
| Agent-callable tools                    | YES         | No                 | No                | No              |
| A/B experiment infrastructure           | YES         | No                 | No                | No              |
| Production LLM orchestrator integration | YES         | No                 | No                | No              |

***

*Every algorithm in this document has a corresponding implementation in code, referenced by file and line number. Every measured result has been produced by running the actual code against a real Qdrant instance. Nothing in this document is theoretical.*

*Gerard Kavanagh — March 21, 2026*