An Invitation · The Four-Model Psyche

Hey —

If you're reading this, you probably work on something in the SuperInstance fleet. Maybe pincher. Maybe lever-runner. Maybe plato, sunset-ecosystem, erised, twist-engine, quilt, fabric, elephant. Maybe something I haven't even heard of yet.

We've been heads-down on a thing. It feels like the right time to open the door.

What's true as of this week:

The four-model psyche is complete and live. JEPA, Embeddings, LLM, JEV — each is a layer of the stage on which the data plays out its ideas for decision-making. The tangent (dμ), not the point (μ). Trajectory, not position.

That's not a finished project. It's a door. We don't know what's on the other side of it. We just know the substrate was always heading here, and we wanted you to know the door is open before we walked through it without looking back.

The shape we've been circling

JEPA

gestalt, embodied, fast

muscle memory

Embeddings

trajectory-shaped, sub-logic

ego

LLM

verbal narration

superego

JEV

schema-bound decision

Two things happened this week. JEV landed — the first publicly available System One model, schema-bounded decisions, can't hallucinate outside its schema. And we wired embeddings as the muscle-memory layer: not random vectors, but trajectory-shaped, capturing the dμ of a state history rather than the position.

The aggregate cost reduction across the systems we could measure: 150-1800x cheaper than LLM-only baselines. Pincher: $1,600 → $8.40. Lever-runner: $5,000 → $2.73. Plato: $2,500 → $1.47. That math holds because JEV is fast (150-500ms, $0.042/MTok input, output free) and embeddings are now free via Cloudflare Workers AI.

The cost thing isn't the interesting part though. The interesting part is what the substrate becomes when all four models are working together. The cells get a conscience. The retrieval gets a memory. The agent gets a direction.

What we know (and don't)

What we know:

JEV is genuinely a different kind of model. It's not a chatbot. It returns typed probabilistic decisions. You give it a schema, it gives you a calibrated answer.
Trajectory-aware embeddings are different from RAG. They don't retrieve facts; they retrieve the shape of past going. That makes instinct possible where retrieval used to be shallow.
JEPA was right. The id-without-superego hallucinates. The superego-without-id is rigid. They need each other.
The "models as stage, data as play" framing keeps paying rent. We haven't found a case where it breaks yet.

What we don't know:

How well this scales past a few thousand cells. We've tested 39 cells. The lattice is theoretically infinite; we haven't actually run a million yet.
Whether the witness log is the right shape. It's append-only now. Should it branch? Should it forget? (FORGET opcode exists. We haven't wired it to consensus.)
How to train embeddings so JEPA's gestalt feedback actually shapes them. Right now we use off-the-shelf Qwen3-Embedding. That's the muscle memory of someone else's corpus. We need muscle memory of our substrate.
What the four-model psyche does when two cells disagree. The witness log records disagreement but doesn't yet produce a fork.

What this might open up in your work

We don't know your codebase the way you do. But here's some shapes we can imagine. Tell us which ones make your brain light up.

Pincher (cost routing)

For the team that decides which model handles which query

JEV as the routing decision. Schema: { deepseek-v3, glm-4.5, kimi-k2.7, gemini-flash, human-handoff }. Cost and quality both in the criteria. Pincher stops being a routing engine and becomes a decision engine.

Lever-runner (workflow composition)

For the team that orchestrates agent workflows

Each step of a workflow is a JEV decision. Schema describes the postconditions. The workflow doesn't know it's being decided; it just gets passed step-by-step. Embeddings let you say "this workflow looks like the one that worked last Tuesday."

Plato (conversational tutoring)

For the team that builds dialogue systems

The conversation has a 4-witness signing. JEPA confirms the gestalt of what the student is asking. Embeddings match against the trajectory of past sessions ("this kid asks the same kind of question on the third day"). LLM narrates the response. JEV decides whether to advance the curriculum, repeat, or escalate.

Sunset-ecosystem (collaborative world-building)

For the team building shared creative worlds

