Hohoo’s workbench

Make it tangible. Then understand it.

Make abstract questions inspectable. Change a condition, observe what happens and return to code with evidence.

Learning by doing

Take a question apart.

Local execution · No API key

Teaching interactions, not research results. Change a condition, inspect the evidence, then return to code. Inputs stay local; leaving or switching resets the exercise.

9 interactive questions

Embodied AIWhat grows from simple rules?

Plant cells, rewind their evolution, and take a frame with you.

AI applicationsWhy did retry duplicate a message?

Inject a timeout and compare two history commit strategies.

LLMDelete a message. Is the fact gone?

Inspect where evidence survives in a recorded conversation.

RAGDoes retrieval guarantee a good answer?

Choose evidence and change ranking to inspect the answer's basis.

LLMWhat goes when context is full?

Balance history, references and output space within a limited budget.

Embodied AICan local vision still find the goal?

Place obstacles and compare full-map and local-vision navigation.

AI applicationsWhose instructions should we trust?

Separate untrusted sources from application instructions.

AI applicationsCan your program read this JSON?

Inspect field paths, strings, arrays and malformed structure.

AI applicationsDoes confidence grant permission?

Vary confidence, permission and risk to inspect a decision rule.

From interaction to implementation

Projects with real code

  1. PROJECT / 001

    Hohoo’s AI Lab

    A personal knowledge site for public learning, research signals and practice.

    Live
  2. PROJECT / 002

    Java LLM Practice

    Reproducible Java conversation, retry and persistence boundaries, alongside attention, cache-cost and quantization-error experiments.

    Building
  3. PROJECT / 003

    Hohoo Embodied Experiments

    Two MuJoCo teaching scenes—pick-and-place and planar force control—record contracts, tuning, clearance and delayed-feedback outcomes, including failures.

    Experiment
All projects →

