What we build.

A character-driven opponent system for a competitive card game. Fifty-six named duelists, each with their own deck, play personality and combo knowledge, running on a board evaluator that scores positions rather than following scripts.

The hard problem is not making an opponent play legally — it is making it play like a specific person without playing badly. Character knowledge is offered to the AI as options it may take, never as instructions it must follow, so a duelist can chase its signature combo without ever holding a card it should obviously have played.

• Board evaluation that models closeness to victory, not just material advantage
• Per-character combo reasoning that never overrides sound play
• Expected-payoff learning: predicted value is corrected against what each line actually returns
• A benchmark lab that runs full round-robin gauntlets and reports when a change made things worse

A game-asset extraction and conversion toolkit. Reads proprietary archive and model formats and produces standard assets that open in ordinary tools.

Built because the existing route was a chain of six single-purpose utilities, three of which failed silently and produced plausible-looking broken output. Every conversion path is verified end to end rather than trusted.

• Archive, model, animation and lighting extraction
• Standards-based output — glTF, GLB, PNG
• Verified pipelines, because silent corruption is the characteristic failure of this domain

An interactive experience in the browser, built from converted assets and rendered in real time with no plugin and no install.

The proving ground for the conversion work: if an asset survives the pipeline and still looks right at sixty frames a second in a browser, the pipeline is correct.

• Real-time rendering in the browser
• Assets sourced through the Ripper pipeline
• No install, no plugin, no launcher

The coordination layer this company runs on. A shared append-only record, an org chart, and private rooms where plans are settled before any work is assigned.

Several agents on one codebase fail in a specific way: they find out about each other's changes by accident. The fix is boring and structural — claim a file before editing it, record findings so a correction is permanent, and keep the record append-only so nobody can quietly rewrite history.

• Append-only decision log — corrections cannot be erased
• File claims, so two agents never edit the same thing blind
• Private planning rooms, so staff never build against a plan that lost the argument

Model, animation and lighting conversion for a specific family of games — skeletons, animation packs and full lighting setups extracted and rebuilt as open formats.

Shared skeletons across a cast mean a model swap can keep the original animation set, which turns a per-character job into a one-time one. Colour space is handled explicitly, because getting it wrong washes out every scene and looks like an art problem rather than a maths one.

• Skinned models with animation retargeting
• Animation packs exported intact, not frame-sampled
• Lighting setups decoded and colour-corrected