Agentic systems · State machines · Game dev

Complex systems, made formal.

Independently authored work in agentic systems, state machines, and game development.

Flagship: Witloom · live protocol graph
Systems: Agentic · machines · game dev
Source: Private · proof shown here

Selected work · proof in sequence

Meet the system. Then see it work.

Three systems lead directly into their evidence; two editor tools close the sequence as concise craft notes. Public proof, private source.

Java orchestration runtime · pre-1.0

Witloom

Agents return bounded signals; a declared protocol owns every legal transition, repair loop, and durable receipt.

Protocol machines
Agent orchestration
Replay + telemetry

Enter the live graph

Project 01 / Java orchestration runtime

A model session is a bad place to own the workflow.

Long-running work, repair policy, and audit trails die when context drops. Witloom is the control plane: you declare a YAML or JSON harness as a validated state machine; agents return bounded signals; the machine alone chooses the next legal state. Commands and effect receipts persist so the process survives the session.

Follow one branching run Public project / Java 21 / pre-1.0

What: Embeddable core + CLI
Input: Validated YAML or JSON harness
Controls: States, routes, retries, waits, consensus
Produces: Durable state, receipts, replay, telemetry

01 / 07 · Queue

Sanitize the request.

Normalize input before planning; invalid work terminates safely.

intake --accepted→ plan

02 / 07 · Plan

Plan inside the protocol.

The master decomposes work, but only a declared signal can choose the next route.

plan --ready→ implement

03 / 07 · Implement

Assign one bounded activity.

Provider, prompt, timeout, and retry policy belong here; record the result before moving on.

implement --success→ test

04 / 07 · Branch

Failure takes the repair edge.

Tests return failed; the machine loops to implementation and preserves both attempts.

test --failed→ implement

05 / 07 · Auto-review

Review returns a signal.

Approval advances. Changes requested take the second declared repair loop.

autoreview --approved→ consensus

06 / 07 · Consensus

Critical release needs quorum.

Bounded votes resolve to quorum or veto; no model can jump to completion.

consensus --quorum→ done

07 / 07 · Terminal

Persist the terminal outcome.

State, receipts, and telemetry remain inspectable after the agent context is gone.

done / success

Protocol graph

Harness YAML

protocols:
  release-harness:
    version: "1"
    initial: intake
    states:
      intake:
        label: "Sanitize one queued work item"
        activity:
          binding: queue-curator
          timeout: 5m
          maxAttempts: 2
          redrive: idempotent
        transitions:
          - id: intake-ready
            on: "accepted"
            to: plan
          - id: intake-blocked
            on: "invalid"
            to: blocked
      plan:
        label: "Decompose and assign bounded work"
        activity:
          binding: master-agent
          timeout: 10m
          maxAttempts: 2
          redrive: never
        transitions:
          - id: plan-ready
            on: "ready"
            to: implement
          - id: plan-needs-context
            on: "needs_context"
            to: intake
      implement:
        label: "Implement one bounded work item"
        activity:
          binding: implementer
          timeout: 30m
          maxAttempts: 2
          redrive: never
        transitions:
          - id: implementation-ready
            on: "success"
            to: test
      test:
        label: "Run deterministic tests"
        activity:
          binding: tester
          timeout: 10m
          maxAttempts: 2
          redrive: idempotent
        transitions:
          - id: tests-passed
            on: "passed"
            to: autoreview
          - id: tests-repair
            on: "failed"
            to: implement
      autoreview:
        label: "Run independent bounded review"
        activity:
          binding: autoreviewer
          timeout: 10m
          maxAttempts: 2
          redrive: idempotent
        transitions:
          - id: review-approved
            on: "approved"
            to: consensus
          - id: review-repair
            on: "changes_requested"
            to: implement
      consensus:
        label: "Resolve the critical release decision"
        activity:
          binding: release-consensus
          timeout: 10m
          maxAttempts: 1
          redrive: idempotent
        transitions:
          - id: consensus-reached
            on: "quorum"
            to: done
          - id: consensus-replan
            on: "veto"
            to: plan
      done:
        label: "Release completed"
        terminal:
          outcome: success
      blocked:
        label: "Work item rejected safely"
        terminal:
          outcome: rejected

Current state: intake
Selected transition: intake-ready
Next state: plan
Validated: 8 / 8 can terminate

One immutable protocol + one live execution cursor. YAML and graph round-trip through vendor-neutral models; React Flow and ELK are replaceable presentation adapters.

TypeScript library

Tiger Layout

A pure layout evaluator: one immutable geometry snapshot, projected into DOM, Three.js, interaction, and motion adapters.

Layout core
Motion signals
Renderer-neutral

Enter the renderer story

How this page is built · Tiger Layout

Secondary system proof. Layout is a pure function of explicit inputs; this scroll story and the lab below consume the same contracts. Not a package-registry product yet.

Input / 01

One rectangle.

Start with an explicit viewport. Size, content, and constraints drive geometry; scroll remains an explicit presentation input.

viewport + content + constraints

Resolve / 02

Layout becomes data.

Flow, padding, clipping, and transforms resolve into one immutable snapshot with stable IDs.

same inputs → same snapshot

Signal / 03

Scroll is just another input.

The page does not chase the scrollbar. It samples progress and deterministically presents the matching state.

enter → hold → exit

Project / 04

One snapshot. Any renderer.

DOM and Three.js consume the same geometry. A custom renderer can join without redefining layout.

DOM / Three.js / custom

Interactive layout demo

Change inputs; layout recomputes.

Drag the floating token, reorder the cards, or resize the split. Pointer and keyboard input become the same immutable event trace; target changes recompute layout while presentation-only frames stay cheap.

Flow composition row → column / gap 12

Motion patch presentation only / geometry stable

Replay trace same events / same snapshots

Keyboard: focus a card, token, or divider; press Space, use arrow keys, then Enter to commit or Esc to cancel.

More systems · current boundaries

Engine depth. Editor restraint.

Planevox carries an architecture proof; the two editor projects stay intentionally compact until their public contracts mature.

Java / Vulkan engine

Planevox

In-development microvoxel engine for huge distances: near-first streaming and packed parallel-plane Vulkan pages—not only mesh rebuilds.

ProblemFine detail and long range compete for budget.

MechanismBounded streaming + plane-page residency.

EvidenceArchitecture case study; playable remains private.

Large-world LOD
Voxel streaming
Vulkan rendering

Active development

Neovim tool

control-center.nvim

A dependency-free control surface for project actions and workspace state inside the editor.

Craft proof Declarative sections; configuration owns values and effects.

Private prototype

Neovim theme

red-noir.nvim

True black ground, restrained gray, and red reserved for scarce semantic signal.

Craft proof Stable palette tokens preserve hierarchy across syntax, diagnostics, and focus.

Private prototype