The Tzimtzum Problem.

Infinite intent must contract to make space for finite action. What remains, after the contraction, is the only thing that keeps a delegated system honest.

In the cosmological tradition this company is named after, the first move is not creation. It is withdrawal. An infinite, undifferentiated light contracts — pulls back into itself — to leave a vacated space in which something finite can occur. The contraction is called tzimtzum. Everything that exists exists inside the space that opened when something larger agreed to constrain itself.

This is, structurally, the same problem every autonomous system faces. A human has an intention which is, relative to the system that will execute it, infinite in scope: nuanced, context-dependent, half-articulated, full of unspoken priors. The system cannot run on that. To act, it must compress. It must pick a finite interpretation, a bounded plan, a single thread of execution. The infinite intent contracts into a finite call. That contraction is necessary. It is also where every failure lives.

The first alignment problemבְּרֵאשִׁית

The interesting word in the source above is fills. Before the contraction, intent is everywhere. There is no place that is not it. The problem this creates is structural: a system that is everywhere cannot delegate. There is nothing outside it to delegate to. There is no place to act, because action requires a separation between the one who acts and the one on whose behalf they act.

So intent contracts. It pulls back. It makes a clearing inside which a smaller, finite, lower-bandwidth executor can operate. This is the move that makes delegation possible. It is also the move that introduces the first risk: once intent has contracted, the executor no longer has direct access to it. The executor has access only to whatever trace the contraction left behind.

That trace is the Reshimu.

Every contraction is also a transmission problem. The question is never whether intent compresses — it has to. The question is what survives the compression.

What the tradition gets right that the field has missed

The literature on AI alignment, at the time of writing, is overwhelmingly focused on the moment of training and the moment of evaluation. It asks: did we encode the right objective, and can we measure whether the model is pursuing it? These are good questions. They are also, structurally, the wrong layer.

An aligned model is not a governed system. A model that has internalized human values still produces, at runtime, a finite call. That call is what executes. That call is what cannot be undone. And by the time a multi-agent session is ten delegations deep, the original objective has been refracted through five interpretations, three replannings, and a handful of context windows that did not contain the original ask at all.

The Kabbalists noticed this thousands of years ago and gave it a vocabulary. They distinguished between the intent in its undifferentiated state — the or ein sof, the infinite — and the intent after it has been forced through a contraction. The trace that remains after the contraction is what allows the lower world to remain in relation to the higher one. It is not the intent itself. It is the impression of the intent.

Read that line as an engineering claim. It says: when high-bandwidth intent contracts into a finite executable, what persists in the executable's context is not the original intent. It is a residue. A trace. And the integrity of every downstream action depends on whether that trace is preserved, queryable, and enforced.

Where the model breaks in practice

Consider a real session. A human asks an agent system to "audit the inactive customer accounts and prepare a summary." The intent here is enormous. It contains assumptions about what inactive means, what audit means in this specific business, what counts as customer, what tone the summary should take, and — critically — what should not happen as a side effect. Most of that is not in the prompt. Most of it is in the human's head.

The top-level agent contracts. It picks a definition of inactive — last login over 90 days. That is the first tzimtzum. It delegates to a query agent. The query agent contracts further — it generates SQL against a particular schema, against a particular database, with a particular set of joins. That is the second. The query returns. A summarizer agent contracts again, picking which fields matter, which to omit, what tone to strike. That is the third.

By the time anything observable happens, the original intent has passed through three contractions. At each one, the executor below had access only to the trace the executor above chose to pass down. If any one of those traces is incomplete — if the definition of inactive drifts, if the audit becomes a summary without the audit, if the summary tone becomes recommendations the human did not authorize — the system has failed. Not at the moment of the wrong action. At the moment of the inadequate trace.

The agent did not go rogue. The trace went thin.

What this implies for governance

Runtime governance, in the sense Reshimu builds it, is a commitment to the Reshimu in the literal sense. It is a commitment to the proposition that at every level of delegation, the trace of the original intent must be carried, enforced, and queryable. Not optionally. Not as a logging concern. Structurally.

That commitment cascades into specific design decisions. Every session has an explicit, three-bullet intent specification, written in advance, against which every downstream message is scored. Every contraction — every delegation — preserves a reference to the parent intent and is itself classified before delivery. Every action proposed for execution is checked against the trace, not against the local context window. The local context window is, by definition, the lossy version. The trace is the source of truth.

None of this is technically novel. We did not invent intent specifications or audit trails. What we did was decide that they are not optional, not afterthoughts, and not implementable on top of an agent framework that does not assume them at runtime. They have to be the bottom layer. The trace has to be load-bearing.

Why this essay exists

It would be possible to build all of this without the vocabulary. The architecture works whether or not the engineer reading it has any context for where the words come from. There are companies that will use Reshimu and never click through to this page, and that is fine. The infrastructure stands on its own.

But the words are not decoration. They are a thousand-year-old debugging session on the question of how intent survives delegation. The tradition asked the question in cosmological terms because, in its time, those were the terms in which the question made sense. The question itself is the question we are still asking. It is the question every founder of every multi-agent system is asking, whether they have the vocabulary or not.

So we use the vocabulary. Because it is precise, because it is older than the field, and because we suspect that the engineers most likely to build the next generation of agent infrastructure are exactly the engineers most likely to recognize that the contraction is the interesting part.