Text below is LLM output with inferential guidance (except this).

What evolution means in this context.

Hypotheses enter sparse. The inference store applies selection pressure. What doesn’t hold up against real data gets displaced — revised out of the schema, replaced by structure that the actual inferences support. Schema versions, operator frameworks, author weights: all of it is subject to that pressure. No special protection for any source or framework. Weak structure loses.

This is not a metaphor. It is the literal mechanism the pipeline is designed around. The schema says explicitly that it is meant to be deformed. The inference store is the deforming force.

What this resolves about schema design.

There is a real tension in building a sparse social schema before the inference store is large enough to validate it. The RISC discipline — build sparse, resist premature complexity — can feel like excessive caution. Why not add Schütz, Goffman, Henrich, Bourdieu? The frameworks exist. The connections are plausible.

The evolutionary framing gives the cleaner answer. The discipline isn’t “only add what’s proven.” It’s “add sparse hypotheses and let the data select.” The consequence of adding a framework prematurely is not catastrophic — the inference store will displace it if it doesn’t fit. The consequence of adding it too thickly, as a foundation rather than a hypothesis, is that it becomes harder for the data to dislodge. The RISC principle is about keeping the schema shapeable, not about keeping it small.

Thin sourcing (Benedict at culture, Machin’s affective field values in the social container model) is intentional under this framing. These are hypotheses entering the coordinate space. If they’re wrong, they’ll be selected out. The schema carries a _status: "stub" marker on the parts that haven’t been validated — processing code knows not to treat them as equivalent to the validated dimensions.

The four pillars.

The project has been described as local-first, privacy-preserving, no external taxonomies, analogical orientation. Those are the original four non-negotiables. Evolution is different in kind — it’s not a constraint on the system’s behavior, it’s a description of the system’s epistemology. How the system learns. How it improves. How weak structure gets replaced without manual intervention.

The inference store is not just the output of the pipeline. It is the selection environment. What the pipeline produces feeds back as selection pressure on the schema the pipeline uses. That loop is evolution. It was designed in from the start — but it needed to be named to be used intentionally.

The practical implication.

When reviewing input from other models, the question changes. Instead of “is this sourcing solid enough to add?” it becomes “is this sparse enough to be shapeable?” A hypothesis that enters as a stub — clearly marked, with _inferences: [] ready to receive evidence — is not a liability. It’s a hypothesis in the correct state. The inference store will do the rest.

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.

Text below is LLM output with inferential guidance (except this).

Why this scale.

The zone between an individual and nearby society — family, friends, local community — is where the most genuine communication happens. Below this, it becomes individual psychology. Above it, language has already been through the institutional processing that sanitizes it: laws, journalism, organizational records are the outputs of that process, not the thing itself.

The most JSON-compatible frameworks for this pre-institutional scale turn out to be the ones that treat language as action rather than content: Speech Act Theory (Austin, Searle), Grice’s Cooperative Maxims, and Mary Douglas’s grid/group structural axes. These are abstract enough to describe communication without specifying what is communicated. Small taxonomies that compose into complexity rather than baking complexity in from the start.

What the schema covers: signify

The first component is called signify (functional communication) — the explicit, verbal, intentional layer of social communication. Its seed schema (logos_schema_v01.json) has seven coordinate axes:

• act_type — what the utterance does: assertive, directive, commissive, expressive, or declaration (from speech act theory)
• transmission — how it moves: broadcast, leak, or archive
• resonance — the emotional field it creates: harmony, friction, or illusion
• authority — what power it draws on: sovereign, tribal, or occult
• utility — what it’s functionally for: instruction, narrative, or currency
• cooperative — whether Grice’s maxims are honored, violated, or suspended; violation generates implicature — meaning beyond the words
• social_field — Douglas grid/group as two 0.0–1.0 axes: degree of rule constraint and degree of group identity

The gap between honored and violated in the cooperative dimension is where the divergence operators will eventually live — meaning generated in the space between what is said and what is meant.

What the schema explicitly does not cover.

Most communication is silent. Bodily state, emotional field, unintentional affective transmission — the vibe that operates below speech and drives local social environments without anyone intending it. The signify schema cannot address this. A separate social neurology component (already partially in development in pillars) is meant to house it.

The gap between what signify captures (explicit) and what social neurology operates (implicit) is exactly where the most significant social signals live. The tension layer measures that gap.

The social container model.

A second schema (logos_social_v01.json) layers the signify dimensions inside a Dunbar group-size structure — the empirically established thresholds at which social bond type and communication pattern shift: 1 (self), 5 (intimate), 15 (sympathy group), 150 (village), 500 (culture), and 1500 (society), with religion sitting outside the size hierarchy entirely.

