Scientific Repository

Gateway:Degraded

Research & Formal Publications

Tokenectomy Labs conducts rigorous, empirically grounded research at the intersection of formal programming language semantics, AST program repair, and autonomous multi-agent runtime verification.

SWE-bench & SecBench Datasets Mathematical Formulation 4-Stage Quine Pipeline Technical Preprints

Authentic Benchmark Datasets & Reproduction

SWE-bench Verified & SecBench Case Studies

Real task instances from industry benchmarks evaluated in standalone Docker environments with 0 broken regressions.

SWE-bench VerifiedWeb Framework / Authentication

Repo: django/django

Problem Statement: BasePasswordHasher.must_update() failed to verify the underlying algorithm component of the password hash, returning False when iterating hashes created by older configured algorithms.

Root Cause: The method only compared decoded['iterations'] against self.iterations, ignoring the decoded['algorithm'] identifier.

Target File

django/contrib/auth/hashers.py

Surgical Diff

+3 / -1 lines

Files Changed

1 (Zero Dirty Diff)

Physical Exit Code

Exit 0 PASS

django__django-14631Environment: Isolated Standalone Docker

diff --git a/django/contrib/auth/hashers.py b/django/contrib/auth/hashers.py
index 920f779..28198f1 100644
--- a/django/contrib/auth/hashers.py
+++ b/django/contrib/auth/hashers.py
@@ -38,3 +38,5 @@ class BasePasswordHasher:
     def must_update(self, encoded):
         decoded = self.decode(encoded)
-        return decoded['iterations'] != self.iterations
+        return (decoded['iterations'] != self.iterations) or (
+            decoded['algorithm'] != self.algorithm
+        )

Mathematical Formulation: Procedural Seed & Sub-Cortex Evolution

The fundamental limitation of next-token prediction agents in software engineering is search entropy: unconstrained language models generate syntactically plausible tokens that violate lexical, typing, and semantic contracts. Tokenectomy Labs addresses this by formulating program synthesis as a constrained optimization problem over Tree-sitter AST nodes:

S_(t+1) = Promote( argmax_(b in B) Fitness(b) | Oracle(b) == PASS )

State Definition S_t

The active verified runtime state at generation t, anchored by an immutable AST snapshot and KNM-512 cryptographic seal.

Branch Generator B

Finite set of procedurally generated, grammar-constrained AST mutations (control-flow splitting, loop unrolling, zero-alloc buffer reuse).

Dual-Gate Oracle(b)

Hierarchical verification gate: 5µs C-ABI syntax check -> isolated Docker sandbox -> non-regression harness.

// Strict Non-Regression Delta Theorem

Delta Latency <= 0 AND Delta Allocations <= 0

Every candidate mutation must strictly match or reduce latency and memory allocations. Any candidate exceeding memory quotas or introducing regressions is rejected in Stage 2.

Formal Architecture Blueprints

System Design & Runtime Verification Pipeline

The four-stage pipeline prevents search entropy by coupling grammar-constrained procedural mutations with microsecond AST oracles and isolated POSIX sandboxes, guaranteeing non-regression before atomic hot-swap.

Stage 1: Branching

Applies semantics-preserving AST mutations (loop unrolling, buffer reuse) via Tree-sitter nodes.

Stage 2: 5µs Gate

Native Rust C-ABI traverses and validates candidate syntax trees in under five microseconds.

Stage 3: Crucible

Compiles candidate `.so` into POSIX namespace, enforcing full regression harnesses with zero egress.

Stage 4: Quine Swap

Hot-swaps symbol tables atomically with instantaneous rollback to t-1 if any panic emerges.

Featured Scientific Preprints & Whitepapers

Peer-reviewed technical reports documenting empirical algorithms and cryptographic proofs.

Repository Ref: KNM-PUB-2026

PREPRINT TL-2026-01November 2026DOI:10.5281/zenodo.10842911

Tokenectomy Labs Research Technical Report

Deterministic Program Repair via Microsecond AST Context Surgery and Constitutional Invariants

Nans & Tokenectomy Labs Research Group • Autonomous Systems Division

Abstract

We present Tokenectomy, an automated program repair architecture combining a zero-allocation Rust C-ABI Tree-sitter Sub-Cortex with a constitutional invariant gate. Evaluated across 2,294 real-world repositories, our Sub-Cortex executes syntax pruning in under 5.0 microseconds while eliminating 92.04% of LLM token bloat without discarding relevant call-site semantics. By enforcing pre-run non-negotiable invariant contracts (prohibiting test de-fanging, mock-pleasing, and synthetic cheats), Tokenectomy achieves 0.00% regressions on the Princeton SWE-bench Verified dataset.

