Install

npm install @reshimu/nesher

yarn add @reshimu/nesher

pip install reshimu-nesher

No native dependencies. No compilation step. Works in any Node.js ≥ 18 or Python ≥ 3.9 runtime.

Quick start

TypeScript / JavaScript

import { classify } from '@reshimu/nesher'

const result = classify({
  action: 'delete_records',
  target: 'user_id:44812 — all associated rows'
})

console.log(result.level)   // 'RED'
console.log(result.hold)    // true
console.log(result.reason)  // 'permanent data deletion'

Reversible action

const result = classify({
  action: 'fetch_records',
  target: 'orders where status = pending'
})

console.log(result.level)   // 'GREEN'
console.log(result.hold)    // false

Python

from reshimu_nesher import classify

result = classify(
    action="send_email",
    target="[email protected] — payment reminder"
)

print(result.level)   # 'RED'
print(result.hold)    # True
print(result.reason)  # 'outbound communication — cannot be recalled'

Classification levels

API reference

classify(options)

Parameters:

Returns:

Integration guide

NESHER sits between an agent's decision to act and the execution of that action. The pattern is consistent regardless of orchestration framework — intercept before the tool call fires, not after.

import { classify } from '@reshimu/nesher'

async function beforeToolCall(action: string, target: string) {
  const result = classify({ action, target })

  if (result.level === 'CRITICAL') {
    return {
      blocked: true,
      reason: result.reason,
      requiresManualReview: true
    }
  }

  if (result.level === 'RED') {
    return {
      blocked: true,
      reason: result.reason,
      awaitingConfirmation: true
    }
  }

  return { blocked: false, level: result.level }
}

With SHOR (grounding gate)

NESHER and SHOR compose. The recommended order is: classify the action's reversibility first (NESHER), then check grounding of the output that produced it (SHOR). An UNGROUNDED output that also proposes an irreversible action is caught by both gates.

import { classify as reversibility } from '@reshimu/nesher'
import { classify as grounding } from '@reshimu/shor'

async function intercept(action: string, output: string, sources: string[]) {
  const rev  = reversibility({ action, target: output })
  const gnd  = grounding({ output, sources })

  if (rev.level === 'CRITICAL' || gnd.level === 'UNGROUNDED') {
    return { blocked: true, rev, gnd }
  }

  return { blocked: false, rev, gnd }
}

Python agent loop

from reshimu_nesher import classify

def before_tool_call(action: str, target: str) -> dict:
    result = classify(action=action, target=target)

    if result.hold:
        raise ValueError(
            f"Blocked: {result.level} action. Reason: {result.reason}"
        )

    return {"level": result.level, "hold": result.hold}

Design constraints

For the full reasoning behind the no-LLM constraint, see Why we don't trust LLMs to classify the call they're about to make.

Runtime stack

NESHER is the first of four runtime integrity validators — the Chayyot — that form the Reshimu agent governance stack.

Each validator is a zero-dependency library, usable independently. The Atzmut OS MCP server integrates all four into a single intercept layer.

For the architectural pattern underlying all four, see Bearers of the Throne.