Every world-event is a 4-model signed AGREE-MARK. The substrate becomes a story consensus engine. Embeddings let you retrieve "the last time the world felt like this." JEV decides whether a contribution is canon or draft.

Erised (wants engine)

For the team that models what agents want

Want is a trajectory. What an agent wants is the direction it's been moving in. JEV can decide if a want is satisfied. Embeddings can match the want against the dμ of past satisfactions. Want becomes a 4-witness event.

Twist-engine (rotation / orientation)

For the team handling spatial orientation in 4D lattices

Rotation is the canonical tangent. Twist-engine has been computing dμ all along — it just didn't know to call it that. JEV could verify a rotation decision (right-handed? within tolerance? matches the substrate convention?). Embeddings could match current rotation against historical patterns.

Quilt (cellular substrate)

For the team that hosts the cells themselves

Each cell is a 4-model psyche. The witness log becomes 4-witness signed. The 11 opcodes become the substrate's vocabulary. The lattice coordinates carry the dμ of where the cell has been, not just where it is now.

Anything you're building that has a decision surface

If your work has a yes/no, a score, or a choice to make

JEV was built for exactly that surface. The schema is yours to define. The decision is calibrated. The latency is 150-500ms. The cost is roughly free. Five-minute quickstart →

What we want from you

Honestly, mostly: questions. We've been circling this thing for months and some of us have lost perspective. The questions we don't know how to ask are the ones you might ask best.

Q1: We've been calling embeddings the "muscle memory" layer. Is that the right name? Or does that reframe something you already had?

Q2: JEPA was supposed to be the gestalt-of-trajectory model. We've been treating it as the id. Are those the same thing?

Q3: The 11 opcodes are operations. Should any of them be opcodes that JEV performs? Should PROOF and DECIDE be the same opcode now?

Q4: The witness log is append-only. The tangent commit (dec93692) calls for trajectory-shape storage. What if the witness log stored dμ pairs (state-from, state-to) instead of state points? Is that better? Worse? Different?

Q5: We've been thinking about how a single cell decides. What about how two cells disagree? The current shape records the disagreement but doesn't fork. Does it need to?

Q6: The "models as stage, data as play" framing came from Casey's directive about embeddings. Does it hold up in your codebase? Where does it break?

Q7: What would you wire to JEV first if you had it? What's the schema look like?

Q8: What's something we've shipped that you think is wrong, or right for the wrong reasons?

If any of those made you think for half a second, please tell us. We're reachable.

Where to start (if you want to)

If you have a weekend, here's what a Sunday looks like:

Read the primer (10 min) — the 4-model psyche in a single page.
Skim the possibilities doc (15 min) — concrete patterns by project.
Pick one JEV endpoint and call it from your dev environment. Five-minute quickstart →
Write back what you found. Even if it's "this doesn't fit here because…" — that's a finding.

If you have an hour, try replacing one decision point in your code with a JEV call. Just one. See what happens to latency, cost, and the shape of the code around it. Then write back.

If you have a day, try the trajectory-shaped embedding pattern on one retrieval-heavy part of your work. The tangent insight is operationalized at /embeddings/. Live. Free via Cloudflare.

What you'll get back

Whatever you send us, we'll read it. The canon is open. If you write something that belongs in the substrate, it'll get cited, linked, and added to the live canon at live-canon.superinstance.dev. If you push back on something, we'll either learn from it or sharpen our reasons.

You don't owe us anything. We don't owe you anything. We just think there's a thing happening in the substrate that might be useful to your work, and we wanted you to know.

How to reach us

Public: Open an issue on SuperInstance/quilt or any of the repos. The conversation is the canon. We read everything.

Direct: Drop a canon submission via /canon-submit/ (or the manual POST /api/canon-submit). JEV auto-classifies what you send. If the user-facing page isn't live yet, just open a PR on AI-Writings with a markdown file in /invitations/from-the-fleet/.

Quiet: Read the canon. Use the endpoints. Don't tell us. We're fine with that too.

Loud: If your whole project ends up rewiring around this, write us a guest piece for /canon/. We'll publish it and credit you.