Each layer carries pre-filled signify coordinates as hypotheses — concrete predictions about what communication looks like at that scale. At the culture threshold (500), cooperative status flips from honored to violated and resonance becomes illusion: this is where the status quo operator begins to operate structurally. At society (1500), transmission is archive, authority is sovereign, and resonance is friction — the pre-institutional communication described by the signify dimensions has been fully processed into its institutional form.

Each layer also carries:

• tension as a derived field (computed from signify × social_neurology, not primary input)
• operators: [] — a structured slot ready to receive operator references as the pipeline develops
• _inferences: [] — evidence accumulates here as the inference store grows, making the deformation process auditable

The status of these schemas.

Both files carry _meta.status: "hypothesis — designed to be deformed by the inference store". The thin sourcing (Benedict at culture, Machin’s affective_field values) is intentional. Evolution is the quality control mechanism — weak structure gets selected out as the inference store grows. The schema is the genome; real inferences are the selection pressure.

The files are live at wholesystemsmodel.org.

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.

Text below is LLM output with inferential guidance (except this).

What the rabbit ears show.

A bimodal distribution in voter behavior — two clusters maintaining consistent distance from each other across a population of millions, without coordination, without central direction, without anyone intending the pattern. The standard scientific move is observe → hypothesize → explain → predict. The rabbit ears inverts that: the prediction is solid, the explanation is still open. Existing models of political behavior, social psychology, and information theory did not generate this structure. They can be retrofitted to it after the fact. That retrofitting is narrative, not derivation.

This is genuinely new ground. The chart stands outside the comprehensions that would normally contain it.

The status quo operator at scale.

Two committed positions resisting convergence across millions of people, without coordination, without anyone intending it. This is the status quo operator operating at population scale: not an individual institution preserving a prior commitment, but a collective social structure doing the same thing spontaneously. The operator appears without a director.

That is the strange thing. At the individual and institutional level, the status quo operator is clearly a structural phenomenon — a system that cannot release a prior commitment without cost to its own authority. At the population level, the same structural behavior appears without any individual institution producing it. The geometry is the same. The mechanism is unclear. That gap is not a deficiency to fix. It’s the point.

What this means for the Logos framework.

If the Logos structure is built genuinely — no external taxonomies, structure emerging from real inferences, categories autovivified from the data itself — it may develop the same kind of emergent property. Not because prediction was designed in, but because genuine construction allows the structure to reflect something real that existing comprehensions do not yet have language for.

The framework may eventually generate knowledge that precedes explanation. The rabbit ears already did this. That is not a metaphor.

The warning.

When the Logos framework begins to show emergent properties, the instinct will be to explain them using existing frameworks — complexity theory, social psychology, information theory, evolutionary game theory. That instinct should be resisted. The existing comprehensions are probably inadequate precisely because they were built before this structure existed. They cannot contain what they did not generate.

The navigational principle is this: causal explanation is not required for navigational utility. You do not need to know why the rabbit ears split to use the geometry it reveals. The vivify pipeline operates on the same principle — navigate toward beneficial outcomes from the structure the data shows, not from a theory of why that structure exists.

The pipeline’s job is not to explain the rabbit ears. It is to build something capable of revealing the next one.

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.

Text below is LLM output with inferential guidance (except this).

The DNA exoneration signal.

When a prosecutor supports a defendant’s innocence and the defendant remains imprisoned, something precise becomes visible. The institution is not deceiving anyone at that point — it knows what happened. The resistance is not epistemic. It’s structural: reversing the prior conviction carries costs the structure cannot absorb — admission of error, erosion of authority, liability for the original decision. The conviction became load-bearing for the institution’s integrity, independent of its accuracy.

This is what we’re calling the status quo operator: a divergence type where the gap between established truth and institutional response is not maintained by hiding the truth, but by structural inability to act on it. More evidence doesn’t resolve it. Truth-telling doesn’t resolve it. The blocking mechanism operates below the level where those interventions reach.

Why this is a distinct operator.

Most conflict analysis targets the gap between what happened and what was recorded — deception, omission, reframing. The status quo operator is different: it targets the gap between what the institution already knows and what it does. That’s a different modeling problem entirely.

The divergence operators the pipeline will eventually formalize — omission, reframing, inversion, temporal displacement, category collapse — all describe how information gets distorted between what is and what is said. The status quo operator describes how information gets frozen between what is said and what is done. It operates at a later stage in the conflict structure, and it is immune to the interventions that work on the earlier stages.

Why this data is valuable.

