Runtime governance
for autonomous agents.
Reshimu is a runtime governance platform for orchestrated autonomous AI agents. We intercept agent actions before they execute, classify them against a session covenant, and either pass, escalate, or block — deterministically, without calling an LLM to judge the call the LLM is about to make.
The problem it solves: agents act. They take real actions in the world — delete records, send emails, execute trades, modify schemas. When something goes wrong, there is no trace connecting the output to what was actually authorized. The capability outruns the accountability infrastructure. Reshimu is the infrastructure.
Four integrity validators. One governance session. Every action classified before it touches the world.
The four validators run inside Atzmut OS — an MCP server that governs the governance session, maintains the session covenant, and produces an auditable trace of every intercept decision. Zero new dependencies on your existing agent stack.
Why this exists.
Origin
I grew up inside a tradition that takes seriously the proposition that the structure of reality is knowable — that the relationships between things, the hierarchy of causes, the protocol by which lower orders receive from higher ones, can be mapped with precision. Chabad Chassidus is not mysticism in the popular sense. It is a systematic inquiry into how structure propagates across tiers. How limitation is constitutive, not incidental. How governance flows downward to enable, not just to constrain.
That framework was in me long before I ever looked at a software system. And when I did start looking at software — at how agents are built, how multi-agent orchestration works, where it fails — I kept seeing the same structural shapes I already knew from a different tradition. Not as metaphor. As correspondence.
The intersection
The Kabbalistic concept of Seder Hishtalshelut — the order of descent, the protocol stack through which reality instantiates from source to manifest — is a description of how constraints produce capability. Each tier-transition is a deliberate limitation: not reduction, but a receiver-oriented act of making receivable. The limitation is the creation. The constraint is the architecture.
The constraint is not the cost of the system. It is the system. This is what the tradition knew. It is what alignment research is slowly discovering.
When I read Yod Aleph Nissan 5741 or the Rashab's Samach Vov, I am not reading philosophy. I am reading architecture. The question it poses — how does intention survive delegation through multiple tiers without degrading into something unrecognizable at the terminus? — is the same question that keeps every serious AI infrastructure person awake. The tradition has an answer. It is not obvious. It took me years to see it clearly. But it is there.
The moment
I was watching an autonomous agent run a multi-step task in production. It completed the task. The output was technically correct. And I realized I had no way to verify that the chain of delegation — from what I had actually authorized, to what the agent had actually done — was intact. The agent acted. The trace was gone. There was no encoding layer that connected the final output to the original human intention. Just capability, executing forward.
That is when the name became obvious. In Kabbalistic cosmology, the Reshimu is the impression — the incorruptible encoding of source that survives even through Tzimtzum, the act of radical self-contraction. Everything else changes. The Reshimu remains. It is not a degraded copy. It is a specification: the fingerprint of what was before, carried forward as structural fact into the contracted regime. Every agent output needs that. Every authorized action needs a trace that is structurally immune to the degradation of delegation. That trace has to be built in, not audited after.
The bet
The bet is that runtime governance at the protocol boundary is the layer that is missing from every agent stack currently in production. Not model-level RLHF. Not post-hoc audit logs. Not wrapper refusal classifiers that sit at the edge and read final outputs. Those all watch the wrong unit. The unit is each individual action, classified before it executes, against a covenant that encodes what was actually authorized for this session.
The bet is also that this layer has to be deterministic. You cannot use an LLM to classify the action an LLM is about to take. That is not a philosophical position. It is an engineering requirement. Deterministic classification is auditable, reproducible, explainable, and fast. It does not introduce a second point of LLM failure inside your governance layer. It is the only architecture that holds at scale.
Now
Reshimu.ai is the company. Atzmut OS is the runtime. NESHER, SHOR, ARYEH, and PANIM ADAM are the four validators. Two are live on npm. The MCP server is built and tested. The architecture is complete.
The name of each validator is also not arbitrary. In the Merkavah — the divine chariot — four Chayyot (living forms) carry the throne. NESHER is the eagle. SHOR is the ox. ARYEH is the lion. PANIM ADAM is the human face. They are not decorative. They are the integrity-validation layer of the throne's bearing structure. They are the reason the throne does not fall. In our architecture, they are the reason the action does not execute unexamined.
The trace that remains is not a metaphor. It is a specification. And it is now running in production.
Why Reshimu?
In Kabbalistic cosmology, the Reshimu is the impression — the trace that remains after Tzimtzum, the primordial contraction. When the infinite contracts to make space for the finite, the contraction is complete. But not entirely. What remains is not a remnant of what was there. It is a specification of what was there — an encoding, structural and incorruptible, that carries the fingerprint of the source into the new regime.
The Reshimu is not the source. It is not the kav — the line of renewed illumination that enters the contracted space. It is older than both of those. It is what survives the act of creative limitation itself. And it is precisely because it survives that the contracted space retains its connection to its origin. Without the Reshimu, there is no trace. Without the trace, there is no covenant between source and output.
Every autonomous agent system that acts in the world without a governance layer is a chalal — a contracted space in which the kav of human intention enters and then disappears. The agent acts. The trace is gone. What we build is the Reshimu: the encoding that keeps every output connected to what was actually authorized, not as an afterthought but as a constitutive architectural feature of how the system operates.
The company is named for what it builds. That is the right name.
There is more to this than infrastructure. The intellectual foundations are documented in the depth series.
Read the depth essays