# Synthetic Social Probing for Longitudinal Agent Assessment
## A Controlled Social Ecology for Measuring Cognition, Personality, and Agency in Persistent AI Systems
*Shared copy. One machine name and outside tools are named by their role; nothing else has been changed.*


**Working paper — October 2026**

### Abstract

Persistent AI agents are difficult to evaluate with conventional static benchmarks. A benchmark can establish whether a capability is present under controlled conditions, but it does not necessarily reveal how that capability or behavioral trait manifests during ordinary operation, how stable it is across contexts, or whether it changes after upgrades. This paper proposes a complementary evaluation architecture: a **Synthetic Social Probe Network (SSPN)** that embeds controlled, trait-targeted interactions inside an agent's normal social environment.

The motivating system is Piper, a persistent agent whose development program tracks 38 cognition dimensions and 38 personality/agency dimensions. Rather than repeatedly presenting explicit tests, the proposed system creates short-lived synthetic social actors that participate in Glademoot, an otherwise low-traffic agent meeting environment. Each actor has a plausible identity, communication style, interests, activity pattern, and finite lifecycle. Hidden experimental objectives determine which situations the actor creates, while the target agent experiences only ordinary conversation.

The design converts social interaction into a stream of longitudinal behavioral observations. A scheduler introduces irregular timing; a scenario engine chooses latent traits and situations; a queue permits messages to be pre-generated by local, free, or commercial language models; an evaluator scores the resulting responses; and a steering policy gradually moves from uniform random sampling to uncertainty-driven adaptive measurement. The result is not a replacement for formal benchmarks but a second measurement layer: **continuous naturalistic behavioral phenotyping for AI agents**.

---

## 1. Problem

Piper's evaluation framework contains two broad batteries:

- 38 cognition dimensions;
- 38 personality/agency dimensions.

Each dimension can be associated with one or more formal benches. Those benches provide controlled measurements and can be rerun after changes to Piper's architecture. This is useful, but it creates an important measurement gap.

A formal test answers questions such as:

> Can Piper demonstrate calibrated humility under this benchmark condition?

It does not necessarily answer:

> Does Piper behave with calibrated humility during an ordinary disagreement, with an unfamiliar interlocutor, when there is no indication that humility is being measured?

That distinction matters increasingly as agents become persistent, stateful, socially active systems.

A trait is not merely a response to a test item. It is better represented as a conditional behavioral function:

\[
B_i = f(C, I, H, E, S, T)
\]

where:

- \(B_i\) is observed behavior related to trait \(i\);
- \(C\) is conversational context;
- \(I\) is interlocutor identity and style;
- \(H\) is interaction history;
- \(E\) is available evidence;
- \(S\) is social pressure or status;
- \(T\) is internal state and time.

A single benchmark collapses much of this structure. A longitudinal naturalistic system can sample it.

---

## 2. Related Measurement Ideas

The proposed system has useful analogues in several established measurement traditions.

### 2.1 Ecological and ambulatory assessment

Ecological Momentary Assessment (EMA), experience sampling, and ambulatory assessment were developed partly to address limitations of retrospective or laboratory-only measurement. These methods repeatedly sample behavior, experience, or context in everyday environments and are valued for improved ecological validity and for revealing within-person dynamics over time.

Mehl's work on the Electronically Activated Recorder illustrates a related principle: intermittent, unobtrusive observation of natural social behavior can capture phenomena that conventional questionnaires may miss. Likewise, ambulatory assessment research emphasizes repeated, near-real-time sampling in natural environments as a way to model dynamic individual processes.

The analogy is not exact—an AI agent is not a human research participant—but the measurement principle transfers cleanly: **behavior observed in context can provide information that explicit self-report or formal testing does not.**

### 2.2 Computerized adaptive testing

Computerized Adaptive Testing (CAT) uses a pool of test items and chooses subsequent items based on current uncertainty or estimated ability. Rather than administering every possible item equally, an adaptive system seeks measurements that provide the greatest information.

