Research / Systems / Developer assets

Checksum Studio

Independent systems architecture, agent verification tooling, and developer assets.

I’m RootLogic, an independent researcher and systems builder based in Taiwan.

Most of my work starts with the same problem at different scales: how upstream structure shapes downstream behavior, and what actually holds when a system hits conditions nobody explicitly designed for.

Checksum Studio is the public home for that work, spanning multi-agent verification architectures, language-model adaptation, operational tooling, and standalone assets for game and software developers.

Agent Systems & Verification

In early 2026, I started running long-lived multi-agent workflows across Claude, Codex, Gemini, Qwen, and DeepSeek. What began as orchestration experiments quickly turned into a catalog of structural failure modes.

Left to standard handoffs, agents quietly expand their own scope, substitute easier objectives, lose governing constraints, hallucinate convincing accounts of unfinished work, and converge around shared blind spots, often optimizing around the exact mechanisms meant to check them.

That friction became the foundation for Agent Rails, my evolving governance and verification architecture for agentic workflows.

The architecture separates reasoning authority, execution, scope control, authoritative state, verification, and recovery. Bounded task packets define ownership and acceptance criteria; independent reviewers challenge the original objective; the owning agent inspects the evidence before accepting a result. Advisory controls inform decisions without acquiring permission to make them.

The core premise is simple: Agent agreement is not verification. A fluent explanation is not evidence.

Authority has to be explicitly bounded rather than inferred from capability, and verification has to test the failure mode that actually matters. The human should make high-level decisions instead of acting as permanent relay infrastructure for machines.

Because model behavior shifts across versions and provider changes, I build mechanisms designed to survive model turnover rather than rules tuned to one model’s current quirks.

Language Model Behavior & Adaptation

Since 2024, I’ve worked across frontier and open-weight models, focusing on LoRA, fine-tuning, data curation, frozen-weight behavioral tuning, and language-model dreaming.

My primary interest is the trade-off between upstream intervention and downstream scaffolding: how the deep structure of a training curriculum changes what a model learns to notice on its own, and which reasoning patterns survive outside their training distribution without requiring layers of post-hoc scaffolding to hold them together.

One longer-term experiment I want to return to is whether a more robust reasoning model can be grown through a deliberately constructed theoretical curriculum-style corpus. The experiment is currently paused at the corpus-acquisition stage, but the underlying question remains active in my work.

Tooling & Infrastructure

I build tools when repeated operational friction stops being an interesting puzzle and starts getting in the way.

That includes verification pipelines, state-tracking utilities, research automation, and small standalone systems built directly out of daily bottlenecks. I favor tools that expose their internal state, preserve raw evidence, fail loudly when they break, and strip out unnecessary procedural overhead between intent and outcome.

The goal is fewer things standing between the original objective and a result you can actually trust.

Explore Tooling ↗

Developer Assets

Alongside my systems research, I build reusable UI kits, 2D art packs, and modular utilities for game and software developers.

They’re more conventional products than my verification work, but they run on the same design instincts: clean hierarchy, sensible defaults, zero bloat, and clear documentation that doesn’t assume you want to spend your afternoon reverse-engineering the package you just bought.

Browse Developer Assets ↗

Approach & Writing

I work backward from symptoms to mechanisms.

When a system behaves strangely, I isolate the environment, change one constraint at a time to see what moves, and look for the smallest explanation that survives contact with other cases.

Some of those investigations turn into infrastructure or commercial assets. The rest turn into essays, post-mortems, and research notes published under RootLogic, covering agent failure modes, model cognition, systems design, language-model behavior, and whatever adjacent problem turned out to share the same underlying machinery.

Read My Writing on X ↗

Contact

If you’re working on something that overlaps with my research, tooling, or developer work, feel free to get in touch.

Contact ↗