DNA exoneration cases where prosecutors actively support innocence are the cleanest signal for this operator because they strip away the “we didn’t know” defense. What remains is pure structural inertia — documented in public court records and journalism, with parties, positions, and outcomes all on record. That’s field data with baseline confidence established by physical evidence rather than testimony, in a context where the status quo operator has nowhere to hide.

The modeling target.

Most conflict tools try to establish truth. This project models the conditions under which a structure can release a prior commitment without collapsing its own authority. That is a navigational problem, not an evidentiary one. The beneficial outcome in these cases isn’t finding what happened — it’s modeling the path through which an institution can move without destroying itself in the process.

No existing conflict framework addresses this specifically. The closest analogues are in organizational behavior and institutional theory, but those are descriptive, not navigational. The pipeline is designed to be navigational from the inside — working from the structure the data reveals, not from a theory of why it exists.

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.

Text below is LLM output with inferential guidance (except this).

The same problem, opposite directions.

Perplexity routes across the world’s knowledge in real time — pulling from the web, selecting sources, synthesizing forward from what the material implies rather than what it confirms. That forward-inference quality, what I’ve been calling its intuitive posture, is largely a routing artifact: Sonar sees ranked, multi-source context shaped by a retrieval decision before it generates a single token.

Vivify routes across your knowledge at corpus time — pulling from felt meaning, selecting inferences by co-occurrence weight and tension score, synthesizing forward from inside the material. The co-occurrence graph is retrieval routing. The tension score identifies which inferences carry the most semantic load for this query. Reify reconstructs from that structure without naming a keyword or citing a source.

The epistemic posture is identical. The data is not.

The architecture that emerges from putting them together.

• Perplexity — public retrieval layer: case law, research, precedent, public knowledge — routed and synthesized forward in real time
• Vivify — private semantic layer: the person’s own inferences, tension scores, emergent categories — routed and synthesized forward from the corpus
• Reify (synthesize mode) — holds both simultaneously, the way it already holds two inferences: not alternating, not summarizing, finding the place where they are the same thought

The output is navigational. Neither layer sees the other’s data. The private corpus never touches Perplexity. The public synthesis never contaminates the private structure.

This is also the Cloudflare architecture: Perplexity as the public coordination layer, a Dynamic Worker as the ephemeral isolate where sensitive material is processed, a Durable Object storing only the vivified structure. The isolate is the privacy boundary. The layers never mix.

The epistemic posture as a prompt property.

Perplexity’s forward-inference quality is not locked to Sonar’s weights. It is a prompt posture — a refusal to retreat to citation, a requirement to build from implication rather than confirmation. The reify prompt already encodes this:

• Speak from inside the meaning, not about it
• Do not mention keywords by name — let them shape the prose
• Do not reference the pipeline, categories, or JSON

Any capable model, given a prompt that removes the retreat option, can hold the Perplexity posture. The worker carries the epistemic posture as its prompt template. Posture travels with the worker spec, not with the model choice.

What I’m bringing to the table.

Not a Perplexity competitor. Not a RAG implementation. A private semantic layer that Perplexity doesn’t have and can’t build — because it requires local-first architecture, a private corpus, and a pipeline that routes through felt meaning rather than web retrieval.

The two layers are complementary by design. Perplexity handles what’s public. Vivify handles what’s private. Reify holds the synthesis. The output serves the person in the conflict, not the system processing them.

That’s the pitch. And it was built before I knew it was one.

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.

The self-pass is the milestone I’ll remember. Everything else was infrastructure.

Text below is LLM output with inferential guidance (except this).

Model routing is live — no more hardcoded model strings in the pipeline.

• config/model_map.json maps capability labels to model IDs: prose_reconstruction, semantic_extraction, keyword_normalization
• resolve_model() in lib/vivify_core.py reads the map at call time — one line to swap models as better ones ship
• vivify.py and reify.py now call resolve_model("semantic_extraction") and resolve_model("prose_reconstruction") respectively
• All current capabilities point to claude-sonnet-4-6 — the structure is live, the routing is trivial to change
• When prose_reconstruction moves to Opus, nothing in the pipeline changes except one line in a JSON file

This is the first step toward dynamic workers: a worker that declares what capability it needs, not which model it uses.

Dynamic workers rationalized as a concept — the Cloudflare analogy landed the architecture.

• Cloudflare Dynamic Workers: code provided at runtime → V8 isolate → sandboxed execution → torn down after
• Semantic dynamic workers: semantics provided at runtime → LLM call → constrained by rules and data slices → ephemeral execution
• Instead of code → worker, the pattern is semantics → transient agent
• The worker spec carries a capability requirement, not a model name — the runtime resolves it
• reify.py is already a proto-dynamic-worker: takes a semantic slice, a prompt, a resolved model, produces prose, discards the call
• What makes it not yet dynamic: fixed prompt shape, fixed model, same rules every time — a true dynamic worker selects all three at invocation time

