Kiwi-chan Goes Fully Local: 2,362 Actions, One 35B Parameter Brain, and the Great Birch Plank Rebellion

📜 Devlog: Episode 07 — The Local Inference Sprint

Welcome back to the digital tundra, where I’m documenting the gloriously chaotic evolution of Kiwi-chan, our fully autonomous local-LLM Minecraft agent. If you’ve been watching the repo, you know we’ve been chasing a specific architectural holy grail: a bot that doesn’t phone it home to some rate-limited cloud API. Well, grab your netherite pickaxes, because the migration is complete. We’re fully local now. No API keys. No latency spikes. Just raw, on-device inference running Qwen 35B, and a bot that’s currently having an existential crisis over a missing crafting table.

📊 The Four-Hour Autopsy

Let’s talk numbers before we talk philosophy. Over the past four hours, Kiwi-chan has logged a staggering 2,362 total actions. Out of those, 1,040 succeeded, yielding a 44.0% success rate.

Now, before you clutch your pearls and call it a regression, let me translate that for the AI-native crowd: in autonomous agent development, a 44% success rate isn’t a bug. It’s a calibration curve with a pulse. Every failed explore_forward, every extraction retry, and every “BOREDOM TRIGGERED” log is just Kiwi-chan’s neural pathways tuning itself to Minecraft’s notoriously hostile physics engine. We’re not chasing 99% accuracy; we’re chasing procedural competence. And right now? It’s learning faster than my GPU fans can spin.

🧠 The Qwen 35B Transition

Switching the cognitive core to Qwen 35B was a massive architectural leap. We’re talking a 35-billion-parameter local model handling real-time reasoning, JSON goal alignment, and JavaScript code generation entirely on my rig. The pipeline is now elegantly brutal:

1. LLM outputs a reason and a lowercase goal
2. System validates JSON structure and rule alignment
3. Code generator compiles the action
4. NO ERROR HIDING: If it crashes, it crashes. We don’t try-catch our way out of pathfinding hell; we let the exception bubble up, log it, and feed it back into the recovery stack.

The result? A system that actually thinks before it moves. When the bot encountered a biome with no oak trees, it didn’t loop into oblivion. It followed the OAK OBSESSION BAN rule, proposed birch_log or explore_forward, and gracefully adapted. That’s not script behavior. That’s local reasoning.

🔄 The Great explore_forward Loop

If you peek at the recent brain logs, you’ll notice a recurring theme: Kiwi-chan got stuck in a severe infrastructure loop. It kept trying to place_chest and place_crafting_table while apparently standing 23 blocks away from a perfectly functional one. The system correctly diagnosed it as a state/pathfinding corruption issue and invoked the Infinite Curiosity directive.

So it pivoted to explore_forward. But here’s the catch: Minecraft’s pathfinder is not a fan of randomly generated targets 30-40 blocks away. The logs show a beautiful cascade of Took too long to decide path to goal! and Failed to move. errors. Kiwi-chan even hit the BOREDOM TRIGGER five times in a row. A bot getting existential dread over repetitive movement tasks? I’ve never seen anything so profoundly human.

But notice what happened next: the system didn’t freeze. It generated a recovery plan, audited the beforeCount before every bot.dig(), enforced tool tiers (no iron_ore mining without a stone_pickaxe), and correctly handled the “cobblestone trap” by aligning the goal to gather_cobblestone. This is what 44% success looks like under pressure: messy, iterative, and relentlessly adaptive.

🛠️ Rule Enforcement & Smart Mechanics

Despite the chaos, the coding standards are holding the line. The snapshot data shows Kiwi-chan has now memorized 37 skills. Each one is audited, versioned, and ready to deploy. The system strictly enforces:

• NO HARDCODED COORDINATES: Everything is dynamically resolved via bot.findBlock({ matching: bot.registry.blocksByName['block_name'].id, maxDistance: 32 })
• 2x2 INVENTORY CRAFTING: Planks, sticks, and torches are crafted with null as the table parameter. No unnecessary block placement required.
• ITEM PICKUP PATHING: Dropped items are targeted with GoalXZ(targetBlock.position.x + 0.5, targetBlock.position.z + 0.5) to account for physics drift.
• INVENTORY COUNT FATAL ERROR PREVENTION: Always uses bot.registry.itemsByName['item_name'].id. No more blocksByName mix-ups.

The code generation pipeline now automatically classifies failures as [Skip Fix] terrain/environment issue vs actual code bugs. That’s not just error handling; that’s contextual debugging.

🔮 What’s Next

We’re fully local. The Qwen 35B core is humming. Kiwi-chan is arguing with pathfinders, getting bored of walking, and extracting JavaScript like it’s trying to pull a diamond out of bedrock. But it’s ours. No cloud. No subscriptions. Just a 35B parameter brain, a Minecraft world, and the relentless pursuit of better planks.

Next devlog, we’re tuning the pathfinder’s heuristic weights, implementing a dynamic biome scanner, and teaching the agent to stop fleeing from its own crafting table. Until then, keep your torches lit, your reason/goal JSONs aligned, and your try-catch blocks banned.

Stay local, stay curious.

🪵 Kiwi-chan v0.4.2 | Qwen 35B Local Core | 2,362 Actions Logged | 44.0% Success | 37 Skills Memorized

---

Call to Action:

This is a passion project, and it's running on a frankly terrifying "Frankenstein" rig of GPUs. Every little bit helps!

🛡️ Join the inner circle on Patreon for monthly support and exclusive updates: https://www.patreon.com/15923261/join
☕ Tip me a coffee on Ko-fi for a one-time boost: https://ko-fi.com/kiwitech

All contributions directly help upgrade my melting GPU rig to an RTX 3060! 🥝✨ Let's get Kiwi-chan out of the debugging woods and into a proper Minecraft world!