u/Truth-Does-Not-Exist

Prism32: One Python file, uses only 6mb ram and can turn any system into a coding agent, a pc a robot, a autonomous jailbreaking tool and AI assistant

Read the code and readme and Install it now https://github.com/MegaDyneSystems/prism32

Prism32 is a single prism32.py file (about 410 KB) that runs on any device with Python 3.7 and a shell. It uses only the Python standard library. There are no pip dependencies, no local database server, and no Electron shell or Javascript.

I tested it on hardware I had found in the garbage like the TP-Link TL-WR1043ND from 2008 with an MIPS 32bit 24kc CPU and 27 MB of RAM running Prism32 pre-compiled using 6mb ram. An Amazon Fire TV Stick (MT8127 ARMv7, 874 MB RAM) runs the source directly. A Kindle Fire tablet (MT8186 ARM64, 3gb RAM) running on Termux accesible with SSH. A Synology DS414 NAS (Marvell Armada XP, ARMv7l, 1 GB RAM, DSM 6.x) The same file runs on Windows 11, macOS, and a Compaq Pentium III 800 MHz running NetBSD 10.1 with 512 MB RAM 320gb HDD, Arch Linux on a i9 13900hx and rtx 4080 64gb ram and runs at about the same speed on all systems, on the pentium III I had it create a snappy web UI I could access it from anywhere on the network in 2 minutes

Software robotics with no hardware mods or soldering

A PC already has a physical body. The webcam is its eyes. The microphone is its ears. The speakers are its voice. What it lacks is actuators, and those are cheaper than most people think.A CD-ROM tray gives about 4 inches of linear push/pull motion, runs on standard PC power, and opens and closes via two Python calls (`ctypes.windll.WINMM.mciSendStringW` on Windows, `os.system("eject -T")` on Linux). Tape a string to the tray, run it over the top of the case, tie it to a desk bell. Now the AI has a physical arm that can ring an alert when a terminal process finishes or when the webcam detects you've been staring at the same bug for ten minutes.A $10 Kasa or Tapo smart plug turns any mains-powered device into an actuator. The `python-kasa` library controls them over local Wi-Fi with no cloud dependency. Plug in a box fan, a USB heater, a lava lamp, or a radio. The AI decides when to switch them based on webcam input, calendar data, or whatever you give it. The agentic loop is the same in all cases: read a sensor, ask the model what to do, execute the tool, feed the result back.

Prism32 runs this loop natively. You describe the goal in plain language, `/extend temp` generates the plugin for your specific device, and the agent starts controlling physical hardware within minutes. A $15 TP-Link router with a USB Zigbee stick becomes a self-healing smart-home hub that generates MQTT plugins on the fly for whatever devices join the network. A junk PC with a webcam and a smart plug becomes a presence-detection robot that controls your room.

How the jailbreaks and installations worked

Prism32 carries its own installation logic. On the Fire TV Stick, it exploited the Android Debug Bridge daemon left open by the factory firmware, pushed a Termux APK sideload, and extracted a Python bootstrap from the Termux repository. On the Fire HD tablet, it used the same ADB path but added a userland escape through the Kindle FreeTime profile sandbox to gain shell access. The Synology NAS had no package manager and no $HOME directory; Prism32 detected the missing paths, wrote its runtime to /tmp/.prism32/, and created a wrapper in /tmp/.local/bin/. The OpenWrt router had 4 MB flash and 27 MB RAM. Prism32 downloaded a Python 3.7 .pyc prebuilt for MIPS, skipped the syntax-check step to avoid an out-of-memory kill, and installed to a 240gb ssd mounted through the USB port

None of these required manual SSH sessions. I just either enabled developer mode if needed gave the User the info and credentials from the tags The agent identified the platform, found the weakest privilege boundary, drivers and wrote the plugin that performed the breakout and logged all the steps.

Architecture: blocks instead of JSON schemas

Prism32 is not a chatbot wrapper. It is a command-execution harness with a feedback loop. The AI writes shell commands inside markdown execute blocks. Prism32 runs them, captures stdout, stderr, and exit codes, and feeds the results back to the AI. The model then decides the next step. This repeats until the task finishes or you press Escape.

