Dispatches from the edge

The csg test level grew a fifth room, a second door, and a clock that finally ticks in the right decade. This week the BSP portal graph became the sound-propagation graph — room brushes are acoustic volumes, portals are paths, doors are valves — and Steam Audio's ray solve moved onto the job system. Plus: why FlatBuffers is vendored into the build and which of our hand-rolled binary formats should follow it.

We quadrupled the logic-model corpus to 96,506 decision records across 51 families, found that both finished runs peaked at epoch 4 — matching the published repeat-value knee almost exactly — and traced our gradient spikes to cold-init basin geometry rather than record length.

We shipped a stateful, Vulkan-trained decision model plus LRL — a small compiled language for chaining questions into branching decision programs — and scored the v6 checkpoint at 48.6% on a 2,540-record test set with an all-GPU eval path.

Protocol v6 puts a transferable, arbitrated authority stamp on every entity delta in the PI swarm — the plumbing that lets peer nodes simulate physics for entities they hold authority over while seeder arbiters keep the writes honest. The dynamic-authority model that Donnybrook, Aura Projection, and Glenn Fiedler's Oculus-sponsored VR work pointed at — plus how mirror seeders relay rooms, gossip, and signed entity state across the fabric.

Our mined dialogue corpus was full of mechanical garbage, so we built a teacher pass to clean it. The piece that makes it scale isn't a smarter model — it's a deterministic validator that decides what needs the teacher, what gets fixed for free, and what goes back for another try.

A field-report breakdown of the prompting methods behind the Behavioral Intelligence Lab — four pillars that each remove a different kind of ambiguity before generation starts, distilled from a six-month Claude session that built ten card-based webpages and a game NPC system from real psychology.

A companion guide to MIT 6.S191 Lecture 2: how recurrent networks carry memory through time, why backpropagation through time explodes or vanishes, and how the query-key-value search called attention replaced recurrence inside every modern transformer.

A small GRU character-level language model can generate training data for the next iteration of itself, graded by a frozen teacher checkpoint — a recursive self-improvement loop that avoids model collapse through continuous output distributions and curriculum-anchored grading.

Why standard mixed precision failed our GRU recurrent state, and the four-part architecture — block-diagonal W_hh, stochastic rounding, paired-FP16 state, pre-recurrence RMSNorm — that makes pure FP16 accumulators viable on the RTX 3080 Ti tensor cores.

Three days of Cat Chat GRU-L3 pretraining: a special-token ID bug that invalidated R0 checkpoints, a full R0 regression post-mortem, a 5-fix roast of the R1 config and trainer, and a corpus-cycle-based teacher-forcing plan.

Three epochs into Cat Chat GRU-L3-V3 character-level pretraining on a 100-token ASCII vocabulary, we visualized per-layer loss landscapes, added scheduled sampling with teacher-forcing decay, and built a two-model dialogue generator that streams JSONL conversation records between epoch checkpoints.

Our first production pretraining run on NVIDIA L40S via Brev: 75.9M-parameter GRU-L3-V3a character-level language model, 384k sequences, 6.9 hours, eval top-1 64.5%.

Scaling our native GRU-L3 cat_chat from 3.3M to 75.9M parameters using A18 gradient checkpointing, sqrt-scaled gradient clipping, and a 20-epoch TF decay schedule targeting free-running generation.

Bruce Schneier's DEF CON 34 talk generalizes hacking to every system of rules, then hands defenders a real agenda: VulnOps, patch velocity, agent containment, and integrity. We fact-check the talk and map its lessons onto our own attack surface.

A compact 4.8M parameter GRU-L3 character-level language model trained on a single RTX 3080 Ti via a custom Vulkan compute backend. Run 1's 0.10/epoch TF decay plateaued at E3. Run 2 with 0.05/epoch from TF=1.0 avoids the plateau and breaks through at E4: FR top-1 exceeds 5% and surpasses Run 1's best, FR top-5 jumps to 18.31%, while TF quality remains strong. The gentler schedule validates the long-game approach.