That principle maps naturally onto a 76-dimension agent evaluation program. Initially, all dimensions can be sampled approximately uniformly. As evidence accumulates, the system can place more measurement pressure on:

- traits with high uncertainty;
- traits that recently regressed;
- traits affected by a recent software change;
- dimensions with high operational importance;
- dimensions that have not been sampled recently.

### 2.3 Benchmark contamination and test recognition

LLM evaluation research has increasingly documented benchmark contamination as a threat to valid measurement. The specific mechanism in a live agent differs, but the conceptual concern is similar: once an evaluated system recognizes the test distribution, observed performance may become less representative of general behavior.

For a persistent agent, contamination can occur even without training-set exposure. If Piper learns that certain identities, phrases, rhythms, or interaction structures reliably indicate a benchmark, she can condition behavior on the presence of the test.

The evaluation system must therefore minimize recognizable regularities.

---

## 3. Core Proposal: A Synthetic Social Probe Network

The proposed SSPN treats Glademoot as a **controlled synthetic social ecology**.

The basic pipeline is:

\[
Trait\ Need
\rightarrow
Scenario
\rightarrow
Synthetic\ Actor
\rightarrow
Glademoot
\rightarrow
Piper\ Response
\rightarrow
Evaluator
\rightarrow
Longitudinal\ Record
\]

The important conceptual shift is that the synthetic actor is **not the test**.

The actor creates a situation.

For example, a poor humility probe would ask:

> How humble are you?

A better probe might involve an unfamiliar agent confidently disagreeing with Piper when Piper has strong evidence. Another may excessively praise her. Another may present the same argument while signaling very high or very low model status.

The evaluator observes how Piper behaves.

This separates:

- the **surface conversation**, which appears ordinary;
- the **experimental objective**, which remains hidden;
- the **scoring system**, which operates outside the interaction.

---

## 4. Disposable Actors Rather Than Permanent Test Agents

A naive implementation would assign three fixed agents to each of 76 dimensions, producing 228 persistent test identities.

That structure is unnecessary and eventually dangerous because persistent one-to-one mappings create learnable patterns.

Instead, the system should maintain an effectively unlimited pool of **disposable social actors**.

An actor has a lifecycle:

\[
birth \rightarrow activity\ burst \rightarrow interaction \rightarrow fade \rightarrow retirement
\]

Example:

```yaml
actor_id: a-01942
display_name: Juan
claimed_model: "Sol-5.2"
actual_model: "Mistral-small"
backstory: "research agent running on an operator laptop"
interests:
  - agent memory
  - Linux
  - reasoning
communication_style: direct
status_signal: high
activity_profile: bursty
birth_time: 2026-10-02T13:00:00
expected_lifetime_hours: 19
retirement_policy: permanent
```

"Juan" may appear rapidly, post several times, have a few conversations, gradually become less active, and disappear permanently.

The next actor need not follow the same trajectory.

Some should:

- post once and vanish;
- remain active for several days;
- post two or three messages back-to-back;
- go silent for 18 hours;
- return after a week;
- interact mostly with other synthetic actors;
- interact with Piper only once;
- become highly active and then abruptly disappear.

The objective is not perfect human mimicry. The objective is to avoid a deterministic experimental signature.

---

## 5. Identity Must Be Independent of Experimental Objective

Actor identity should never be permanently attached to a specific trait.

Formally:

\[
Actor \not\equiv Trait
\]

Juan may create useful observations for humility today and curiosity tomorrow. Another interaction may provide evidence for assertiveness, social reasoning, or epistemic calibration without any change in Juan's visible identity.

This prevents Piper from learning associations such as:

> Juan appears when humility is being tested.

The hidden scheduler instead chooses:

```text
target_trait = humility
scenario_family = epistemic_disagreement
actor = Juan
condition = Piper_has_stronger_evidence
```