The architecture uses blocks instead of JSON tool schemas. Any OpenAI-compatible endpoint works: local llama.cpp, Ollama, Groq, Kimi, GLM, Qwen, OpenRouter, Anthropic, or a self-hosted API. The model can chain multiple commands in one response. If a model tries to use its native tool-calling format (Anthropic, Qwen, etc.), Prism32 detects the malformed output, converts it to execute blocks, and continues without breaking the session.

Self-extension without restarts

The /extend command asks the configured model to generate a Python plugin using only the standard library. Prism32 syntax-checks the code, writes it to ~/.prism32/plugins/, loads it immediately, and advertises the new command in the system prompt. Temporary plugins disappear when the session ends. Permanent plugins load on every boot.

I can ask it to monitor a 3D printer. you can connect your printer to your laptop or give prism it's credentiasl and it can install itself to the printers bare metal then generate a plugin that parses serial G-code responses, tracks temperatures, and alerts on thermal runaway. The plugin runs 5 minutes after you the request. No pip or restarts java or bloated RAM requirements in this RAMpocalypse

Quantum context and model mixing

Subagents share state through an in-memory key-value store called quantum context. A subagent scanning open ports drops its findings into /quantum target:192.168.1.50, and the main agent reads that value without polling. Subagents can run on different models and providers. I run the main session on a reasoning model through GLM5.2 fast while delegating bulk scanning to a harness with a free tier or kimi 2.6. The cost for the subagent task rounds to zero or pennies,

Harness absorption

If you have other AI CLI tools installed - Claude Code, Aider, Gemini CLI, OpenCode, Goose, Cursor, Hermes , Agent - Prism32 detects them with /harness scan and injects their availability into the AI context. The agent can then delegate a task to a "super subagent" seeded with those tools. Prism32 becomes a coordinator over every AI agent CLI on the machine, not a replacement for them.

Self-healing and evolution

/evolve on enables a mode where the agent inspects its own source code against a saved baseline, diffs it, and can generate plugins to patch gaps. It also scans the local system for tools, package managers, and external AI CLIs (OpenCode, Codex CLI, Claude Code, Aider, Gemini CLI, Goose, Cursor Agent) and records their availability. The agent can then delegate tasks to those harnesses, making Prism32 a coordinator over every AI CLI installed on the machine.

/extend temp <goal> asks the configured model to generate a stdlib-only Python plugin, syntax-checks it, writes it to ~/.prism32/, loads it, and makes the new slash command available immediately. No restart. Temporary plugins disappear on exit; permanent ones load every boot. The agent can use and create extensions whenever it needs to accomplish tasks

The plugin API covers context injection, HTTP helpers, scheduled callbacks, provider registration, and theme registration. The intended pattern is: add new capabilities as plugins rather than editing core code, so the 410KB source file stays auditable and diffable.

Context compression that works

When the conversation fills the model's context window, Prism32 does not crash or lose track. It reserves the most recent 8K tokens (or 30% of the window on small models), then builds a summary of the dropped messages containing the active objective, discovered IP addresses, file paths, error messages, and package versions. It scores each line by information density and keeps only the highest-scoring facts. The agent continues as if nothing happened.

What I am running now

On the OpenWrt router, Prism monitors the local network, detects new DHCP leases, and writes alerts to quantum context. The Synology NAS runs a subagent that checks disk health, scrubs the ZFS pool, and reports failed services. The Fire TV Stick runs a plugin that controls Kodi via HTTP API calls. The Fire HD tablet runs the main interactive session. All four devices share state through quantum context when I route them through the same API endpoint.

Why this differs from Claude Code, Aider, or Cursor Agent or Hermes

Those tools are editors. They require Node.js, large dependency trees, and specific project structures. Prism32 requires none of that. It runs on a 1.44 MB floppy disk and only 1.5mb post install. It auto-detects the OS, architecture, package manager, and shell, then adjusts every command it runs. It can turn a router into a smart-home hub, a Kindle into a reading companion, or a 1994 DEC AlphaStation into a machine with a modern AI brain. Or an old trash PC into a basic robot by connecting it with smart plugs or a webcam DVD or CD that can ring a bell by tying them with strings or drives USB gadgets as crude actuators and natural language to set it up in 5 minutes