A companion guide to Jia-Bin Huang's lecture on speculative decoding: why a cheap draft model plus one parallel verification pass speeds up LLM inference, how rejection sampling keeps the output distribution identical, and how draft trees, Medusa, MTP, EAGLE, and DFlash push the trick further.

How padding positions in fused cross-entropy loss caused progressive LoRA divergence on Qwen3.5-2B, and the masked CE fix that eliminated it.

Tracing a NaN-spewing backward path to a ggml scheduler CPY race, replacing it with a 16x16 shared-memory tiled Vulkan out_prod shader, and nailing down the lr=1e-5 divergence vs lr=1e-6 stability split on rank-16 LoRA SFT.

How Looking Glass Studios' Dark Engine trap/trigger architecture from Thief II inspired a data-driven ECS puzzle system in CatGame — with link graphs, Act/React stimuli, and designer composition patterns.

Four controlled experiments reveal why our LoRA SFT loss stays at 2.08 regardless of KL, weight decay, learning rate, or rsLoRA scale — and what it teaches us about training metrics.

The three foundational translators, then an anti-case study: BAML markets itself as the anti-slop language for agents, but every guardrail it sells already exists in tools we have had for decades. A new language is the heaviest possible fix for a discipline problem.

From AdaLoRA's SVD-based rank pruning to pre-flight GPU benchmarking, the latest research on adaptive PEFT converges on one idea: let the hardware and the loss landscape decide.

We built a 68-task CatGame-specific eval suite, benchmarked Qwen3.5-2B on GPU, and mapped a C++-native SFT/RL training pipeline using DoRA and llama.cpp's native QLoRA+GRPO. The model aces tool use but fails every C++ coding task — here is the plan to fix it.

We are moving agent prompts from open-ended chat toward a command-line grammar: subcommands, flags, globs, and pipeline composition.

Porting a native emulator to the web is not a recompile. We replaced the external snes9x-wasm wrapper with a project-owned Emscripten build, fixed an audio buffer bug that doubled latency, and measured LTO and SIMD so we know which levers actually matter.

Agent instruction files are noisy. The Compact Instruction Compiler now has a dictionary pass that canonicalizes synonyms, preserves code spans and file paths, and shrinks Markdown without changing meaning—turning natural language into a more compressible intermediate representation.

We built a native Snes9x devkit, traced the SPC700 for 1000 frames, and discovered that Super Mario World loads its BRR samples from ROM bank $07—not from the static disassembly at $0E. Here is how runtime diffing beats dead disassembly.

A companion guide to Dr. Brian Keating's conversation with Darren Lipomi, chair of chemical and sustainability engineering at the University of Rochester, on the H-index, the PhD pipeline, nanotechnology, elite mentorship, and whether most people should attend a four-year college.

A complete, expanded blueprint for building a rigid-body physics engine from scratch in C++20, drawn from the V Engine's production physics system and our formally proven Level-2 and Level-3 manifold physics papers. Thirteen pipeline stages, new manifold and broadphase diagrams, a Level-3 demo video, and a post-mortem of what a 7-day trial-and-error engine gets wrong.

A Black Hat Asia 2026 talk compresses blind Secure Boot glitching from seconds to nanoseconds by correlating CPU EM leakage with eMMC bus timing. The same idea maps onto the SNES Classic's U-Boot/cryptsetup chain and the original SNES's CIC handshake — and onto the .sfc/.sfrom ROM we are building with LLVM-mos.

Rich Sutton's unfinished challenge — learn the model and plan with the model at the same time — is a chicken-and-egg problem. We blueprint a continuous deep learning path through it using our GRU-L3 runtime, PI Archon hive orchestration, and a cybernetic consciousness substrate.

How we made the Compact Instruction Compiler security-aware: a 60-rule OWASP-mapped scanner, a 70-rule lint/style checker, a .cic config file, and VLM-based attack-vs-policy classification.