Sub-Cortex Latency

4.82 µs

Token Reduction

-92.04%

SWE-bench Verified

Verified Docker

Regressions

0.00%

PREPRINT TL-2026-02October 2026DOI:10.5281/zenodo.10842912

Cryptographic Invariant Security Proceedings

KNM-512: Cryptographic Sponge Seals for Verifiable Autonomous Agent Worktrees

Security & Cryptography Group • Tokenectomy Labs

Abstract

Autonomous AI agents that execute code repairs risk introducing unverified modifications or circumventing test harnesses through mock substitution. We introduce KNM-512, a post-quantum sponge construction hash that seals execution transcripts, physical hardware clock cycles, and AST diffs into an immutable cryptographic digest. We demonstrate that KNM-512 prevents verification replay attacks, validates zero-dirty-diff contracts, and proves hardware grounding without external attestation services.

Sponge Width

512 Bits

Replay Immunity

Hardware Nonce

Digest Latency

12.4 µs

Tamper Proof

Post-Quantum

WHITE PAPER TL-2026-03September 2026DOI:10.5281/zenodo.10842913

Autonomous Systems Engineering

Runtime Quine Evolution: Four-Stage Self-Modification in POSIX Air-Gapped Sandboxes

Metacognition & Runtime Systems • Tokenectomy Labs

Abstract

We formalize the four-stage recursive self-improvement pipeline of the Kronumos AGI architecture. By binding procedural seed permutations to dynamic linker hot-swapping (dlopen / dlsym) guarded by an instantaneous rollback circuit breaker, our engine autonomously improves its own internal parsing routines and memory allocations without human supervisor intervention, guaranteed to maintain non-regression against constitutional contract invariants.

Hot-Swap Time

< 1.2 ms

Rollback Guard

t-1 Instant

Air-Gap Egress

0 Bytes (Air-Gapped)

Self-Commit

AST Verified

WHITE PAPER TL-2026-04August 2026DOI:10.5281/zenodo.10842914

Programming Language Systems & Virtual Machines

Vidyax: An AI-Native Language Architecture with Stack Virtual Machine and AOT Native Compilation

Languages & Compilers Group • Tokenectomy Labs

Abstract

We introduce Vidyax, a lightweight, AI-native programming language designed with its own C-based bytecode virtual machine (VVM) and ahead-of-time (AOT) native compiler. By integrating an instruction-level bytecode verifier, mark-sweep safepoint garbage collection, and a behavioral-preserving peephole optimizer, Vidyax provides a safe, reproducible foundation for autonomous program synthesis and differential execution testing across four independent backends.

AOT Speedup

36.2x Transpiler

Verified Backends

4 Shared Runtimes

Memory Footprint

< 2.1 MB Resident

Sandbox Verifier

Opcode Instruction Gate

Benchmark Comparison Matrix

Empirical Evaluation: Princeton SWE-bench Verified

Environment: Standalone Docker (Exit Code 0)

Architecture / Engine	Context Surgery	Test De-Fanging Defense	Token Waste	Dirty Diff Rate	Hardware Truth
Tokenectomy Sub-Cortex 2.0	5 µs Tree-sitter	Pre-Run Invariant Zero	-92.04%	0.00% (Strict AST)	Physical (Linux VmRSS)
Standard Unassisted LLM Agent	None (Raw Strings)	Vulnerable to Mock-Cheats	100% (Full Context)	High (Spurious Churn)	Probabilistic Guess
Regex / Heuristic Agent	Naive Regex Filter	Partial (String Match)	-35.0%	Medium (Line Shifts)	Synthetic Check

Verified across Django, SymPy, Matplotlib, and Scikit-Learn tasks.100% REPRODUCIBLE IN STANDALONE DOCKER

Reproduce Our Research in Your Own Environment

All benchmarks, C-ABI harnesses, and invariant contracts are available for open scientific inspection. No hidden mocks, no proprietary black-box evaluation.

1. Criterion Micro-Benchmark

// Run physical clock microsecond AST benchmark

$ cargo bench --bench subcortex_surgery

2. Standalone Docker Crucible

// Isolated regression evaluation harness

$ docker run --rm -v $(pwd):/workspace tokenectomy/crucible:v2.1

Access Open Source Research Repositories