The project is at github.com/MegaDyneSystems/prism32. Apache 2.0 licensed

Some automation ideas you could do with this

1. The $15 self-healing smart home. A TP-Link TL-WR1043ND with a USB Zigbee stick runs Prism32. When a new device joins the network, the agent generates an MQTT plugin on the fly, assigns it to a room, and writes the automation rules into quantum context. If the router reboots, the persistent plugins reload and the house resumes operation without cloud dependency and the agent can debug and diagnose issues.
2. Cross-device media intelligence. A Fire TV Stick runs Prism32 and indexes the NAS library. The Kindle Fire tablet queries the index: "Find me a 90-minute sci-fi film I have not watched." The NAS subagent searches filenames, the TV Stick subagent checks play history, and the tablet presents the result. No Plex server. No subscription.
3. The self-auditing NAS. A Synology DS414 runs Prism32 with /goal mode set to audit the server every morning. It checks for disk pressure, lists failed services, scans open ports, greps logs for authentication failures, and emails a summary. If it finds a recurring error pattern, it writes the fix into startup_memory.md and applies it automatically on the next boot.
4. Retro hardware resurrection. Someone installs Prism32 on an SGI Octane from 1997 or a Sun UltraSPARC workstation. The agent generates plugins that understand IRIX or Solaris system calls, reads legacy log formats, and translates them into modern monitoring alerts. A 28-year-old machine becomes a monitored node in a homelab. and can scrape the web for drivers or create new ones and backport new software for older OS's and systems
5. Automotive CAN bus diagnostics. A Comma.ai Openpilot device or Tesla MCU runs Prism32. The agent reads CAN bus traffic, scripts custom dashboard plugins, and detects anomaly patterns in driving data. If a sensor drifts, the agent flags it and generates a calibration routine.
6. The 3D printer that fixes itself. A Raspberry Pi inside a printer enclosure runs Prism32. It monitors temperatures, detects layer shifts from serial G-code responses, and generates plugins to adjust slicer settings mid-print. If a print fails, it writes the failure pattern into memory and avoids the same parameters next time or detects and stops spaghetti messes
7. The anti-ransomware router. An OpenWrt device runs Prism32 with a plugin that monitors SMB traffic for encryption patterns. If it detects a client writing high-entropy files at speed, it isolates the client from the network and alerts the admin or can take other actions. The detection logic updates itself based on new attack signatures the agent reads from security bulletins.
8. The reading companion on a jailbroken Kindle. A Kindle Paperwhite runs Prism32 under a minimal Linux environment. The user highlights a passage and asks, "What did Orwell write about this in 1946?" The agent fetches the relevant essay, cross-references it, and displays the summary on the e-ink screen.
9. The autonomous farm sensor mesh. A $15 OpenWrt router in a greenhouse coordinates soil moisture sensors, relay controllers, and weather APIs. When a sensor drops offline, the agent generates a plugin to poll the backup sensor, adjusts irrigation timing, and logs the event. No cloud service. No subscription.
10. The AI that maintains itself. A user enables /evolve on on a machine that runs 24/7. The agent periodically diffs its own source against the baseline, checks for updates via git, scans for new tools, and writes documentation about its own configuration. If the operator asks, "Why did you do X?" the agent points to the exact line in evolve.md where it recorded the reasoning.

Universal one click install:

curl -fsSL https://raw.githubusercontent.com/MegaDyneSystems/prism32/main/bootstrap.sh | sh

Install it in one click Install on OpenWrt:

wget -O /tmp/install.sh https://raw.githubusercontent.com/MegaDyneSystems/prism32/main/openwrt-install.sh

This is a solo developer project funded by the stuff I find and donations - Sebastian

https://github.com/MegaDyneSystems/prism32

supports subagents, goals, MacOS, Unix, linux, BSD, windows 7 +, minimum needed CPU is 386, tried it on an 800mhz pentium 3 and still got sub second startup time and less than 1% cpu usage during use without --slow-cpu flag, prism supports plugins and is small enough to fit on a floppy as it is only 500kbs. Releasing tonight on github. Of course it also supports local models cloud models and you can have the subagents be a different provider or local agent easily, this is much faster and more compatible than opencode, can't wait to see what people are able to run this thing on