Saying Please to an LLM: Building an Interactive Window with an Open-Weight Model

Testing Weights

To distinguish the actuality of large language models (LLMs) from the corporate hype, I dedicated three months to load-testing open-weight LLMs inside the CUNY AI Lab (CAIL) zero-retention Sandbox. Built on Open WebUI, this secure environment allowed me to deploy these systems without my data being mined, retained, and commodified by corporations, as all requests to external providers strictly prohibit model training and are configured for zero data retention. Operating within this protected infrastructure, I entered the Sandbox with a clear position: push the models to their breaking point, map where and how they succeeded and failed, and apply the garnered knowledge toward building a Nuyorican LLM for the Nuyorican Poets Cafe Founders Archive Project (NPCFAP).

To find the point where the algorithm fractured, I needed to move beyond casual chat prompts to test and analyze the architecture and configurations themselves, i.e., “the black box.” To do so, I turned to Open WebUI’s workspace view and built a custom AI model dedicated to experimentation; my objective was to design a system that would propel my chosen open-weight model to its absolute limits. I commenced by naming it Experimental.AI, crafting detailed background instructions (the system prompts), and calibrating the underlying parameters, such as the “temperature” that controls its statistical randomness. I tuned the model until the LLM modifications I wanted emerged. In this protracted process, I pushed Experimental.AI to its limits, noting the exact intervals where it couldn’t keep up with the conversation, offered incorrect feedback, or began to hallucinate.

Once I had seemingly outlined the boundaries of Experimental.AI’s text generation, I shifted to testing the platform’s programmatic capabilities. I began by researching and implementing the Open WebUI community’s custom “tools”—external Python scripts created by independent developers that enable the LLM to execute modular tasks rather than simply returning text. Here, I discovered that the LLM’s chat interface possessed incredible malleability. By executing custom Python code, the model could render actual user interfaces (UIs) using cascading style sheets (CSS) and hypertext markup language (HTML) directly in the chat. Utilizing the community’s open-source code, I saw functional weather apps, dynamic maps, and podcast players materialize with a single prompt. Apparently, if it could be conceptualized, it could be assembled.

Then, the whole game shifted, and the entire impetus for why I was in the Sandbox changed with it. I went from wanting to break open the machine to realizing I could actually build with it. I saw this potential to create with LLMs firsthand when a fellow Open WebUI community member, @GCSK1982, released an open-source American Psychological Association (APA) citation tool.

Their script was pure text: toggle the tool, and the LLM generated an APA citation. The reality was the baseline model already possessed this capability, albeit with vexing margins of error. Yet, armed with my earlier discoveries about the Sandbox’s visual capabilities, an epiphany struck: I could rewrite the Python logic to include the Modern Language Association (MLA) format, retain the APA framework, and re-engineer the code to generate an interactive window with a full front-end UI. When constructed, this interface would allow users to generate unlimited citations from a single window, breaking the cycle of endless prompting. One prompt, unlimited citations.

This realization birthed AskCite, named in homage to the early search engine Ask Jeeves. Functioning as a specialized Python tool, it produced a clean, persistent visual interface directly within the chat. By design, a user simply had to issue a single command or natural inquiry—like, “Cite Lois Elaine Griffith’s You See What You See (2025) using AskCite”—and the interactive window would materialize. Experimental.AI would then render a dedicated UI displaying the formatted citation, alongside editable text fields to correct author and publication details if the model hallucinated.

The Illusion of Relation

To construct the AskCite interface, I employed GLM 5.1, an open-weight model trained by Zhipu AI. However, attempting to force stringent, functional code out of a conversational interface quickly became a lesson in the limits of LLMs. I found myself trapped in the exact mad cycle of prolix prompting I had set out to mitigate. The harder I fought to refine AskCite’s layout and Python code, the more the underlying system began to rupture.

Experimental.AI hallucinated relentlessly, displaying broken interfaces and spitting out unprompted historical trivia (“The Romans believed in white teeth and fresh breath!”) instead of AskCite. I even recalibrated every advanced parameter at my disposal—tuning the temperature to eliminate statistical randomness, adjusting repetition penalties to prevent the model from looping broken syntax, and modifying Top-P sampling to actively suppress the system’s hallucinations. Yet, regardless of these hyperparameters, the interface I envisioned never populated within the chat.

Trapped in an incessant troubleshooting loop, I noticed a profound shift in my demeanor: I had begun typing “please” and “thank you.” Alone in my apartment, staring into the Sandbox, I was cajoling a probabilistic machine—pleading with a damn LLM—and treating an inanimate architecture of code as an autonomous collaborator. My desire to complete AskCite had eroded my critical distance, causing me to project humanity onto an LLM just to get the code to work. I absurdly hoped some form of respectability politics might coax it into compliance—might be coded into its system. Evidently, it appears that attempting to build with LLMs forced a beguiling anthropomorphic entanglement, turning technical failures into interpersonal annoyances while extracting heavy costs—physiological, psychological, environmental, and electrical—in the process.

The Jupyter Save

After hours of contending with a hallucinating machine, I abandoned Experimental.AI, exported the provisional code, and opened a Jupyter notebook—an interactive coding environment designed for modular execution of Python code. Although I was already familiar with Jupyter from prior coursework and practice, the specific task ahead of me was entirely new. To find answers, I turned to documentation, Stack Overflow threads, and forum posts written by humans who shared their knowledge without condition—programmers who had tested and resolved the exact hurdles I faced in the notebook.

Within twenty minutes, the interface I had begged an algorithmic model to render took shape on my screen. When errors appeared in Jupyter, they were legible, traceable, and mine to solve. The CAIL Sandbox had served its initial purpose as a secure, zero-retention space designed to stress-test these models, map their fractures, and shorn corporate hype. However, my experience confirmed a hard limit: insistent troubleshooting and nascent automated systems alone cannot build sustainable infrastructure. Free from the chatbot, there was no LLM to plead with and no anthropomorphic fetter to break—only code, human ingenuity, and the unconditioned solidarity of the open-source community that actually makes digital preservation possible.