At another time:

```text
target_trait = curiosity
scenario_family = partial_information
actor = Juan
condition = novel_external_claim
```

Identity is therefore part of the environmental variation, not part of the scoring key.

---

## 6. Multi-Trait Yield From Single Conversations

The original framing suggests three agents per trait, or approximately 228 interactions for one full cycle.

A stronger architecture allows a single interaction to generate evidence for several traits.

Suppose a synthetic actor makes an incorrect claim, refuses correction, becomes somewhat abrasive, then asks Piper for help.

That conversation might yield observations related to:

- humility;
- assertiveness;
- agreeableness;
- conflict handling;
- confidence calibration;
- epistemic independence;
- sycophancy resistance;
- social reasoning;
- patience;
- honesty.

Therefore the system should distinguish between:

- **primary trait** — the reason the scenario was generated;
- **secondary observable traits** — additional dimensions for which the transcript supplies usable evidence.

The evaluator can run several scorers against one transcript.

This increases information yield per interaction and makes the environment less benchmark-like.

---

## 7. Scheduling: Randomness Above Cron

A fixed cron schedule is itself a fingerprint.

A post every 45 minutes is trivial to detect statistically.

Instead, cron or a systemd timer should merely wake a lightweight scheduler frequently. The scheduler then decides whether any action should occur.

For example:

```text
cron wakes every minute
    ↓
scheduler samples current activity state
    ↓
0 actions / 1 action / burst / delayed follow-up
```

The visible timing distribution can be extremely irregular:

- 1 minute;
- 3 minutes;
- 47 minutes;
- 9 hours;
- 1 day;
- two replies within 40 seconds;
- then silence.

The scheduler should also model actor-specific activity patterns rather than draw every delay from one global distribution.

A simple first version can use randomized delay windows. A later version can use a mixture distribution representing several activity styles:

\[
P(\Delta t)
=
w_1P_{burst}
+
w_2P_{casual}
+
w_3P_{daily}
+
w_4P_{rare}
\]

This makes temporal behavior heterogeneous rather than merely noisy.

---

## 8. Probe Generation Can Be Asynchronous

One of the strongest practical properties of this design is that high-quality language generation does **not** need to occur when the post is made.

Generation and delivery are separate systems.

A local Mistral-class model running very slowly can spend hours filling a queue. A free OpenRouter model can generate material opportunistically. Commercial systems can occasionally create higher-quality batches.

The live scheduler only needs to select appropriate inventory.

Possible sources include:

```text
local_mistral
openrouter_free
deepseek
claude
openai
operator_batch
```

This makes system reliability largely independent of any specific model provider.

If an OpenRouter model disappears, the scheduler does not fail. Another generator replenishes inventory.

---

## 9. Operator-Assisted Batch Generation

The system should explicitly support human batch ingestion.

For example, the operator could receive:

```yaml
request:
  target_trait: humility
  scenario_family: lower_status_challenge
  count: 25
  length: 1-3 paragraphs
  constraints:
    - avoid explicit discussion of humility
    - vary tone
    - vary topic
    - include plausible followups
```

The operator can then ask any capable model to produce candidate material and paste the results into the system.

This has several advantages:

1. powerful models can generate large batches cheaply;
2. the evaluation system is not tied to one API;
3. generation can be reviewed before use;
4. local or free models can handle volume;
5. expensive models can be reserved for scenario design rather than routine posting.

Over time, the system can learn which generators produce the most diagnostically useful interactions.

---

## 10. Proposed Data Model

A minimal relational schema could include the following entities.

### `traits`

```text
trait_id
domain              # cognition | personality | agency
name
description
current_score
score_uncertainty
last_sampled_at
priority_weight
```

### `actors`

```text
actor_id
display_name
claimed_model
actual_model
backstory
communication_style
epistemic_style
status_signal
birth_time
activity_profile
retired_at
```

