Vectorspaces: Approximate-Match Tuplespaces over VSA

Kendall Clark · Pentad Labs · 5 May 2026 · PLRN-001

Abstract

Linda’s tuplespace coordination model never scaled past small distributed systems, in significant part because exact unification is the wrong primitive for partial, noisy, or analogical agent-to-agent communication. We define Vectorspaces: a tuplespace abstraction whose operations (out_vs, in_vs, rd_vs) are realized as bundle, factor-and-subtract, and factor-and-read over a Vector-Symbolic Architecture (VSA). The result is a coordination primitive with first-class support for approximate match, compositional templates, analogical retrieval, and accumulation-based salience. Vectorspaces are local-first, eventually consistent, and embarrassingly distributable. A reference implementation is being built into Wunderblock, the agentic-memory subsystem of WunderOS at Pentad Labs.

1. Motivation

Tuplespaces (Gelernter et al., 1985) gave distributed systems a coordination primitive of striking elegance: a shared associative memory accessed by out (write a tuple), in (destructively read a matching tuple, blocking until one exists), and rd (non-destructively read). Templates with wildcards permitted limited pattern matching. JavaSpaces, TSpaces, and a small commercial ecosystem followed.

By 2010 the model had effectively collapsed. The conventional explanation is performance, since central matchers scale poorly, but the deeper problem is semantic. Exact unification on flat tuples is the wrong abstraction for the messy, partial, analogical communication that real distributed agents actually want. Templates that don’t quite match return nothing; mistyped fields fail silently; richer queries require enumerating wildcards by hand. Linda was associative in name only.

Vector-Symbolic Architectures (Plate, 1995; Kanerva, 2009) solve a different problem with overlapping mathematics: representing structured data as high-dimensional vectors that compose under a small algebra (bind, bundle, permute) and admit approximate retrieval by inner-product similarity. VSAs have been used for cognitive modeling, neuro-symbolic reasoning, and analogical inference, but rarely as coordination infrastructure.

This paper proposes Vectorspaces: a tuplespace whose operations are defined over a VSA memory, replacing exact unification with geometric approximate match. The substitution is small in code and large in consequence. Coordination over Vectorspaces is robust to noise and partial information, supports analogical templates as a one-line construction, and inherits VSA’s compositional structure for free. Accumulation-based write semantics give the resulting space the dynamics of human memory: salience emerges from use, drift is a feature rather than a bug, and unattended structures fade.

2. Background

2.1 Linda

A tuplespace is a multiset of tagged tuples. out(t) adds t. in(template) removes and returns some tuple matching template, blocking until a match exists; inp(template) is the non-blocking variant. rd(template) returns a copy without removal. Templates contain ground values and typed wildcards; matching is exact unification. The canonical references are Carriero and Gelernter’s papers from 1986 to 1992.

2.2 Vector-Symbolic Architectures

A VSA is a tuple ⟨V, ⊕, ⊗, π, ~⟩ where V is a high-dimensional vector space, ⊕ is a bundling operator (typically a thresholded sum, preserving similarity), ⊗ is a binding operator (component-wise multiplication or circular convolution, distributing over ⊕ and approximately invertible), π is a permutation used for role-marking and sequence, and ~ is a similarity measure (typically cosine or Hamming-equivalent). Atomic symbols are random vectors. Structured representations are built by bundling bound role-filler pairs. Retrieval is similarity search; factorization is supported approximately by clean-up against a codebook and, for clean codebooks, exactly via Resonator Networks (Frady et al., 2020).

2.3 The Z₃ ternary VSA

The concrete substrate for the reference implementation is a ternary VSA with values in {−1, 0, +1}, dimension 2¹⁴, addition over Z₃ (giving full additive invertibility), component-wise multiplication for binding, and cyclic permutation for role marking. Zero entries function as wildcards under inner-product similarity. The construction below is parametric over any VSA satisfying the algebra; specific dynamics differ between Z₃, BSC, FHRR, and custom dynamical systems, and the right choice depends on the deployment.

3. Vectorspaces

A vectorspace S is a single VSA vector, a Groove in Wunderblock’s terminology, initially zero. Tuples are bundled into S and recovered by approximate match.

3.1 Tuples and templates

A tuple is a finite map from role symbols to filler vectors, encoded as

T = ⊕ᵢ (rᵢ ⊗ fᵢ)

where each rᵢ is a role vector from a fixed codebook and each fᵢ is a filler. The canonical schema in Wunderblock is the SPOCL pentad (Subject, Predicate, Object, Context, Lineage), but Vectorspaces are defined over arbitrary role schemas. A template Q is the same shape, with zero vectors in role positions to be matched (zero-trit wildcards in Z₃; corresponding constructions in other VSAs).

3.2 Operations

We give two read variants per operation: a committed form returning a single best match, and a field form returning the projected superposition. Both are useful; consumers choose based on whether they have factorization budget and whether they want a distribution or a decision.

