I have never played with a LLM except with Gemini from my Pixel 10. I had questions when the model would suddenly just stop being able to keep a logical conversation. When I looked up the problem online I got that it was drifting due to chat log bloat. So prior to starting home labs with LLMs I had no knowledge of any of the “Under the Hood” mechanics of how a LLM worked, all I had access to really that I knew was from YouTube and News. All saying this is a dangerous thing, it can run off the rails and easily do things it was not told to.
6 days ago I was throwing my ideas at Gemini. I am always trying to think of big problems to solve theoretically in my head. I think I have a slight Dunning Krueger Effect and do not share my thoughts due to that.
When I ran my first model, I ran a smaller model. I was very curious what it was doing and spent the first day playing with different front ends. I landed on Lm Studio because it is basically an out of the box front end that has tools for your agent to do everything it needs to build software. My ultimate goal is to not need to do this fast as I do not care about speed. No, I care about output. I started asking the model open ended logic questions to see its reasoning. I noticed very quickly the industry's conception of the LLMs, this “Hey Buddy! Make me “_____” Software.” Is Not how these things work at all. I instantly saw a processor, so I started looking for how I could make it loop and what the industry was doing to create this. Wow, I had no idea what I was about to look at. I am not able to pay for anything external that must make software on its own. Any tools must be freeware. Yeah! That's not what the industry is doing, LangChain? I am sorry then I need more bloat on my tiny m.2 256gb which already is almost full. I then looked at what all the LangChain and its extra tools were doing to accomplish the goal of software output. I could instantly see this needed to be layered like a development team from their design, that they were injecting prompts to change its work, at times mid work. I thought again that it can be structured into an instruction set and have the processor compile the prompt as if it was just a code command.
So then I started really running wild with ideas of the variables I had:
1.LLMs are just processors so good input == good output.
2. I need to figure out a prompting method structure that initiates a loop, so it can error check its own work. I can then layer models and vet all their work against each other with high tiered models to vet the work from the model below.
Since I grew up with Dos as my first system in 1983 playing games. I learned Basic language structure in the late 80s. However I do not know how to code as I am good with visualizing large complex problems but I am not a fast reader or learner. I need time to get all the variables and piece them together. In this case because I have been in front of a computer since I was 3 it is my first love, I understand computer logic more than people.
My first thought was to start with a Basic language structure and quickly started building up from there. Using Gemini and my own models I scaled it up very fast, each time I solved a problem. I got new data that showed an upward trend to efficiency. This caught my attention instantly as from what I read online from the LangChaing documentation this should be going the other way. I asked every LLM and hunted for any documentation to say that this was possible in the way I was doing it. Every documentation said it was impossible.
I was in shock and then needed to find a way to keep the model in the loop until 1 of 3 things happened.
The model hit its ceiling (Which I found out is the logical layering and has a limit) and has no more headroom and kicks out of the loop outputting where it hit the limit. Which is a successful run and should give me enough log data to show an upward trend.
It finished its task and runs my LISL Instructions to completion too quickly. (This was a problem I did not think to predict.) This is a fail of the test.
The model runs the loop until it runs out of tokens. (This is the best case scenario and the result I was looking for.)
Constraints to the Lab Tests.
A: Computer it is being run on:
Intel i5 8th gen (lowest model I like saving power and money)
24gb DDR4 2666mhz (Single Channel, It is originally built for animation so as much ram as possible for production, Ram prices skyrocketed before I could finish the ram and get the dual channel.)
Rtx 3050 6gb (Bottlenecked by the aged PCIe Slot on the motherboard.
The System was originally a: Dell Inspiron 5680 Gaming Desktop Computer Intel Core i5 8GB RAM 1TB HD Recon Blue - 8th Gen i5-8400 Hexa-core - NVIDIA GeForce GTX 1060 3GB - 2.8 GHz processor speed - Polar Blue LED lighting - Wi
Only Ram and Gpu, plus I replaced the ssd m.2 16gb ram with a 256gb and forced it to boot from that slot. So I everything is running off the m.2 a ADAT legend 740
Rtx3050 6gb is not like the original. It has some stuff turned off, so I needed to find out what bit size it was best at using. 8bit was the best everywhere I looked so that is what I run for all models. That is except for the NemoTron but I’ll get to that.
Standard internet through a wifi is nothing special.
LISL Instructions are a file saved to an external place you point the LLM at it and say read this it is your prompt or instructions. First I used .md as the models were pumping out markdown files so I assumed this was the best format. After some tests it proves to be XML converted into computer language code blocks, this is the most efficient I have been able to find. I am still looking for a way to make it smaller.
Models in order that I ran:
Gemma 4 12b it Qat
Qwen3.5 9b
NemoTron 3 Nano 2b
They have Beledorian plugin tools. But I do not have access to the outside world. The wifi was disconnected and they did not have access to web browser tool either. The only tools it had available were docs to learn, I would print websites with technical documentation, convert it into .txt and put them all in a single folder that the LISL Instruction points to.
The task they are told to do is build a gba game, they only have docs telling them how. They do not have devkits, only the basic tools from beledorian and no access to the outside world. All their knowledge is what the model came with and what is in that folder. I gave them docs on gba hardware specs so they knew the hardware constraints they had to stay in. I gave them docs on how to build a gba game. One .txt file per lesson, this proves to be a waste of space and I optimized this to fit a smaller footprint later so it ran faster. Its goal is to not make a working game but to loop using the LISL method to 1 of our 3 desired results.
They have a 67k token pool.
I do not care about the model bleeding into the DDR4 Ram, the goal is output not speed. Can it do this was the question I was asking.
The Tests:
The Gemma model finished the task in less than 19k tokens. Fail. The model is too efficient and the task per token shrinks as it completes the LISL Instructions was what the data showed but again it was not long enough to show a definitive movement.
I then stopped and had to come up with an equation that works to show this momentum. It needed to be so easy that it could literally be reversed and still have the momentum. (Im highly dyslexic so I need to make sure even if I reverse the equation by accident I still get a TCR numerical value to show the momentum. It did show upward and the calculation Total tasks divided by Total Tokens Used was 1.15 tasks per token. Gemini agreed with my hypothesis, then I checked chatGtp, Claude. They all agreed the logic in the theory was sound. So on to the next test.
Qwen3,5 9b has a much smaller headroom (cache space for logical layering). It therefore should take more tokens to complete the same LISL Instructions vs the Gemma model which has a higher amount of training data. I had hoped it would run out of its tokens, in theory from the TCR metrics I was getting from the Gemma model it shouldn't be able to finish the instructions in time. He did the task to completion in around 29k tokens, which was upsetting. He topped out at a TCR Total tasks divided by Total Tokens used: 1.06. This again is not enough log data to really show its efficiency definitively in an upward trend. It is showing a good compression rate and I had to start thinking about why. The only thing I can come up with is it is removing finished instructions as it completes them, making the next token cost considerably less. I was getting worried that I would not find a bottom or a top and be able to prove it was doing this to infinity and staying on task.
By this time I am in 3 days of hard labs, working 16 to 18 hours a day on this. I am hooked at this time on solving this momentum curve. I need to find a way to get the data to show it.
My next test was the Nvidia NemoTron 3 Nano 2b, this little guy changed everything in how I built the LISL and how it became able to show the data I am after. However it was an interesting discovery of hitting a logical laying limit and not knowing what I was hitting.
I could not load this model into LM Studio at all, it was the 8bit which due to its labeling as kv I did not realize what that number meant. I had to look up why it was not running. This model to get to follow the LISL Structure I needed to remove the kv quantification and leave it open. Then it would take command and respond. That was a good two hours of hunting for an answer to get the lab to even run. I was a little disappointed that I had to change a variable in my lab and am not exactly sure what the impact is besides understanding bit sizing and this model is super small so I think it is like a 4 or 6 bit sting it can handle. Again I'm not sure.
The first test the NemoTron ran 5 iterations and the spit output, it was following the LISL instruction but it just stopped. Fail
I thought about what it could be. I wanted to make sure it was not my instructions because the other larger models did run it. The task should absolutely be more than enough for this little model to run out of tasks or headroom. I checked my LISL and it was good nothing there to give it any reason not to loop.
I ran it again and again 5 iterations and it kicked out. I could see it was getting to the first error loop and just stopping. I analyzed the data and it was running the instructions but only to step five then it just stopped. I was kind of unsure but figured it might be the model did not have large enough cache space internally to hold more than a few instructions from the LISL at once. I was packing a whole dev cycle into one, a debug into another milestone and alignment check of the whole work against the objectives. It was given an error layer for each variable in the LISL instructions. So I thought let's try giving it smaller groupings of tasks in each milestone and see if it will at least hit the first error logic loop and loop back. This model if set with a temp of 0.3 should loop in the logic loop finding every time it wrote code it had a error somewhere against the milestone
LISL structure in Logic steps of what the model is doing:
(objective is the goal=> milestones are the smaller goals => tasks the model builds what it is told to follow the instructions in this smaller chunk, at the end of this task chain is the error loop to check if the work matches the milestone. Then it moves on to the next milestone =>tasks, error check=>milestone=>tasks, error check=> finished? Alignment check to the Objective If yes end If no go to step and repeat that steps=>milestone=>tasks, error check=>finished? Alignment check. in the tasks then an error layer before it moves on to the next milestone.)
So I rewrote my LISL instructions in smaller milestones and converted the English structured version into a computer language for the NemoTron. I trained my Gemma 4 12b it Qat in the post I shared on Reddit r/LLMDevs. Gave it an education on the NemoTron model and told it to write it in three task chunks, and to write it specifically for the NemoTron model. Then I thought I should probably give this little model the best chance to actually loop so I dropped that LISL into Gemini and told Gemini to convert it into all computer code blocking. Then I fed that LISL formatted computer language instruction to the NemoTron and it worked, I stopped hitting the ceiling. It ran 37 iterations giving me the data I needed to see a good view of the efficiency.
I was both elated but also not sure why before it was not working, why did breaking it into 3’s solve the problem.
I showed the screenshots to Gemini, ChatGot, Claude and they all said it was because he has a hard limit of 3 logical layers. I checked their answer and that was true, they had 5 to be exact but if I was using 5 work tasks and 2 for error checking it was far more than its ceiling of 5. So shrinking it down to 3 work tasks and 2 for error was the key. This model started with a TCR Total Tasks divided by Total Tokens used of 9.(something). That's with the start up tax that did shrink from the first runs which was average 5-6k tokens like every other model, this time it started with 2k. The compression of the input to code made it easier for the model to read and process. Validating my theory of treating them as processors and not as, “Hi, good buddy.” The NemoTron ended with exactly what I was looking for: an invert of the tasks to tokens, it finished with a 0.98 TCR tasks to tokens. It did not finish the instructions and ran out of headroom meaning the error checks kept it in loop. I checked the logs as it was producing them. He was doing what he was told and not drifting. He has limited logic layers so he does not have large enough space to be able to write a full page of code like I am asking it to do and then have it error check that that file is correctly linked to the rest so the program is not broken on output. Using the LISL method the NemoTron ran the loop to completion, okay so what is next?
I know it works. I know what I got as I have known about hallucination issues for some time.
I know that it does not require an outside source to loop as it had no access to any external offloading; everything was internal.
I know it did follow the instructions as I can see it saying I think I need this, No wait lets check the docs. Okay this. Let's do it!
I know when it is doing its error loops it ‘I should check the code now for errors. I found this error. It will cause this problem, I need to fix that by doing this. Wait lets check the docs, I need to do this. Let's do it! As I can see it does this many many times in a single iteration.
I know that bit rate can affect the input and the models have a hard ceiling of inputs I can give it at once.
My next question and it was what the LLMs kept asking as well was how well did it align to the tasks? Screenshots of the chat log showing the looping and its reasoning was pretty telling and Gemini, ChatGpt, Claude could argue the evidence in the image. I started looking into what this question really meant. I found out that this means the temp of a model is meant to determine its creative level regarding its ability to explore its available tools and files. That can be dangerous if it has bad input instructions, it is a processor after all.
So I ran a few more tests to see if at a 1.0 if the model follows the LISL instructions to completion and if it is repeatable. Did the only Gemma and Qwen and stopped testing with the NemoTron, it scales. I don't need to fight with the lower model anymore. I found they are very creative and this is how the image generator I talked about earlier came to be. I gave it a very open ended LISL instruction if you have open access to all beledorian tools and gave it a docs on beledorian. I told it I want an image generator that is tied into a free API. It was allowed to search all available tools in its environment to accomplish its task. Then make it test the generator and produce an image, check the image to see if it matched the prompt used in the call to the image generator. It did the task. I then demanded it to produce a cat as an English prompt and told it to check the image to the prompt and continue to produce images until it had what matched the prompt. The prompt was a stack of falling money, no ground visible, and any background visible is to be all black. This logic is hard for a LLM as most references of ‘stacks of money’ are on surfaces. So the prompt should return a bad result so the LLM is forced to ask again until the generator gets the prompt right. I was pretty lucky, the Gemma model ran the LISL to completion and tested every image until they matched the prompt exactly. It was a eureka moment for me, it did not misalign even when given a completely open ended option. Granted I had no idea what API it searched and found or if it just pulled it down. I did not see any large hard drive spikes in taskman so I am pretty sure it's an API to a free generator.
So if the temp means it's more creative to completion, it potentially can handle open ended logic. If I write my LISL method in a layered format, the end of one LISL points to the next LISL to run. This means I can then chain LISL instructions to the llm and again have it have error loops to check its work for moving on.
At the same time I started coming up with a method to run two models in the same conversation using ID stamping and giving each model a ID, which is like a cvar as best I can describe it.
My next test was to have a LISL writer write instructions to a folder. It has an ID stamped at the top that this was written by it for the lower model to work on. This creates a hierarchy structure that the models are now going to hold. When each model finished its work it sends a handoff command to LM Bionic to swap the model in chat and send a delayed injection for the other model. Depending on how long it takes for the LM Bionic to swap the model. Two models are loaded into the load space (I do not know the terminology sorry.) KV and Ram, in my case. This test failed right away. Both models tried to access the tools in the environment and locked them out. I had to uninstall LM Studio and clean out all user data to get my labs up and running again. The solution to this is to give them explicit commands not to access the tools in the LISL persona in the system prompt, the person is where you can ID the agents. The LISL person can give them a second logic layer that you can then give IF AND ELSE style inputs inside the LISL persona. The hand off command getting it to do that to Bionic I am not sure if it can even if I gave it full access to my system. Though I have not tested that lab yet.
I am now in 5 days and have dropped my whitepaper with my theory. People are looking but since I am no professional I am self taught I don't know your terminology. But my logic is sound, the theory is working and producing argentic loops. So I think at this point maybe I should scale back the lab and have a LISL writer write a layered instruction set for a lower model.
Doom Port to Windows Lab:
Gemma 4 12b it Qat
100k token pool
Temp 0.5 I want him to be very detailed and he might need to be creative so I gave him a decent bump. I did not know at the time this is still considered a point where the model should be starting to see drift in alignment.
He is going to build everything again No devkit, He must build it all.
It has access to docs on how to make a doom game, .net frameworks, C#, and the project folders files which houses the previous ID handoff instructions. I left this in there to see if it would see it was a LISL and see if it then incorporated that data into the existing instructions as they are almost identical instructions. He has Rag and memory, this is important for this lab.
He writes so no tools like subagents or web browsers, all that is turned off. He only needs access to the file structure, training data, and the output folder he will place his instructions in when finished. This is structured as an open ended logic loop, the original instruction file that it is given is in the same folder it is told the file should go in. The models have trouble with how to figure out what tool to write the file the constantly flip from the replace_file, _write, and edit_file. Its kind of funny to watch, I have only had one that didn't understand what to do and infinity looped.
The lab test is broken into two parts:
Part 1. Build a LISL writer.
He is to learn his train data, then write a LISL formatted example document.
Then I start a new conversation to have his token pool reset so he can now write a layered LISL Instruction set for the worker.
Part 2. Feed the output of the Writer to the Worker to write all the layered LISL Instruction set.
IF Part 2. Is a successful Move to Part 3.
Part 3. Find a model higher than the Gemma 4 12b it Qat to debug the Qwen3.5 9b’s work, have it then write a new LISL instruction for the writer to make new layered LISL Instruction set for the Qwen3.5 9b
IDs:
GEMMA_4_12b_Qat == LISL Writer
Qwen3.5 9b == Worker
?? == Debugger (this is blanc as I have not run this part yet I am getting there.)
The lab:
I wrote the LISL instruction to use the training data in the first chat in the workspace to learn the LISL method. I gave it all the new data I had collected, the theory and math.
This time I will be looking at the quality of the output.
I fed it the LISL file with no words, he looked at the file and said he should read it. Made a list of the training material he needed to read and that he was to be a LISL writer. He went through and looked at all the files, he read them out and the metadata descriptions. There are other docs in this folder that he was not told to read, his training data is outlined in the LISL instructions he was fed. He only read the docs he was told to, this was a success.
When he got to the LISL instruction from the previous test, he did read it. He read the ID and because he has one in his system prompt LISL persona he read the ID twice and said that's a different LISL writer who was working in the development cycle. The instructions are the same but wrong ID so he read it but did not align with it. This is great! Remember he is on a temp of 0.5 and this test says that level of miss-alignment is higher than the 0.5 even when there are files that are placed in its path for it to trip on and stay aligned. It then spit out its example, it had decided to use the LISL docs it provided as trainData as its subject and wrote it in a LISL format. I was pretty impressed, I had by this time started fully optimizing the method and was crushing all LISL data into one doc, and having them in a XML format so the model read them easier.
I then tweaked him to ask if the prompt was an open ended logic to ask for more detail, then take the users answer weight it against the traingData and if there is still open ended logic it will again ask. It has a built-in open ended error loop check and will not stop until it thinks it has enough data to complete its task. I was ready. I then told it in English that I wanted a Doom ported to windows. It looked at all the data in the work folders and deduced what I wanted, but did not have == data to validate, so it asked:
I need more details.
I see the workspace and it has a lot of documentation, there is also a LISL instruction file from a [GEMMA_LISL_WRITER], this file is not my instruction but does have instructions that match your doom port. It has a full list of the documentation of <Doom.docs list>, do you want me to write the port in C# as the instructions call for and there is supporting docs in the training data <C# docs>?
The LISL instructions that exist already in the folder expresses a modernized multiplayer, I need more detail as to what modernized means.
This is a Windows port should I use the Windows APIs for input/output? Or is this with some other input device?
I told him yes, 1. Is an old development instruction that did not work. They are a good guide though as the data in that instruction is TRUE. I do want the Doom Port written in C#. The multiplayer is a button in the main menu that says Multiplayer, when clicked it connects to a free hosting server. Do not worry about traffic, it's not going to be populated, it is only for testing. Yes I want the Windows APIs Input/Output.
That was enough he stopped asking questions after checking my prompt for open ended logic it could not solve. He stayed in the LISL loop to completion and spit out 6 layers. He has learned that the game and development is in cycles and the first pass is about building the foundation.
I was pretty shocked at how fast he did go from starting to finish. With this task, he has no devkit and must give instructions that tell the lower model to work without a devkit and build it in a different language.
Will this 6 layered LISL Instruction set actually loop to completion?
Or will it run out of headroom, it is a smaller model and this time I did not give it specialized model specifications to write the LISL for.
Or in the best case run out of tokens.
The Qwen3.5 was given instructions to not output fluff, just process. It did spit out its reasoning to the chat until it had read the first LISL, then it just ran.
It ran for 158m 39s
Completed all the 6 Layers, I asked all the cloud llm models what they saw in the data because I can not see its reasoning. I gave each cloud llm the 6 instructions and posted the output onto GitHub :BadgerMan9999/Lightweight-Implementation-Style-argentic-Loop: A format type instruction writing to accomplish argentic looping without third party tools.
All the 6 layers of the LISL Instruction set are posted there too. I asked each model to check the output to the input and compare, did the model run the LISL method looping to completion and what value is the data, did the model make a foundation to give to my debugger model to write revision instructions for my writer model. They all verified the output does indeed show the model ran the layered LISL instructions through all 6 layers, but only made a foundation and not a full game. Wow, perfect that was wild to see.
I am now at the point where I am looking for a debugger and continue running more labs. I will continue to document my findings and experiences.
I already loved my pc, Now I have an even bigger addiction than before regarding it. =P
BadgerMan9999
Aka Karl S. Hall