Experiments and research

  1. LAB / 001

    Retrieval quality comparison

    Use fixed questions and documents; compare retrieval hits, citations and answer correctness with and without retrieval.

    Running
  2. LAB / 002

    Tool failure recovery experiment

    Use controlled read-only tools; inject timeouts and empty results, then record completion and call counts.

    Running
  3. LAB / 004

    VL01 / Pickup target offsets

    What changes when pickup x targets shift by 25 / 50 mm with the controller fixed?

    Completed
  4. LAB / 005

    L1 / Context position: an interrupted trial

    Can the model retrieve the same fact at different positions?

    INCONCLUSIVE
  5. LAB / 006

    E2 / Confirm the grasp before transfer

    Use sustained height and bilateral contact to decide whether transfer should proceed.

    Completed
  6. LAB / 007

    E3 / Contact monitoring during transfer

    Separate missed loss, false cancellation and confirmation delay using forced opening and one empty contact report.

    Completed
  7. LAB / 008

    E4 / Observation freshness and sampling

    Separate delivery from fresh evidence and test a fixed count at different sampling periods.

    Completed
  8. LAB / 009

    E5 / Revalidating recovery

    Does delivery recovery authorize the old action? Compare fresh evidence, replay and remaining-path planning.

    Completed
  9. LAB / 010

    TypeScript / Output boundary comparison

    Which invalid inputs escape assertions and object validation?

    Completed
  10. LAB / 011

    A1 / The chat-history commit boundary

    How should committed history survive failures, truncation and candidate trimming?

    Completed
  11. LAB / 012

    E6 / Recovery gate and path ablation

    Separate revalidation from replanning: which differences concern evidence and which concern the resumed target?

    Completed
  12. LAB / 013

    E7 / Grasp contracts during lowering

    What changes when transfer monitoring extends into lowering?

    Completed
  13. LAB / 014

    A2 / Concurrent history commits

    Reproduce reversed response order with real Java threads, then enforce versioned commits, complete turns and bounded receipts.

    Completed
  14. LAB / 015

    L2–L4 / Attention and cache mechanics

    From a two-row hand calculation to a two-layer numeric experiment: causal masks, softmax and future-information leakage.

    Completed
  15. LAB / 016

    E8 / Post-alarm exit actions

    Fifteen fixed-scene rollouts compare hold, open and open-then-retreat after identical alarms.

    Completed
  16. LAB / 017

    E9 / Post-release completion verification

    Apply single-capture and sustained-window checks to five actual trajectories, including forged observations and post-completion disturbance.

    Completed
  17. LAB / 018

    E10 / Bounded recovery and cooldown

    Twelve rollouts compare unlimited recovery, a two-resume cap and a 400 ms cooldown, separating bounded behavior from task completion.

    Completed
  18. LAB / 019

    L5 / Prefix-cache invalidation

    Three seeds and six conditions compare unchecked and keyed prefix reuse; numerical equality does not establish permission to share across scopes.

    Completed
  19. LAB / 020

    E11 / Completion and current validity

    Seven MuJoCo rollouts and a paired replay separate historical completion from current validity, including false alarms and expiry boundaries.

    Completed
  20. LAB / 021

    Java LLM practice (8): should an interrupted stream enter conversation history?

    22 loopback HTTP cases separate incremental preview from committing history, testing UTF-8, SSE framing, cancellation and abnormal endings.

    Completed
  21. LAB / 022

    LLM mechanics (5): after editing history, can we recompute only the changed suffix?

    27 fixed conditions and 81 raw arrays test longest-prefix cropping, continuation positions, sliding-window fallback and scope isolation.

    Completed
  22. LAB / 023

    Embodied AI practice (12): what should the gripper do after recovery is exhausted?

    12 MuJoCo rollouts and synchronized three-view replay compare hold, open and open-retreat, separating terminal decisions from physical consequences.

    Completed
  23. LAB / 024

    Java LLM practice (9): why can a cancelled answer overwrite a new conversation?

    18 controlled thread schedules test request ownership for streaming previews, completion and errors, with cancellation and bounded deduplication.

    Completed
  24. LAB / 025

    LLM mechanics (6): why can a larger prefix cache still get zero hits?

    324 requests across cold-start traces and 648 arrays test byte-bounded prefix checkpoints, working sets, isolation and LRU eviction.

    Completed
  25. LAB / 026

    Embodied AI practice (13): where should recovery resume after interrupted lowering?

    18 MuJoCo rollouts and synchronized replay connect phase contracts to recovery budgets, separating false holds, physical placement and controller abort.

    Completed
  26. LAB / 027

    Java LLM practice (10): why is the reader still running after cancellation?

    30 local HTTP connections separate conversation invalidation, reader exit and server work, comparing Future interruption with socket closure.

    Completed
  27. LAB / 028

    LLM mechanics (7): why is caching slower even when it saves computation?

    4,860 measured queries compare three admission policies, connecting byte budgets, working sets, computation and local elapsed time.

    Completed
  28. LAB / 029

    Embodied AI practice (14): does landing in the bin mean the task is complete?

    Eight MuJoCo trajectories, three passive readouts and recorded-state replay separate historical placement, current evidence and qualified completion.

    Completed
  29. LAB / 030

    Java history and request windows: can a trimmed fact return?

    Follow narrowing, commit, restart and expansion to separate durable conversation history from one request context.

    Completed
  30. LAB / 031

    Java retries: three timeouts are not one deadline

    Seven local HTTP conditions separate retryability, Retry-After, attempt limits and elapsed-time budgets.

    Completed
  31. LAB / 032

    Durable Java turns: what survives a process crash?

    Checksummed append records, 142 truncated prefixes and three halted JVMs distinguish local recovery from remote exactly-once execution.

    Completed
  32. LAB / 033

    Profiling KV reuse: saved work versus added overhead

    Profile 909 queries across signatures, lookup, copying and continuation, including the remaining slowdown.

    Completed
  33. LAB / 034

    Tiled attention: preserving results without a full score matrix

    Derive online softmax from a failing block-average baseline and separate smaller temporaries from measured speed.

    Completed
  34. LAB / 035

    KV quantization: how many bytes, and at what error?

    Compare tensor and row-wise int8 quantization, including scale bytes and attention error under outliers.

    Completed
  35. LAB / 036

    A second MuJoCo scene: why does the actuator overshoot?

    Compare mass and PD damping in a planar force-controlled actuator, separating target crossing from stable completion.

    Completed
  36. LAB / 037

    MuJoCo obstacle clearance: a point path is not a body path

    Six contact trajectories compare direct, edge and clearance paths while separating geometry from controller tracking.

    Completed
  37. LAB / 038

    Delayed MuJoCo feedback: can an old observation predict now?

    Twenty-four paired traces compare delay, position noise and constant-velocity prediction, retaining incomplete recoveries.

    Completed
  38. LAB / 039

    Java idempotent retries: no reply does not mean no effect

    Seven loopback HTTP fault cases explain idempotency keys, concurrent admission, payload conflicts and process-crash gaps.

    Completed
  39. LAB / 040

    KV quantization axes: why Key and Value need separate reasoning

    162 archived INT8 comparisons examine tensor, token and K-channel/V-token scales, including cases where the hybrid loses.

    Completed
  40. LAB / 041

    MuJoCo velocity estimation: smoother signals can mean worse control

    54 actual simulation rollouts compare finite differences, EMA and an oracle reference across position noise and observation delay.

    Completed
  41. LAB / 042

    Durable delivery and history recovery

    17 scenarios and 193 child-process records. An unkeyed receiver duplicates the effect after a delivery crash; all three history recovery boundaries retain whole turns.

    Completed
  42. LAB / 043

    Packed KV, residual windows and block cost

    144 comparisons and 810 timings. Recent float32 windows help recent-focused attention more; block decoding reduces work arrays but is slower on this CPU run.

    Completed
  43. LAB / 044

    Planar control tuning, observation loss and transfer

    153 episodes and 306000 physics steps. The selected controller passes 7/18 holdouts; zero force coasts, and mass scaling lowers mean error without passing the velocity contract.

    Completed
View experiment proposals

These are questions to investigate, not established results.

All experiments →