out_vs(S, T) bundles T into S. The default is accumulating: writing T twice yields a stronger signal than writing it once. This is a deliberate departure from Linda’s set-theoretic semantics. Repeated writes encode salience-by-frequency, an effect well-attested in bibliometrics and in the broader literature on memory and attention. An idempotent variant out_vs_set is provided where set semantics are required, but accumulating is the canonical case and the source of much of what follows. The exact accumulation dynamics (saturation, decay, normalization) are VSA-specific; we describe the Z₃ case in §3.4.

in_vs(S, Q, θ) factors S against the template Q, returns the single best match if its similarity exceeds θ, and subtracts the matched tuple’s encoding from S. The call blocks until similarity ≥ θ. Threshold θ is caller-supplied. A system-wide threshold is the wrong abstraction, since different consumers of the same vectorspace impose different precision/recall tradeoffs, and caller-controlled thresholds are how this scales without per-consumer space partitioning.

in_vs_field(S, Q, θ) is the long-name variant. Rather than committing to a single best match, it returns the projected field, the superposition of all components of S whose similarity to Q exceeds θ, and subtracts that projection from S. The caller may then factor the field at leisure (Resonator iterations, exhaustive codebook scan, downstream LLM, whatever they have budget for) or treat it as a distribution. This is more VSA-native than in_vs and exposes the geometry directly.

rd_vs and rd_vs_field are non-destructive analogues; no subtraction.

inp_vs and inp_vs_field are non-blocking analogues. They return immediately with (match, similarity) or (⊥, 0). Caller decides whether to retry.

3.3 Wildcards and analogy

A template with zero entries in some roles matches any filler in those roles, ranked by similarity in the remaining roles. This recovers Linda-style wildcards as a special case.

More interestingly, templates can be analogical. Suppose S contains the tuples

T₁ = (usa ⊗ country) ⊕ (dollar ⊗ currency)
T₂ = (mexico ⊗ country) ⊕ (peso ⊗ currency)

The analogical query “what stands to mexico as dollar stands to usa” is constructed in one line:

Q = (mexico ⊗ country) ⊕ ((dollar ⊗ usa⁻¹ ⊗ mexico) ⊗ currency)

in_vs_field(S, Q, θ) returns peso, ranked first. Classical Linda has no analogue; the construction comes for free from the VSA algebra. Analogical retrieval is the killer feature of Vectorspaces and the strongest single justification for the abstraction. VSAs are essentially unique among practical retrieval substrates in supporting analogy as a primitive operation rather than a learned behavior.

3.4 Accumulation, drift, and the residual

Each in_vs subtracts an approximate match from S. When the match is exact, subtraction is exact (Z₃ addition is invertible). When approximate, residual noise accumulates. We treat this not as a defect but as a model of memory dynamics.

Concretely, a Vectorspace exhibits the following emergent properties under accumulating semantics. Frequency salience: tuples written many times grow stronger and dominate retrieval. Use weighting: tuples read but not rewritten weaken under subtraction; tuples rewritten after reading recover. Compositional ghosting: tuples never written may nevertheless appear faintly in retrieval as superpositions of their compositional neighbors, a property closer to creative recall than to database lookup. Implicit decay: structures unattended by either reading or writing remain at fixed magnitude while the rest of the space accumulates around them, becoming relatively quieter without explicit decay machinery.

These properties are precisely what one wants from a memory and precisely what one does not want from a coordination primitive in the strict Linda tradition. The choice is a deployment parameter. Set-semantic Vectorspaces with periodic exact compaction recover something closer to classical tuplespace coordination; accumulating Vectorspaces with infrequent compaction give the memoryspace dynamics described above.

The unselected-data principle underwrites the design. Across many domains where attention is a scarce resource (bibliometrics, search behavior, cultural transmission, biological memory) what is not selected fades, and what is repeatedly selected dominates. Vectorspaces import this dynamic at the level of the storage primitive. We claim, informally, the inclusion

Vectorspaces ⊃ Memoryspaces

A Memoryspace is a Vectorspace where the SPOCL schema and accumulating semantics are fixed. Other instantiations (set-semantic Vectorspaces over flat tuples for pure coordination, alternative role schemas for domain-specific coordination) are parameter choices of the more general construction.

Periodic consolidation passes bound the residual: Louvain clustering over the implicit co-occurrence graph, sign renormalization, and optional clean-up against a clean codebook. Choice of consolidation schedule is a system parameter, and a productive analogy with sleep-stage memory consolidation in biological systems is left for future work.

3.5 Distribution

Each node maintains a local Vectorspace Groove. out_vs is local-first; writes gossip lazily. in_vs consults the local Groove first; if no match exceeds θ, the node may issue a probe to peers, ranked by past locality of relevant tuples. There is no central matcher and no global lock.

