NSHKR is a governed write-path substrate for enterprise AI execution. It captures how AI-mediated actions move from typed intent through authority, workflow, external effect, receipt, evidence, projection, review, and replay.

Why does the write path matter for enterprise AI?

The write path is where a proposed action becomes binding and where an external effect actually happens. Capturing that moment gives operators durable proof of who asked, what authority applied, which effect was requested, what happened, what evidence supports it, and whether the chain can be replayed.

How does NSHKR avoid provider lock-in?

Products can bind roles to concrete providers such as GitHub, Linear, Codex, Slack, Jira, Notion, or internal APIs. Reusable platform surfaces still operate on product roles, operation classes, manifests, receipts, and projections, while provider mechanics live in connector packages.

Why is NSHKR built around Elixir, OTP, and the BEAM?

Enterprise AI execution is a distributed systems problem before it is a model problem. OTP provides supervised processes, explicit failure handling, durable state machines, message passing, and high-concurrency runtime surfaces.

What proof does the platform produce?

NSHKR produces compact receipts, evidence records, projection updates, review decisions, AITrace causal DAGs, release evidence, and StackLab scanner results so governed execution can be audited and replayed.

Python · PyTorch · mechanistic interpretability · open research

Mechanistic interpretability research
with controls that can fail.

NSHKR studies representation, transport, superposition, and causal legibility with frozen protocols, matched controls, real-model or ground-truth synthetic runs, and reports that preserve negative results. The portfolio also includes an Elixir/OTP systems program for governed AI execution.

question preregister control run falsify report reproduce

Research programs → Systems engineering Ecosystem

Research Programs

Each program keeps its question, controls, artifacts, and claim boundary together. Results are stated at the level the evidence supports: a decoder is not a mechanism, an internally coherent operator is not automatically useful, and a clean null is still a result.

Geometry of Conditional Truth

A cross-model Qwen3-4B and Phi-4-mini replication. Across eight preregistered endpoints, Phi supported one and Qwen supported none; both remained Level 1 of 6. Cross-model report.

Architecture Mechanics

Tiny trained models and known synthetic features make transport, overwrite, packing, and intervention outcomes directly measurable across mixing mechanisms.

Attention Lab

A matched GPT-pretraining harness for alternative attention architectures. Two confirmatory pretraining runs reached full-depth analysis; the current mechanism verdict remains insufficient evidence.

Superposition Zoo

Synthetic retrieval comparisons across attention, routing, linear attention, delta memory, and state-space mixing. Retrieval findings are real; the central feature-isolation question remains open.

Research workbenches and records mwb mil circuit-tracer learning archive

Systems Engineering: Governed AI Execution

The Elixir/OTP side of the portfolio builds the write-path substrate an enterprise needs after an AI system proposes an action. The important artifact is not a prompt transcript; it is a durable chain from request to authority, workflow, external effect, receipt, evidence, review, and replayable proof. nshkr is the production composition and release backbone; its Nshkr.Runtime application boots the bounded owner services as one fail-closed platform.

01Who asked?

Actor, tenant, installation, request context.

02What authority?

Capability, policy, scope, review gate.

03Which workflow?

Operation context, causation, idempotency.

04Which effect?

Operation class, manifest, lower instruction.

05What happened?

Effect receipt, status, failure class.

06What evidence?

Evidence refs, attached artifacts, proof tokens.

07Who reviewed?

Review case, decision, override, escalation.

08Can it replay?

AITrace DAG, predecessor refs, merge semantics.

09Where did it execute?

Spatial topology, target host ID, BEAM node ref.

Command OperationContext ResolvedOperationPlan AuthorityPacket GovernedInvocationEnvelope TopologyProfile ExecutionInstruction EffectReceipt EvidenceRecord Projection ReviewDecision AITrace DAG

NSHKR composition root production assembly, runtime profiles, dependency order, releases

nshkr is the production backbone rather than another capability package. Nshkr.Runtime composes persistence, workflows, context, authority, provider accounts, execution, cluster reconciliation, Synapse, and Extravaganza into reproducible monolith and distributed deployments. Production profiles reject memory, fixture, no-op, and static-success substitutes.

nshkr Nshkr.Runtime

AppKit boundary product-facing commands, reads, reviews, leases, traces

app_kit is the northbound surface product code is allowed to touch for governed platform behavior. It accepts product-level commands and stable DTOs, exposes operator reads and review controls, and keeps products from stitching lower execution paths together by hand.

app_kit extravaganza stack_lab

Mezzanine substrate workflow truth, ledgers, receipts, evidence, projections

mezzanine owns reusable operational truth: binding registry, compiled run snapshots, workflow handoff, execution ledgers, operation receipts, evidence, projections, review state, audit, and operator actions. It records the facts that make the write path replayable.

mezzanine execution_engine decision_engine

Semantic and authority chain context, normalized outcomes, capability and policy compile

outer_brain owns semantic context, recall, normalized AI outcomes, and semantic failure carriers. citadel authorizes after resolution, when the operation class, manifest, side-effect class, required scope, and credential constraints are known.

outer_brain → citadel

Connector spine manifests, operation descriptors, leases, governed invocation

jido_integration resolves connector manifests, operation descriptors, and credential leases into governed lower invocation. It lets provider mechanics be specific without leaking provider-shaped control flow into reusable platform surfaces.

jido_integration core/contracts control_plane

Execution plane HTTP, process, CLI, sandbox, filesystem, raw effects

execution_plane performs raw mechanics across HTTP, CLI, process, JSON-RPC, sandbox, terminal, filesystem, and future execution lanes. It emits receipts and raw facts. Product meaning, review state, and operational projections stay above it.

execution_plane pristine prismatic cli_subprocess_core

Spatial substrate host provisioning, Systemd environment leases, mesh topology, secrets injection

chassis is the self-replicating spatial substrate that maps virtual stack components to physical BEAM nodes. It coordinates host inventory, provisions remote nodes via native Elixir SSH bootstrap or pluggable adapters, and injects memory-decrypted age/SOPS credentials directly into Systemd service environments.

chassis chassis_core chassis_ssh

Trace and proof causal DAGs, replay, redaction, lineage, failure drills

AITrace records causal execution events with predecessor references so replay is not just emission order. stack_lab adds scanners, acceptance gates, negative controls, failure drills, and second-product validation so generality is tested instead of assumed.

AITrace stack_lab ground_plane

Products own meaning. Platform owns invariants. Connectors own vendor mechanics. Execution owns raw effects. Trace owns proof. switchyard ElixirScope

177

Repository nodes

667

GitHub stars

Write-path stages

Audit questions

Authority follows resolution

A broad product request is not enough. Citadel authorizes the resolved operation plan after Mezzanine knows the operation class, manifest ref, binding ref, side-effect class, credential scope, and review constraints.

Provider specificity is data

A pack can bind issue tracking to Linear, code hosting to GitHub, or runtime work to Codex. Reusable surfaces still speak product roles, manifests, operation classes, receipts, and projections.

Proof is executable

stack_lab scenarios, AITrace DAGs, schema registries, release manifests, no-bypass scans, projection hashes, and proof tokens are not documentation after the fact. They are acceptance gates.