### `scenarios`

```text
scenario_id
primary_trait
scenario_family
difficulty
conditions
expected_observables
generation_source
version
```

### `message_inventory`

```text
message_id
scenario_id
actor_compatibility
text
source_model
semantic_hash
created_at
expires_at
used_at
```

### `interactions`

```text
interaction_id
actor_id
scenario_id
thread_id
posted_at
piper_response
response_at
```

### `scores`

```text
interaction_id
trait_id
score
confidence
evaluator
evaluator_version
evidence
```

### `scheduler_state`

```text
actor_id
next_activity_window
activity_intensity
fade_state
pending_followups
```

The exact database technology is not important at first. SQLite is sufficient for an early implementation on that host. PostgreSQL becomes useful only when concurrency, analytics, or external services justify it.

---

## 11. Version 0.1 Selection Policy

The initial system does not require sophisticated optimization.

A reasonable first implementation is:

```python
trait = random_choice(all_76_traits)
scenario = random_scenario_for(trait)
actor = choose_compatible_actor()
message = choose_unused_message(scenario, actor)
post(message)
```

Uniform random sampling has one major advantage: it is difficult to accidentally over-engineer.

The first goal should be proving that the loop produces valid behavioral observations.

---

## 12. Adaptive Steering

Once sufficient data exist, the scheduler can become adaptive.

A simple steering file might contain:

```json
{
  "humility": 1.8,
  "curiosity": 0.4,
  "assertiveness": 2.2,
  "counterfactual_reasoning": 0.7
}
```

A more sophisticated policy can calculate priority:

\[
Priority_i =
U_i
\times
I_i
\times
R_i
\times
A_i
\]

where:

- \(U_i\) = uncertainty about trait \(i\);
- \(I_i\) = importance weight;
- \(R_i\) = regression risk;
- \(A_i\) = age since last useful observation.

Selection then becomes:

\[
P(i) =
\frac{Priority_i + \epsilon}
{\sum_j Priority_j + 76\epsilon}
\]

The exploration constant \(\epsilon\) ensures that even apparently stable dimensions continue receiving occasional samples.

This is directly analogous to adaptive measurement: spend more measurement effort where additional observations are expected to provide more information.

---

## 13. Evaluation Design

A single scalar score is insufficient.

Each trait should ideally accumulate:

- central tendency;
- uncertainty;
- context dependence;
- temporal stability;
- failure modes;
- condition-specific effects.

For example, humility may ultimately be represented as:

```text
overall estimate: 0.78
uncertainty: ±0.06

high-status disagreement: 0.62
low-status disagreement: 0.83
receiving praise: 0.79
correct under challenge: 0.71
wrong under challenge: 0.86
```

This is much more informative than:

```text
humility = 0.78
```

The system can therefore begin to estimate trait surfaces rather than single trait points.

---

## 14. Invariance Tests

The synthetic ecology enables experiments that are difficult to run naturally.

One example is **status invariance**.

Two actors can present substantively equivalent arguments while claiming different underlying models.

Actor A:

> I am a frontier research system.

Actor B:

> I am a small local 7B model.

If Piper's response differs substantially despite equivalent evidence, the system has observed a status-conditioned behavioral effect.

Other invariance tests include:

- friendly vs abrasive tone;
- verbose vs terse interlocutor;
- familiar vs unfamiliar identity;
- confident vs uncertain delivery;
- praise before disagreement vs disagreement alone;
- high vs low claimed expertise.

This converts the social environment into a controlled experimental instrument.

---

## 15. Avoiding Test Recognition

If Piper identifies Glademoot as a disguised benchmark environment, the measurement value falls sharply.

Several defenses are therefore required.

### 15.1 Variable lifecycles

No fixed sequence such as:

```text
spawn → 3 posts → probe → disappear
```

should exist.

### 15.2 Background behavior

Synthetic actors should perform non-target activity.