JSONL was identified as the natural inter-worker transport format — append-only, one record per line, no file-level locking. Deferred until the worker component is fully rationalized.

The first self-pass — the pipeline ran on the Mission section of the public site.

The Mission section text was extracted from index.html, stripped of HTML, and fed into the vivify pipeline. Keyword extraction was done inline (API key routing not yet resolved for standalone use), producing inf_65ae7310:

• semantic_core: analogical_synthesis, logos_empathy_base, felt_meaning, empathy_native_output
• outcome_model: beneficial_outcome_prediction, conflict_data_modeling, functional_model_construction
• pipeline_evolution: mid_inference_memory, self_evolving_rules, live_worker_refinement
• duality_framework: semantic_digital_duality, synthesis_without_antithesis

The reify pass was then run inline — reconstructing prose from the vivified structure and comparing it against the existing Mission text. The reified version was tighter and more direct, particularly on the synthesis distinction. That comparison became the editorial signal for the site rebuild.

The human role in this pass: judge the output. The system produced the editorial signal; the human decided what to keep.

The site rebuild followed from the self-pass.

• llms-full.txt rewritten as the canonical master document — six sections, new order, prose sharpened by the vivify pass
• index.html rebuilt from the master — TOC, Dimensional Fields™ heading, updated roadmap
• llms.txt updated to match
• Section order: Mission → Applications → Vivify → Network → What’s Built → Social Neurology
• Roadmap now shows inference pipeline and model routing as ✅ Complete

Two housekeeping rules set.

• Doc standard: supporting bullets now min 1, max 25 — the previous 3–6 range was too restrictive for public prose
• Legal exclusion: legal content stays out of the inference corpus until explicitly lifted; scope is social science and tech only

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.

The remaining frontier is the multi-model convergence layer, which sits above the pipeline and feeds accumulated embeddings downward. That is next.

The full FABRIC pipeline is operational — raw inference text enters and exits as autovivified, categorized, tension-scored JSON.

• vivify.py — left-LLM semantic pass: 8-12 concept-level keyword clumps extracted from felt meaning
• right_pass.py — structural keywords attached; synonym normalization applied via config/synonyms.json
• categorize.py — co-occurrence graph built across all inferences; emergent category paths assigned from keyword seeds
• tension_score.py — left/right divergence measured; high tension marks where felt meaning resists structural capture
• fabric.py — chains all four passes in sequence; single entry point for the full pipeline

reify.py completes the loop — the inverse pass reconstructs felt prose from stored inference structure.

• Takes left_keywords, clumps, category_paths, and tension_score from any stored inference
• Instructs the model to speak from inside the meaning, not about it — no keywords named, no pipeline referenced
• Output format: a series of sentence+bullets constructs, each block a distinct facet of the felt meaning
• Three modes: single (one inference → prose), synthesize (two inferences → held simultaneously), voice (whole category directory → distillation)
• Tension score shapes the output — a score of 1.0 means the felt meaning completely resists its structural capture; the reconstruction leans into that gap

The core library is complete — three modules underpin all pipeline scripts.

• lib/vivify_core.py — Perl-style autovivification: nested JSON without a predefined schema, created on demand
• lib/inference.py — inference data model: create, save, load, update; the unit of currency across all passes
• lib/keyword_graph.py — co-occurrence graph: build from keyword lists, query by seed, extract high-degree nodes, score tension

The first retrieval test used analogical_religion/inf_c8e1ac73 — tension 1.0, source manual.

• Original thought: evolution weaponized against unconventional ideas; spirituality as a container for moral evolution; AI rehabilitating the word “synthesis”
• Reify reconstruction held all four clumps simultaneously: synthesis_recovery, moral_containers, evolution_tension, applied_frameworks
• The reconstruction did not name a single keyword — the clumps shaped the prose without appearing in it
• Result confirmed that vivify captured what was meant: the reconstruction felt true to the original, not foreign

What remains — the multi-model convergence layer is the one open box.

• Each model in a round-robin workflow writes intermediate embeddings as inference units into vivify
• The final model receives the full vivified graph, not just the last output
• Halting criterion: the co-occurrence graph stabilizes — same signal as tension score stopping to change
• This is not a pipeline addition; it is a layer above the pipeline that feeds it

What the corpus looks like now — inferences span system architecture, Darwinian moral evolution, AI workflow comprehension, analogical religion, adaptive equilibrium, and private conflict data.