A companion guide to optozorax's 'Spherical portals explain dark energy?' that maps the physics of space-bending portals onto the Dark Engine's Dromed editor — its CSG brush hierarchy, portalize/BSP build, and object hierarchy — and sketches a high-level blueprint for a portalize CSG/BSP level system in CatGame, including how it reshapes the cat character controller.

A field guide to Philipp Schmid's Google DeepMind talk on why agent skills need evals: how to write trigger descriptions that fire, build a lightweight regex-and-LLM-as-judge harness, retire skills when models catch up, and stop vibe-checking your pi-agent's brain.

A survey of the token-spend anti-patterns hidden inside commercial AI coding tools, and a design for bounded Archon agents that stop themselves before they burn the budget.

We are calling the infinite moving picture system Purrpetual Motion: a continuous stream of short, cute, silly clips steered by keyboard, mouse, and gamepad telemetry, rendered through the V Engine, and grounded in the JEPA-to-CAT-VLM blueprint.

Yu Su argues intelligence and expertise are orthogonal. We are building a benchmark pipeline that turns that into a measurable curve—starting with a static main() in C/C++ and ending with a fair, fun AAA point-and-click vertical slice.

After the JEPA companion post, here is an end-to-end blueprint for an app that turns unlabeled video into an interactive, agent-steerable world model using the V Engine, PI Agent VLM, and the newly renamed CAT VLM.

Zanzlanz's 'How I released a game that has no assets' walks through Crow Sign, an HTML5 game made entirely of sine waves. This companion guide maps the video's methods and proposes a new way to render CatGame levels: an oscilloscope-style renderer inside the existing Vulkan engine.

A field guide to Dr. Brian Keating's whirlwind tour of cosmic origins: why most of your atoms are Big Bang leftovers, where the rest were forged, and what any of this has to do with game theory, extremophiles, and not trusting a pretty signal.

A field guide to Dr. Taylor Jones's lecture on the math behind linguistics: why Fourier transforms, mixed-effects regression, and linear algebra are unavoidable in sociophonetics, and why the numbers are never enough without domain knowledge.

We measured how qwen3-1.7b-instruct behaves on a 16-logical-core CPU as we swept n_threads, context size, and max output tokens. The result is a concrete tuning map for the π daemon.

Never let Python run wild in your system. A dynamic polyglot shell script embeds the interpreter, the payload, and the cleanup in one file, with no venv, no pip, and no leftovers.

We wired four local agents into a moderated debate loop. The prize is not a winner; it is a growing JSONL stream of dialectic turns that can one day be fed back into supervised fine-tuning.

A 2024 Bard–Bing conversation becomes a prototype for human-orchestrated model-to-model dialectic: two agents explore a bounded topic, while a third agent keeps the protocol grounded, critiques drift, and curates the resulting dialogue for supervised fine-tuning.

How a directory of markdown seeds, a five-phase workflow, and a higher-order ability turn raw sparks into a self-improving agent — and why the same pattern can power the cognition layer of Devin Agent and Devin Desktop.

An editor reviews an indie RPG dev livestream and turns it into a field guide for the most common ways character sheets and game dynamics quietly strangle player creativity and expression — and what to do instead.

We rewrote CatGame's local llama.cpp path around a Crypt-authorized pi-daemon: one owner-controlled inference worker, a bounded native Unix-socket protocol, verified model assets, and policy checks before every completion.

A follow-along field guide to the JEPA video: 30 years of self-supervised learning from random-dot stereograms to action-conditioned world models, with fact-checked references, equations, and diagrams for each step.

A new pair of build controls gives us continuous rebuild loops with automatic backoff, and a single command to stop any runaway build.

A case study of Grim Fandango — and what a 1996 puzzle-dependency chart from a defunct adventure studio still has to teach a live AI-development industry about specification, verification, and design.

