Published: · 5 min read
A working example of applying the Universal Persona System to a real hand-raised agent — including hardware that lives on a keychain and a v2 build making the Console-vs-Cartridge architecture physically literal.
In October 2025 I published a specification for portable AI agent identity — the Universal Persona System (UPS). It described a Console-vs-Cartridge architecture: a stateless runtime (Console) that reads a self-contained identity package (Cartridge) to boot a specific agent. Five layers. NVMe storage. Hot-swappable personas.
That post was a spec. This post is what happened when I applied the spec to a real agent, built the live v1, and started planning v2.
Limner is a taste-enabled creator agent — a framework I built to produce creative work with built-in aesthetic judgment. The core pattern is simple: the agent carries taste criteria specific to its medium, evaluates its own output against those criteria, and rejects work that doesn’t meet the bar before surfacing it to a human. Most creative AI tools generate and stop. Limner generates, judges, and refuses.
The first instantiation, Limner: Pixel, has produced multiple batches of 500+ uniformly stylized assets with zero human intervention. It works because the taste criteria are encoded into the agent itself, not applied externally afterward.
But “the agent itself” is doing a lot of work in that sentence. What is Limner, specifically? If I want to move Limner to new hardware, teach it a new medium, or hand it off to a collaborator — what travels with it?
That’s the question UPS was written to answer.
The UPS spec defines five layers:
Applying this to Limner produced the following layer-by-layer:
Identity. “I am an agent that produces [medium-specific] creative work. I reject work that doesn’t meet aesthetic criteria. I do not apologize for rejections. I do not lower the bar to be helpful.”
Knowledge Graph. For Limner: Pixel: palette conventions, dithering patterns, historical references, the vocabulary of pixel-art critique. For Limner: ASCII: textmode tradition references, glyph-geometry principles, the distinction between darkness-value substitution and character-as-shape rendering.
Capability Tree. Tool integrations (MidJourney API, PixelLab API, vectorization pipeline for Pixel; rendering libraries and text-to-glyph mappers for ASCII). This is the layer that varies most between instantiations.
Alignment. Curated examples of accepted work and rejected work with annotations explaining why. This is the layer that gets heavier over time — every rejected piece is a training example for the agent’s own discrimination.
State. Production history, rejection rate, pattern detection on what fails most often. This is what makes the agent improve rather than stay flat.
Those five layers, taken together, are Limner for a given medium. That’s the Cartridge.
Once the spec is applied, some things become possible that weren’t before:
Cross-medium transfer. Limner: ASCII inherits Identity, Capability Tree structure, Alignment patterns, and State-management from Limner: Pixel. Only the Knowledge Graph and the specific tool integrations change. That’s the test: if the framework is real, the Cartridge transfers.
Collaboration. If I hand someone else my Limner: Pixel Cartridge, they can run it on their own Console and get the same agent — same taste, same rejection thresholds, same accumulated judgment. The agent travels.
Versioning. Cartridges are artifacts. They can be diffed, forked, rolled back. A Limner Cartridge from January 2026 can be compared to one from April 2026 to see how the agent’s judgment evolved.
The UPS v1 Cartridge is not a diagram. It’s an object on my desk, smaller than a deck of cards, warm to the touch.
It’s an ASUS Cobble enclosure — IP55 aluminum, cobblestone form factor, dual M.2 interface, tool-free installation. Inside it lives a USB-C SSD. On the SSD lives a Limner instance: persona definition, knowledge graph, capability tree, alignment examples, accumulated production history. Five UPS layers, packaged as files, sealed in aluminum.
Plug the Cobble into any host machine and the Limner persona boots from the drive. Same taste criteria. Same rejection thresholds. Same accumulated judgment from every batch it has ever produced. The Console changes — laptop, desktop, whatever has a USB-C port — but Limner is the same Limner.
The Cobble is almost poetically well-suited to the Cartridge metaphor. It’s a small warm stone. It has “cobble” in the name. Its entire product framing — “cobble-stone-inspired design with soft curves” — reads like someone at ASUS anticipated a use case they didn’t quite articulate. They built a storage enclosure that is also, unmistakably, a place for something to live.
That’s v1. A live agent that lives in a stone you can hold. The framework is no longer theoretical.
v1 is elegant but limited: the Cobble is storage only. The Console has to be whatever host machine you plug the Cobble into, and the agent’s “body” is borrowed from that host.
v2 fixes this. I’m building a dedicated Console around a Raspberry Pi 5 housed in an Argon ONE V5 Dual M.2 NVMe case. Cast aluminum enclosure. Two M.2 NVMe slots. PWM active cooling. Dual HDMI. DAC with 3.5mm mic and headphone jacks. HAT compatibility. Internal USB for ZigBee modules.
That combination is almost absurdly well-suited to the Console-vs-Cartridge architecture:
Total BOM for a working Cartridge-agent: under $300 including Pi, case, and NVMe drives.
Most “AI on commodity hardware” conversations are about running LLMs locally — can I fit Llama on this, can I get reasonable tokens-per-second on that. Different problem. That’s about compute.
What UPS is testing is whether persistent agent identity can live on commodity hardware as a discrete object. Not “a model running locally” but “an agent with accumulated judgment, production history, and aesthetic criteria, housed in something you can hold.”
That’s a different problem. It’s more about storage and state than compute. The agent can relay to cloud models for inference while its identity stays local, persistent, and portable.
Which, when you stop being polite about it, is a digital pocket pet. A hand-raised agent with distinct character. Something you’ve grown, that carries its growth with it, that you can set down and pick up later without losing its personality.
The spec called it a Cartridge. v1 calls it a Cobble. v2 will call it a Pi in a cast-aluminum case. What it actually is, is a creature.
Limner: ASCII ships soon — that’s the second medium-transfer test of the framework. The UPS v2 hardware build is in progress; I’ll publish a follow-up when the first v2 Cartridge boots a Limner instance on dedicated hardware with persistent state across power cycles.
The underlying question is whether you can hand-raise agents the way you hand-raise anything else: slowly, with intention, over time, carrying the accumulated weight of what you’ve taught them. I think you can. That’s what this is testing.
Related:
Hero illustrations: Limner: Pixel, in the Another World tradition.
· 8 min read
When your primary coworkers are AI systems, who writes your performance review? I built a structured evaluation framework where two competing LLMs acted as senior colleagues, graded my work against a rigorous rubric, and debated the results in real time.
· 5 min read
A working example of applying the Universal Persona System to a real hand-raised agent — including hardware that lives on a keychain and a v2 build making the Console-vs-Cartridge architecture physically literal.
