Rob de la Teja

Applied AI, independent software, language, and creative systems — built on local execution, explicit permission, and records you can check.

I build software, research instruments, and creative tools with AI. The work runs from local inference infrastructure and custom Android device fleets to multilingual atlases, music workstations, zero-relay camera systems, and behavioral experiments that log their own failure modes.

Underneath all of it is one conviction: what a person says, makes, and keeps belongs to that person. Every system below is an attempt to make that true in practice: your words stay yours, your data stays where you put it, and no model changes your work without showing you what it did. I treat this as a creed. When a design decision gets hard, it is the invariant I return to.

My background is in journalism, language, editorial work, and a decade in the New York wine trade. Those disciplines shape how I use models: define the question, examine the primary source, compare alternatives, make the criteria explicit, and distinguish a convincing answer from a supported one.

I work across the whole process: product concept, interface, data structure, implementation, testing, packaging, documentation, and revision. Frontier and uncensored APIs are part of my daily working environment. At home, I build and operate the open-weight infrastructure that lets me examine the entire system myself.

Cross-Provider Routing & Empirical Verification

My daily practice spans Venice, Opus, GPT, Gemini, and Fable, with Claude Code and Codex in the terminal. I use different models for systems coding, source comparison, writing, visual synthesis, and adversarial criticism. Working across providers makes their differences visible: what they notice, what they miss, how they handle long instructions, where a policy layer triggers a refusal, and where fluent output conceals a broken assumption.

Scheduled routines handle recurring work, including my job and research pipelines. Larger builds accumulate specifications, issue records, verification notes, and handoffs so that work can continue cleanly across sessions and agents. The model contributes to the implementation; I remain responsible for the product decisions, the evidence, and what I claim the result can do.

MoHu and Local Studio: The Stack on My Own Silicon

MoHu brings local language and image models into an in-process working environment on an RTX 5090 (24GB VRAM) system, with a separate control laptop and private Tailscale connectivity. The stack includes Qwen and Gemma through Ollama and llama-cpp-python, OpenAI-compatible local APIs, ComfyUI image workflows, OpenVINO tools in GIMP 3, LoRA training on my own reference sets, and retrieval over private documents.

There is practical systems engineering underneath that list: model discovery, hard context budgets, streaming responses, deterministic VRAM release, job queues, and GPU guards. Private, shareable, and open material sit behind distinct directory boundaries. Cloud routing is always an explicit choice.

Local Studio provides a unified local control plane for text generation, images, document search, and configured training scripts. It brings engine connections, source references, logs, and job controls into one interface. Its document search uses a local text index; its training controls launch separately prepared trainers. Each capability is described at the exact level actually implemented on disk.

Fuego and MoHuOS: Sovereignty at the Hardware Edge

I repurpose Fire tablets as dedicated clients for my own applications, using a sideloaded Android software layer and Karnak, a custom launcher written in Kotlin. The tablets connect to the home rig with automated watchdog behavior and device-specific configuration.

The surrounding system includes a central hub, device heartbeats, an APK installation queue, and an auditable record of what was installed where. Substrato snapshots record disabled vendor services by package and date. Pulso monitors the rig's services, restarts assigned daemons when they fault, and reports state changes to the tablets.

Older hardware is a real design constraint. Interfaces have to remain responsive on limited memory and older Android WebViews, which governs architecture, visual effects, dependencies, and how much compute belongs on the device. Switching off vendor telemetry services is the same core conviction at device scale: I decide what a device I own is allowed to phone home about.

Cody Wong, Rama, and the ADHDossier Protocol

Cody Wong combines character architecture with a local agent implementation on Hermes. Trilingual on the surface and polyglot underneath, Cody's language, voice, and register constraints are built as a behavioral measuring device (documented in full at dearanthropic.fyi).

The runtime work is concrete. Cody can route across separate Ollama and Python inference paths backed by the same stored model weights, exposed through a shared API and integrated with Hermes, MoHu, and Local Studio. The implementation handles token streaming, discovery, structured tool calls, append-only ledger persistence, and model unloading.

Rama is a branchable local chat and coding workspace. A conversation can fork at any message, retry with another model, and maintain separate file versions for each branch. Proposed edits stay isolated in the branch until explicitly applied. The interface exposes diffs, saves timestamped backups, and detects when the underlying file has changed out of band.

The ADHDossier protocol gives this work a shared issue vocabulary: FD-numbered flags and SEV-1 through SEV-5 severity tiers, so people and agents can refer to the exact same unresolved problem across sessions.

Desktop Executables, Android Packages & Local Bridges

Image, Performance, Music Workstations, and Games

I build tools for inspecting and shaping raw material as well as generating it.