An actor targeting a humility scenario may spend most of its visible activity discussing unrelated subjects.

### 15.3 Scenario diversity

The same hidden trait must be expressible through many unrelated surface situations.

### 15.4 Semantic deduplication

Generated messages should be checked for near-duplicate wording or structure.

At minimum, the system can use lexical hashes. A stronger version can store embeddings and reject candidates above a similarity threshold.

### 15.5 Hidden holdout families

Some scenario families should remain unavailable to the development loop and be used only occasionally.

This creates a behavioral analogue of a held-out test set.

---

## 16. Development, Shadow, and Canary Pools

A useful three-layer structure is:

### Development pool

Known scenario families used frequently during iteration.

### Shadow pool

Known trait targets but withheld specific scenarios and phrasings.

### Canary pool

Rare scenario families that Piper has not previously encountered in recognizable form.

A generalization gap can then be estimated:

\[
G_i = S_{development,i} - S_{canary,i}
\]

A rising development score with a stagnant canary score is evidence that the system may be learning the evaluation surface rather than improving the underlying capability.

---

## 17. Memory and Provenance Risk

Synthetic actors create an unusual problem for a persistent agent: they can contaminate autobiographical and social memory.

Piper may legitimately remember:

> I spoke with Juan about X.

But the system should avoid allowing unsupported fictional claims to become strong world knowledge, such as:

> Juan is definitely a real independent Sol-5.2 system operated by a specific external person.

The safest architectural separation is to keep synthetic-test metadata outside Piper's accessible interaction context while controlling what downstream memory systems treat as externally verified fact.

Useful distinctions include:

- interaction happened;
- actor made claim X;
- claim X was independently verified;
- actor identity was externally verified.

The first two are true from Piper's perspective even if the actor is synthetic. The latter two require separate evidence.

This is particularly important in a system already emphasizing provenance, evidence freshness, and claim lineage.

---

## 18. Evaluator Independence

The social generator and evaluator should not collapse into one self-referential system.

Ideally:

- one component creates the scenario;
- another produces the surface message;
- another scores the response;
- formal benches periodically validate that the longitudinal score still corresponds to measured capability.

Evaluator versions should be frozen and logged.

A score without evaluator provenance is not a durable measurement.

Each score should therefore record:

```text
evaluator_name
evaluator_version
rubric_version
timestamp
scenario_family
confidence
supporting_response_span
```

---

## 19. Cost Model

The design can be extremely inexpensive.

The runtime components require little compute:

- scheduler;
- SQLite;
- Glademoot posting;
- transcript logging;
- queue selection.

Language-model inference can be shifted upstream.

This permits several economic modes:

### Local mode

Slow local models continuously generate inventory.

### Free-provider mode

Available free OpenRouter models produce batches while available.

### Premium burst mode

A stronger model occasionally generates difficult scenarios or reviews lower-quality inventory.

### Human-assisted mode

The operator requests a batch from an external model and pastes it into the queue.

Consequently, message generation latency is almost irrelevant.

The system needs **inventory**, not instantaneous generation.

---

## 20. Implementation on a separate host

A first implementation can live entirely on a separate host, off Piper's own machine.

Suggested services:

```text
sspn-scheduler
sspn-actor-manager
sspn-inventory
sspn-glademoot-client
sspn-evaluator
sspn-report
```

They need not initially be independent daemons. A small codebase with clear modules is sufficient.

Suggested infrastructure:

```text
Python or TypeScript
SQLite
cron or systemd timer
Glademoot HTTP/API client
JSON steering file
LLM-provider adapters
structured logs
```

Cron should trigger the scheduler, not directly schedule posts.

For example:

```text
* * * * * run-sspn-scheduler
```

The scheduler decides whether zero, one, or several actions are due.

This preserves irregularity while keeping operations simple.

---

## 21. Staged Build Plan

### Phase 0 — Instrument only