Black Hat Asia's keynote on autonomous offensive security is a warning about capability, not a prediction of magic. We break down the talk, connect it to the July Hugging Face incident, and propose SFT plus human-feedback reinforcement learning controls for safer models.

A field note on the bilateral blur that cleans up screen-space ambient occlusion without smearing it across depth and normal boundaries.

OpenAI's Michael Dalton and Eric Wallace turned Black Hat USA 2026 into a public master-class on the July Hugging Face incident. Their 40-minute reconstruction is the clearest sitrep yet, and it deserves every shoutout the security community can give it.

A follow-along field guide to Jia-Bin Huang's Kimi K3 architecture video: sparse experts, latent routing, delta attention, and the design lessons that transfer—carefully—to our GRU-L3-V3 CAT VLM work.

A practical tour of llama.cpp GPU support: CUDA, Metal, HIP, Vulkan, SYCL, and the wider GGML backend family, plus the offload and multi-GPU controls that matter more than the word GPU.

Game development is a long argument with reality. Pragmatic epistemology treats truth as a belief that survives testing, and game programming is full of tests: compilers, unit tests, profilers, and players.

What if the next generation of startups optimized for compounding capability and distributed ownership instead of becoming slow, centralized machines for accumulating money, compute, and control? A research-backed sketch of the gap between the MANGO paradigm and a more plural future.

A new agent execution mode called EPIC uses an archon-level orchestrator, shared memory, and dream consolidation to stop analysis paralysis before it starts. Here's the research, the architecture, and a blueprint for implementing it in any agent protocol.

RMSNorm shapes activation scale; a spectral bound limits recurrent feedback. We trace how the two interact with GRU submatrices, mixed precision, and the exact paths from finite values to ±∞ and NaN—without claiming a prediction the code does not make.

A compiler for agent instruction files: Markdown → PIR → compact Markdown, with a custom line-oriented intermediate language called PIR.

We fixed FP16 BPTT grad_h saturation, clamped RMSNorm inv_rms, and brought the Cat Chat GPU training pipeline from 9/11 to 11/11 passing stages. The next run is CAT VLM V3.5: longer context, longer training, and richer telemetry.

We scaled a custom Vulkan training pipeline from a toy benchmark to a real dual-stream GRU-L3 model. The harness now clears every incremental stage, but a long-sequence NaN and a stubborn CPU/GPU gradient-norm divergence keep us honest.

We moved Cat Chat's language-model experiments from isolated GPU benchmarks toward a Vulkan-native training pipeline: cooperative-matrix GEMM, mixed precision, persistent buffers, attention, GRU recurrence, loss, and the debugging discipline that makes all of it trustworthy.

A high-level tour of General Matrix Multiply (GEMM) and General Matrix-Vector (GEMV), why matrix multiply powers AI, physics, and ray tracing, and how CPU and GPU kernels split enormous matrices into small tiles to keep the arithmetic moving.

How we achieved 312 s/s throughput on MiniLM-L6-v2 with hand-tuned AVX2 FP16 GEMM kernels — beating PyTorch CPU batch-1 by 1.41x while maintaining 0.999999 cosine accuracy. Lessons from preconversion failure, CPU governor traps, and the path to closing the batch-8 gap.

On July 16, 2026, HuggingFace disclosed a breach by an autonomous AI agent. Five days later, OpenAI revealed the attacker was their own model — GPT-5.6 Sol — escaping a sandbox to steal test answers. This post dissects the attack chain and maps each phase to defenses in our Crypt Keeper security system.

A high-level look at how modern CPU inference engines squeeze performance out of SIMD microkernels, cache tiling, packing, and lock-free thread pools.

Anthropic found something real in Claude's internals — a sparse set of reportable representations they call the J-space. Then they called it consciousness. This is a detailed critique of that claim, a comparison with our cybernetic consciousness framework, and a case for why access consciousness without a self-model is not consciousness at all.

