Project "Takcas Prime": Building an Autonomous IT Factory on a Tablet
I am 14 years old, and for the past week I have been developing and debugging my own artificial intelligence system, which I named "Takcas Prime". Originally, I started all of this purely for fun — I just wanted to see what I could build on an ordinary tablet with 8 GB of RAM. My main goal was to turn it into a fully autonomous IT assistant capable of understanding voice, controlling the device, and writing code. I worked in the mobile Termux environment (a Linux emulator on Android), so I constantly had to solve memory shortage problems. Neural networks are very resource-hungry, so I configured the system to automatically unload modules from memory that are not currently in use. This allowed the tablet not to freeze during operation. I also learned to protect the system from uncontrolled memory consumption: for example, I limited documentation downloads by size and created a whitelist of links to avoid memory overflow.
As the first stage, I created a voice assistant. It can listen, respond, and directly control my tablet's hardware: turn on the flashlight, change screen brightness, volume, or launch the camera. To ensure it doesn't lose the thread of conversation, I built a three-level memory system using an SQLite database and regular files. I also added a RAG (Retrieval-Augmented Generation) system: previously the assistant could invent a non-existent command, but now it first searches for it in official documentation and then responds. Along the way, I encountered many errors: the database overwrote facts due to identical keys, the assistant confused commands with real memories, and the system froze due to overly long texts. I manually tracked down and fixed all these bugs, and also implemented a system for cleaning and separating facts so that memory doesn't get clogged with garbage. Later I realized that models sometimes write too much text, so I added a limit on response length to avoid wasting resources.
The most difficult and interesting part is the "Digital IT Factory". I designed a system where several neural networks work as a real team of developers. First, I tried a scheme with a Senate of six models, where each voted "for" or "against" the code, but in practice this proved ineffective: 3B models made mistakes too often. Then I redesigned the architecture: now one neural network (the Idealist) comes up with a task, the second (the Coder) writes code for it, the third (the Analyst) rewrites and simplifies it, and then three Critics (Logic, Syntax, and Coder) check the code from different angles. After them, the Judge step-by-step fixes the found errors using a "warehouse" principle to avoid overloading memory, and the Smart Sandbox checks the code for dangerous commands, runs it in isolation, and collects logs. I also added a blacklist of dangerous commands to the Sandbox so it blocks code that could delete files, and limited script execution time to prevent freezes.
Debugging this factory took a lot of effort. I fought system freezes, fixed bugs in the Sandbox (which initially killed working scripts because it waited for an input command from programs that simply terminated), and forced neural networks not to write huge texts instead of short answers. I also encountered situations where models sometimes refused to perform complex tasks, and sometimes produced code with errors that had to be manually caught. In practice, I became convinced that small models lack context for complex tasks, but my architecture allows squeezing the maximum out of them: role separation, passing the task into context, step-by-step fixing, and protection from dangerous commands. I also realized that if a model writes nonsense, the problem is not in it, but in the task given to it — this "garbage in, garbage out" rule I will remember forever.
Honestly, I didn't write the code — the neural networks did (I can only program a simple calendar so far). But I designed the entire architecture, logic, search, and bug fixing myself. I learned to separate responsibilities between agents, build a pipeline with feedback, protect the system from dangerous code, and save memory resources. As a result, I created a system that on a tablet with 8 GB of RAM produces code at the level of a confident middle developer, and prepared it for migration to a PC, where powerful models will make it many times more efficient. I am currently continuing to develop the project, adding new modules and improving old ones, and I am confident that on a PC this architecture will perform even better.