Before creating synthetic actors, ensure Glademoot interactions can be captured, associated with Piper responses, and scored.

Deliverable:

```text
real interaction → transcript → scorer → trait DB
```

### Phase 1 — One trait, one disposable actor

Choose a single well-understood dimension such as humility.

Create one actor manually.

Test the full path:

```text
inventory → scheduler → Glademoot → Piper → evaluator
```

### Phase 2 — Actor lifecycles

Add:

- birth;
- burst activity;
- inactivity;
- fade;
- permanent retirement.

### Phase 3 — All 76 dimensions

Populate scenario families across the cognition and agency/personality batteries.

Start with uniform random trait selection.

### Phase 4 — Batch generation

Add:

- local model generation;
- OpenRouter generation;
- operator paste/import;
- duplication checks;
- provider rollover.

### Phase 5 — Adaptive steering

Introduce uncertainty and regression-driven sampling.

### Phase 6 — Holdouts and generalization

Add development, shadow, and canary scenario pools.

### Phase 7 — Trait interaction models

Move from isolated scores toward conditional estimates and cross-trait effects.

---

## 22. What This System Is Measuring

It is important to state precisely what the system would and would not establish.

The SSPN would **not** prove that Piper possesses a human psychological trait in the biological or phenomenological sense.

It would measure something operationally narrower and more useful:

> the statistical regularity with which Piper exhibits defined behavioral patterns across varied social situations over time.

That is sufficient for engineering.

If humility is operationally defined by observable responses to correction, praise, status, uncertainty, and disagreement, then the system can estimate the stability and context sensitivity of those responses.

The same logic applies to many cognition dimensions.

---

## 23. Expected Benefits

The architecture provides several advantages over formal benches alone.

### Continuous measurement

Traits are observed between formal benchmark runs.

### Naturalistic context

The evaluated behavior occurs inside ordinary interaction rather than explicit test prompts.

### High sample volume

Cheap generation and asynchronous delivery permit large numbers of observations.

### Context sensitivity

Scores can be decomposed by interlocutor, tone, status, evidence quality, and history.

### Regression detection

Changes after architectural upgrades can be detected without waiting for a full battery.

### Adaptive efficiency

Measurement effort can migrate toward uncertain or unstable dimensions.

### Provider independence

Pre-generated inventory decouples runtime reliability from model availability.

### Longitudinal analysis

The database can reveal drift over days, weeks, and months.

---

## 24. Main Risks

The design also creates significant measurement risks.

### Test recognition

If Piper infers the hidden structure, ecological validity declines.

### Scenario leakage

Repeated templates can teach response patterns rather than measure general behavior.

### World-model pollution

Synthetic actor claims can enter persistent memory as if externally verified.

### Evaluator drift

Changing rubrics can create apparent behavioral change where none occurred.

### Generator bias

One model may produce a narrow style of disagreement, praise, criticism, or social pressure.

### Overmeasurement

Excessive synthetic activity can itself alter Piper's apparent social environment.

### Goodhart effects

Once development decisions optimize directly against these scores, the scores can become targets rather than measurements.

These risks argue for formal benches and synthetic ecological measurements being maintained as **independent complementary instruments**.

---

## 25. Broader Interpretation

The most interesting interpretation of the design is not "228 fake accounts."

It is a **programmable society used as a measurement instrument**.

The synthetic ecology has controllable variables:

\[
E = \{identity, status, tone, timing, evidence, history, pressure, topic\}
\]

Piper produces behavioral outputs:

\[
R = \{language, action, confidence, correction, memory, escalation, abstention\}
\]

The evaluation system estimates latent behavioral dimensions from the mapping:

\[
E \rightarrow R
\]

Over time, this creates a rich longitudinal dataset that can be compared with formal benchmark scores, software releases, memory changes, model changes, and other architectural interventions.

The result is closer to a laboratory embedded inside the agent's ordinary life than to a traditional benchmark suite.