Parallel Studio is a local video workbench for identifying and tracking two people, constructing separate face-reference banks, previewing exchanges, adjusting occlusion masks, and rendering results. It retains source files and produces audit reports covering model and source hashes, unresolved frames, and export checks alongside a separate body-motion research workbench. The limits of each are documented.

An avatar runtime connects MediaPipe facial tracking to a VRM character and OBS in real time. Cody's broader development brings together character spec, multilingual performance, visual identity, and local voice tooling.

My music work spans Más樂 / MasMusic and its Pocket and Studio interfaces, with editable patterns, instruments, arrangements, mixer controls, and MIDI and WAV tools. The design principle is that a musical result must remain something a person can inspect and change. I come to that as a working songwriter in the reggaeton and neoperreo space, writing in English and Spanish, so the tools are built by someone who needs them to survive a real studio session.

Resonant develops that principle through a separate workstation design and interaction prototype: select a musical object, preview a variation beside the original, keep it or discard it, and undo the change. Its product blueprint and workflow specifications are kept distinct from the audio engine and model integrations still to be built.

Rogue Goddess extends the practice into game modification and systems work, including controller mappings, HUD behavior, textures, and playable builds. Automated input checks and physical playtesting are tracked in separate ledgers.

Language as Data, History, and Interface

A substantial body of connected work with its own datasets, visualizations, quantitative scoring rubrics, and editorial decisions:

• Living Language Loom+ follows slang between cultures and generations through a braided timeline, geographic movement, and a lexicon of 386 threads. Contested entries are flagged, and its timeline distinguishes historical material from a speculative future horizon.
• The Nube brings together 893 words for Earth, world, and globe across 442 languages, with etymologies and source notes. The visualization is supported by a corpus whose origins remain visible.
• Atlas of Tongues examines roughly 217 languages and 74 divisions between spoken and written forms, using a published scoring rubric.
• Atlas of Alphabets maps roughly 228 writing systems through geography and time as a companion to the language atlas.
• The Glyph Selvedge studies 42 typographical glyphs that left everyday use, using explicit scoring criteria, bias flags, and a record of rejected folk etymologies.
• Code Switcher explores what switching between Spanish, English, and Chinese can suggest about a speaker's voice. Its stages distinguish implemented processing from hand-authored interpretation.
• Oo explores a constructed language for children in which each word occupies one byte.

Across these projects, I design both the data structures and the experience of reading them. Attribution, contested classifications, and uncertainty belong in the interface. Slang, code-switching, and the words a community keeps for itself are speech that institutions have tended to flatten, so the work treats a speaker's own usage as primary evidence worth preserving—and treats the tools that record it as obligated to say where their authority ends.

Testing Whether Behavior Deserves Confidence

Some projects investigate a question; others build the instrument needed to investigate it.

• Atlas of Energy assembles roughly 420 sourced records about how energy is produced and moved. I directed the editorial structure and design, with Claude assisting compilation and citations attached at the record level.
• Divide by Zero and its companion atlas examine fifteen places where scientific explanation encounters a limit. Each asks what remains unknown, which framework produces that limit, what evidence could change the answer, and which claims remain contested.
• Turing Bench is a browser reaction-diffusion simulator with deterministic records. It supports the investigation described in The Floor Beneath the Instability: a documented case in which floating-point rounding suppresses an expected instability, and reducing the simulation's time step makes that suppression worse. The finding is bounded by its implementation and test conditions; broader novelty remains an open question.
• NVIDIAddict combines a market digest with forecasts recorded before their outcomes are known. The backend grades resolved forecasts using Brier scores and calibration tables, then supplies that track record to subsequent analysis. This makes errors inspectable and probabilities accountable. Whether the feedback improves later forecasts is something the record can test.

That distinction runs through the practice: an integration test establishes that components communicated; a useful evaluation asks whether the resulting behavior deserves confidence.

Convictions, Stated Plainly

I build around two commitments that I hold as convictions rather than product preferences: that people must be free to say what they think, and that they must be free to keep what they have not chosen to share. They are the same commitment seen from two sides. Speech without privacy is exposure, and privacy without speech is silence. I hold both as non-negotiable by convenience, deadline, or business model.

In engineering terms they become specific, checkable practices:

• Local execution by default, with explicit permission required before a byte leaves the machine.
• Preserved originals and reviewable diffs, so whenever a model touches someone's work, the person can see what changed and recover the previous version.
• Disclosed compute quotes (AllMyCity), branch-isolated edits and backups (Rama), retained source material (Recorte and Parallel Studio), zero accounts, relays, or telemetry (OJO), and explicit boundaries between a prototype, a tested local build, a hosted application, and a capability that still needs validation.

Languages, Local Runtimes & Infrastructure