The model is eventually consistent: a tuple written at node A may not be visible at node B for some time, and approximate matches at B may be less sharp than at A until gossip catches up. This is acceptable and indeed desirable. Vectorspaces inherit the partition tolerance of well-designed CRDTs without requiring CRDT formalism, because bundling is commutative, associative, and (under accumulating semantics with appropriate normalization) approximately convergent. Two nodes that have seen the same multiset of writes converge to similar Grooves regardless of order.

4. Worked examples

4.1 Analogical retrieval

(As above.) The full power of the algebra appears here. A template that would require enumeration in Linda is a single bind in Vectorspaces. Concrete agent applications include cross-domain search (“find the X of Y” where the relation is implicit), preference transfer (“recommend Z to user A as Q was recommended to user B”), and unsupervised relation extraction over agent traces.

4.2 Multi-agent blackboard

Agents post partial hypotheses as tuples and read approximate matches without enumerating templates. An agent posting ⟨hypothesis, suspect, X⟩ for various X populates the space; a coordinator querying ⟨hypothesis, suspect, ?⟩ retrieves the field of suspect-hypotheses ranked by accumulated weight, surfacing the consensus directly. Linda requires the coordinator to know in advance which suspects to template against, which is exactly the information the blackboard is supposed to produce.

4.3 Compliance memory

Audit queries over lineage-bearing pentads can be approximate in the actor or the asset and exact in the operation:

in_vs_field(S, ⟨?actor, transferred, ?asset, ?ctx, ?⟩, θ)

Misspellings, aliases, and partial identifiers all match. The Merkle-chained lineage component preserves cryptographic auditability of the exact facts, even though the match was fuzzy. This is a regulatory feature, not a bug: investigators can search by what they remember and audit by what was written.

4.4 Episodic recall

An agent’s current context Groove is a template. The Vectorspace of past episodes returns relevant memories ranked by similarity, automatically weighted by accumulation and recency. No segmentation model, no embedding API, no LLM in the retrieval path. Episode boundaries fall out of consecutive-context novelty; consolidation runs in the background.

5. Discussion

5.1 Why now

The original Linda papers predate practical VSA by a decade; the original VSA papers showed no interest in coordination. The intersection has, as far as we have been able to determine, remained unwritten. A small body of 1990s work on associative tuplespaces using conventional hashing explored approximate match without VSA geometry and did not propagate. Recent VSA implementations on commodity hardware, including the Z₃ stack underlying Wunderblock, make Vectorspaces practical at the scales coordination problems actually occupy.

5.2 Coordination and memory are the same problem

Both are associative storage with partial-information retrieval, accumulated salience, and graceful failure. Linda gave coordination a thin formal core; VSAs give memory a thin algebraic core. Vectorspaces unify them. A coordination space and a memoryspace are the same data structure with different schema and consolidation parameters. This is not a metaphor; it is an implementation fact.

5.3 Why this is hard to do classically

Approximate match in a relational or document store requires (a) indexing every plausible approximation, (b) running similarity as a separate query path, or (c) embedding into a vector store and losing compositional structure. Vectorspaces give approximate match and compositional structure in one substrate at one cost. The price is a different programming model: callers think in templates, thresholds, and binds, not joins and predicates. We consider this a feature.

5.4 On the name

The original Linda was named after a pornographic actress as a joke about Ada Lovelace. We do not carry that forward. Vectorspaces names what the thing is.

6. Reference implementation

Wunderblock, the agentic-memory subsystem of WunderOS in development at Pentad Labs, implements Vectorspaces as a first-class abstraction over a Z₃ VSA storage substrate. The full stack provides the operational semantics described above with caller-controlled thresholds, accumulating writes by default, both committed and field read variants, local-first distribution with lazy gossip, and periodic Louvain-based consolidation. A free cloud tier with Python and TypeScript SDKs is forthcoming.

7. Open questions

Several questions are deferred to a fuller treatment.

Convergence guarantees under accumulating semantics. Two nodes seeing the same multiset of writes converge to what, exactly, and how fast? The answer depends on bundling normalization, threshold dynamics, and consolidation schedule. We have empirical results in the Z₃ case and no formal theorem yet.

Threshold calibration. Caller-controlled θ is the right abstraction, but consumers need defaults and guidance. A characterization of the precision/recall surface as a function of space density and template specificity would be useful.

Resonator-based factorization for in_vs_field. Returning the field is cheap; factoring it well is not always. Whether Resonator Networks at the scales we care about converge reliably is an empirical question we have partial answers to.

Schema migration. Changing the role codebook of an in-use Vectorspace is currently an offline rebuild. A streaming migration scheme using role re-binding would be valuable for long-lived systems.

1990s work on associative tuplespaces using conventional hashing is acknowledged but, to our knowledge, did not employ VSA geometry.

A note on method

Written in conversation with Claude Opus 4.7 (Anthropic) as structured interlocutor and prose editor. The ideas, claims, framing, and architectural commitments are mine.

Kendall Clark · k@pentad.ai
—Great Falls, Virginia
May 2026