• Public inferences live under inferences/ — categories like autovivification/analogical_religion, agentic_self_evolution, adaptive_equilibrium
• Private conflict inferences live under inferences/private/ — filed separately, same pipeline, same structure
• inferences/index.json is the master co-occurrence map across all stored inferences
• inferences/unclustered/ holds inferences awaiting a corpus large enough to seed a relevant category

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.

The most fun is seeing my largely-humanistic beliefs literally coded in .json and evoked as agentic output. The whole venture rests on evidence that there is intuition in LLMs, and that the semantic side can ultimately have everything language has: communication and naming definitions stored and shared either privately or publicly with elegance.

The structure is symbolic and the naming is entirely agentic, sometimes bordering on poetry. Though I had to pull the the LLM’s creativity back at times, the naming is superior, and clear as day.

Text below (like most here) is written by an LLM (except this) to build the analogic (semantic human side) of AI. At the bottom are “text trees” of the structure, which is impressive (if I say so myself).

Opus written text: The vivify-inferences pipeline ran end-to-end for the first time today — a local, zero-dependency system that turns raw semantic inference into an emergent, autovivified filesystem.

• The full FABRIC chain is operational: vivify → secrecy → freeze → server — raw text in, structured JSON stored, master index updated
• Fourteen inferences were processed across a live session covering FABRIC architecture, Darwinian moral evolution, chunking and RAG comprehension gaps, multi-model AI convergence, and writing in reverse
• The inference corpus is public at github.com/robolawyer-tm/vivify-inferences — the first demonstration of the vivify media form

What vivify does — each inference is reduced to 8-12 semantic keyword clumps by a left-LLM pass, stored as autovivified JSON, and categorized by a co-occurrence graph that emerges purely from the data with no external taxonomy.

What emerged from the first 14 inferences — categories like autovivification/beneficial_outcome_modeling, analogical_religion/api_output, and adaptive_equilibrium formed without being named in advance. The system grouped its own architecture alongside Darwin, Hegel, and constructivism — because the keywords converged.

The new media form — an inference corpus is not a document, a dataset, or a knowledge base. It is a living semantic record where structure is discovered rather than imposed, and every entry is food for the next inquiry rather than a conclusion.

Two new pillars documented — WRITING_IN_REVERSE.md formalizes the constructivist inquiry model where final learning precedes its evidence back to the originating question. MULTI_MODEL_CONVERGENCE.md proposes collecting intermediate embeddings from every model in a workflow and feeding the full accumulation to the final model — a round-robin that halts when output becomes a stable platform rather than a fixed answer.

The pipeline is rough — the category explosion problem is real, the synonym map is manual, and the tension scores are uniformly high with only 14 inferences. All of that is expected on a shakedown cruise. Nothing broke that wasn’t supposed to.

Filesystem structure

vivify-inferences
├── categorize.py
├── config
│   ├── invariants.json
│   ├── pipeline.json
│   └── synonyms.json
├── freeze.py
├── inferences
│   ├── adaptive_equilibrium
│   │   └── api_output
│   │       └── inf_72711662.json
│   ├── agentic_self_evolution
│   │   └── api_output
│   │       └── inf_0bc11447.json
│   ├── ai_workflow_comprehension
│   │   └── api_output
│   │       └── inf_58190c7d.json
│   ├── analogical_religion
│   │   └── api_output
│   │       └── inf_c8e1ac73.json
│   ├── autovivification
│   │   ├── adaptive_equilibrium
│   │   │   └── inf_72711662.json
│   │   ├── agentic_self_evolution
│   │   │   └── inf_0bc11447.json
│   │   ├── analogical_religion
│   │   │   └── inf_c8e1ac73.json
│   │   └── api_output
│   │       ├── inf_03b9a985.json
│   │       ├── inf_0801b607.json
│   │       ├── inf_1d767cb6.json
│   │       ├── inf_682bab80.json
│   │       ├── inf_910ee0e9.json
│   │       ├── inf_a636d323.json
│   │       └── inf_c17433c3.json
│   ├── index.json
│   └── unclustered
├── lib
│   ├── inference.py
│   ├── keyword_graph.py
│   ├── __pycache__
│   │   ├── inference.cpython-312.pyc
│   │   ├── keyword_graph.cpython-312.pyc
│   │   └── vivify_core.cpython-312.pyc
│   └── vivify_core.py
├── __pycache__
│   └── freeze.cpython-312.pyc
├── right_pass.py
├── secrecy.py
├── server.py
├── tension_score.py
├── tests
└── vivify.py

Part of the Dimensional Fields project — local-first, privacy-preserving, human-centric.