Memoryless Recursions with a Provability Check: Files as the Only State in Human-in-the-Loop AI Workflows

Large language model (LLM) assistants are increasingly asked to run multi-step workflows that span days, many sessions and an external system of record. Their working memory doesn't hold up across that span: context windows get compacted, sessions restart, and a summary of earlier work stands in for the work itself. This paper describes a design method that takes the assistant's memory out of the workflow's critical path. Every workflow is written as a memoryless recursion: each step is triggered by the files the previous step left behind, works from those files alone, and leaves files that trigger the next step, until a named base case is reached. A read level places the rules a step needs immediately before that step, logged in the assistant's own words, so rules are read on demand rather than carried from the start of a session. A +1 handshake, a single pasted sentence checked word for word by code, is the only human approval inside a running recursion, and it stands before any action that can't be undone. And a provability checker audits the system itself: every loop ends, every documented step has a matching print in the code (cancel), the documentation agrees with itself and with the code (sync), each program's levels rewind from the innermost level out with every level required by the one above (rewind), and no check compares a value with itself (pairs). Code is written outside in; the proof reads it inside out, because a recursion must rewind. The method grew out of a working system run daily over roughly ten weeks of an academic term, in a higher-education teaching setting. It builds on the TJ++ Logic Engine (10.5281/zenodo.22057917), turning the same content-blind structural checks from text onto process. A reference kit with runnable checkers, a sample workflow and deliberately broken copies is on GitHub: github.com/abhi50188/memoryless-recursion-kit (code under MIT).

Authors

Publication Details

Journal
Zenodo (CERN European Organization for Nuclear Research)
Published
2026-11-16
DOI
https://doi.org/10.5281/zenodo.24294503
Primary Topic
Artificial Intelligence Applications
Type
article
Field-Weighted Citation Impact
0.00
Controls
|||
ALL TIME
JAN
FEB
MAR
APR
MAY
JUN
JUL
AUG
SEP
OCT
NOV
article

Memoryless Recursions with a Provability Check: Files as the Only State in Human-in-the-Loop AI Workflows

Abhi Sharma
2 links
Zenodo (CERN European Organization for Nuclear Research)
Artificial Intelligence Applications
article

Memoryless Recursions with a Provability Check: Files as the Only State in Human-in-the-Loop AI Workflows

Abhi Sharma
article en

Abstract

Large language model (LLM) assistants are increasingly asked to run multi-step workflows that span days, many sessions and an external system of record. Their working memory doesn't hold up across that span: context windows get compacted, sessions restart, and a summary of earlier work stands in for the work itself. This paper describes a design method that takes the assistant's memory out of the workflow's critical path. Every workflow is written as a memoryless recursion: each step is triggered by the files the previous step left behind, works from those files alone, and leaves files that trigger the next step, until a named base case is reached. A read level places the rules a step needs immediately before that step, logged in the assistant's own words, so rules are read on demand rather than carried from the start of a session. A +1 handshake, a single pasted sentence checked word for word by code, is the only human approval inside a running recursion, and it stands before any action that can't be undone. And a provability checker audits the system itself: every loop ends, every documented step has a matching print in the code (cancel), the documentation agrees with itself and with the code (sync), each program's levels rewind from the innermost level out with every level required by the one above (rewind), and no check compares a value with itself (pairs). Code is written outside in; the proof reads it inside out, because a recursion must rewind. The method grew out of a working system run daily over roughly ten weeks of an academic term, in a higher-education teaching setting. It builds on the TJ++ Logic Engine (10.5281/zenodo.22057917), turning the same content-blind structural checks from text onto process. A reference kit with runnable checkers, a sample workflow and deliberately broken copies is on GitHub: github.com/abhi50188/memoryless-recursion-kit (code under MIT).

Zenodo (CERN European Organization for Nuclear Research)
Artificial Intelligence Applications
AI Navigator

Ask Laika to Summarize, Analyze, and Connect papers live on the map.

Summarize Papers & Methodologies

Extract key findings, datasets, and comparative methods across publications.

Benchmark Rankings & Visual Analytics

Rank top research institutions, authors, funders, topics, and journals by Field-Weighted Citation Impact (FWCI) and paper volume with instant charts.

Connect Distant Disciplines

Bridge topological clusters on the map to find hidden collaborative intersections.

Laika access coming soon