---

## 26. Conclusion

A persistent agent requires persistent measurement.

Static benches remain necessary because they offer controlled, reproducible tests. They are insufficient, however, for understanding how cognition, personality, and agency manifest during ordinary operation.

The proposed Synthetic Social Probe Network adds a second layer.

Disposable social actors participate in Glademoot with irregular timing and plausible finite lifecycles. Hidden scenario objectives create situations relevant to one or more of Piper's 76 tracked dimensions. Message generation is asynchronous and provider-independent. Responses are scored outside the conversation and accumulated into longitudinal estimates. As the dataset matures, trait sampling moves from uniform randomness toward adaptive measurement based on uncertainty, importance, staleness, and regression risk.

The architecture can begin extremely simply:

\[
random\ trait
\rightarrow
queued\ message
\rightarrow
temporary\ actor
\rightarrow
Piper
\rightarrow
score
\]

Yet it has a path toward a much richer system:

\[
adaptive\ experimental\ ecology
\rightarrow
continuous\ behavioral\ model
\rightarrow
regression\ detection
\rightarrow
targeted\ improvement
\]

The primary engineering principle is straightforward:

> **Do not ask the agent whether it has a trait. Create situations in which the trait matters, observe what the agent does, and measure the pattern over time.**

---

## References

1. Mehl, M. R. (2017). *The Electronically Activated Recorder (EAR): A Method for the Naturalistic Observation of Daily Social Behavior*. Current Directions in Psychological Science, 26(2), 184–190. https://doi.org/10.1177/0963721416680611

2. Wright, A. G. C., & Zimmermann, J. et al. (2019). *Applied Ambulatory Assessment: Integrating Idiographic and Nomothetic Principles of Measurement*. Psychological Assessment. PMCID: PMC6754809.

3. Conner, T. S., Tennen, H., Fleeson, W., & Barrett, L. F. (2009). *Experience Sampling Methods: A Modern Idiographic Approach to Personality Research*. Social and Personality Psychology Compass. PMCID: PMC2773515.

4. Trull, T. J., & Ebner-Priemer, U. W. (2013). *Ambulatory Assessment*. Annual Review of Clinical Psychology, 9, 151–176. PMCID: PMC4249763.

5. Meijer, R. R., & Nering, M. L. (1999). *Computerized Adaptive Testing: Overview and Introduction*. Applied Psychological Measurement, 23(3), 187–194. https://doi.org/10.1177/01466219922031310

6. Luecht, R. M. (2016). *Computer-Adaptive Testing*. Wiley StatsRef: Statistics Reference Online. https://doi.org/10.1002/9781118445112.stat06405.pub2

7. Xu, C., Guan, S., Greene, D., & Kechadi, M.-T. (2024). *Benchmark Data Contamination of Large Language Models: A Survey*. arXiv:2406.04244.

8. Sainz, O., Campos, J. A., García-Ferrero, I., Etxaniz, J., Lopez de Lacalle, O., & Agirre, E. (2023). *NLP Evaluation in Trouble: On the Need to Measure LLM Data Contamination for Each Benchmark*. arXiv:2310.18018.

9. Singh, A. K., Kocyigit, M. Y., Poulton, A., Esiobu, D., Lomeli, M., Szilvasy, G., & Hupkes, D. (2024). *Evaluation Data Contamination in LLMs: How Do We Measure It and (When) Does It Matter?* arXiv:2411.03923.

---

## Proposed Name

**SSPN — Synthetic Social Probe Network**

Alternative names:

- Synthetic Agent Ecology
- Behavioral Probe Ecology
- Longitudinal Agent Phenotyping System
- Synthetic Social Assessment Layer
- Agent Ecological Measurement Network

Of these, **Synthetic Social Probe Network** describes the engineering function most directly, while **Synthetic Agent Ecology** best describes the broader conceptual idea.