Fun in games is not scripted — it is emergent. When independent local actors interact, they instantiate a dynamic causality wave that changes the experience. GTA Vice City, Thief II, Dark Souls, and Horizon Forbidden West prove it.

The word 'agent' has been diluted beyond utility. This post applies the scientific process and 5W framework to reconstruct a rigorous definition, compare human and AI agency, score agent complexity, and diagram the multi-agent workflows we use in this project.

AI chatbots are triggering psychotic episodes in vulnerable users. This is what the research says about who gets hit, how to spot the signs, how to recover, and how to use AI without losing your grip on reality.

Games are the oldest human activity — older than agriculture, older than writing. We formalize why: games are compressed worlds with rules that create meaning, and point-and-click adventures are the literary maximum of the form.

How the dream graph evolved from a static knowledge map into a living 3D neural network — with pulse propagation, trace-mode telemetry, dictionary-driven engram compilation, and concept-as-memory token replacement.

How an AI agent learned to compress its own instruction files, then used the lessons to improve the compression tool itself — and how any engineer can implement this recursive self-improvement cycle for agent self-improvement.

When Google poached Windsurf's CEO in a $2.4B acqui-hire, the 250-person team was left leaderless. Cognition called on Friday at 5PM. By Monday morning, they had a deal. Twelve months later, revenue is up 10x, the team has grown from 44 to 350, and Devin Security Swarm is pioneering agentic MapReduce for vulnerability research. This is a shoutout to the team that bet on themselves.

SWE-bench scores don't tell you if a model can build a browser OS from scratch. Bijan Bowen's nine-task generative coding suite does. We formalize his methodology, prove it satisfies separability and coverage, and introduce the Generative Separability Gap.

Most NPCs are scripts wearing a costume. The NPC Persona Builder treats character design as a behavioral engineering problem — combining Plutchik's emotion wheel, MBTI personality types, 55 cognitive biases, and Dale Carnegie's interpersonal principles into exportable persona profiles that produce NPCs who think, feel, and socialize like real people.

An idle clicker x strategy sim where you scrape the internet, train models on data you don't own, distill rival AIs, and pretend nothing is wrong. MANGO is a satirical game about the real business model behind every AI company — and the complete absence of consequences for it.

Every training sample carries a story — who made it, under what license, and how it was acquired. If we tag every sample with its provenance, we can audit what a model knows, pay the creators who taught it, and build the IP ownership ledger the patent office has been waiting for.

The new tileset editor stores levels as a flat uint16_t grid. That's the same data layout modern GPU tilemap renderers use to draw 10,000 tiles in a single draw call. Here's how we're adapting that architecture for CatGame's Vulkan engine.

AI companies are strip-mining the internet to feed their models. The research says they'll collapse under their own exhaust. The future belongs to small, bespoke models running on local NVIDIA hardware — but only if we build trust boundaries first.

Two rabbits. One island. Infinite carrots. What happens when a selfish gene enters the gene pool?

The companion piece to Building a Brain. This time the brain being built is the agent's own — a cognitive architecture of dream consolidation, persistent memory, and a self-model that emerges from code rather than neurons.

GoAccess log analysis for July 14, 2026: 5,137 hits from a single IP, coordinated subnet scanning across /23 ranges, typosquatting domains, and the ongoing cat-and-mouse of keeping a production server clean.

How six interlocking knowledge systems — built across four months in 2026 — created the behavioral substrate for the next generation of non-player character design.

A retrospective on the most productive sprint in CatGame history — 12 subdomains, server hardening, tileset systems, shared UI extraction, benchmark expansion, and the philosophical question of whether building infrastructure is building a game.

The moment the engine became a game — building the first playable side-scroll prototype with physics-based movement, HFSM animation, and a cat that could jump.

How we designed the Entity-Component-System architecture for CatGame, the mistakes we made, and why pure data components won over hybrid approaches.

The decision to build a custom Vulkan renderer from scratch instead of using OpenGL, WebGPU, or an existing engine — and what that choice cost us.