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

2. Data Structures

3. Algorithm 1: Field Creation

4. Algorithm 2: Pattern Injection

5. Algorithm 3: Content Deduplication

6. Algorithm 4: Semantic Query with Resonance Scoring

7. Algorithm 5: Temporal Decay

8. Algorithm 6: Access Boost

9. Algorithm 7: Resonance Score Computation

10. Algorithm 8: Archival Filtering

11. Algorithm 9: Hebbian Reinforcement (Single)

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

13. Algorithm 11: Field Stability Measurement

14. Algorithm 12: Field Destruction

15. Algorithm 13: Mission Lifecycle Integration

16. Algorithm 14: A/B Backend Selection

17. Algorithm 15: Experiment Instrumentation

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

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

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