Forem: kiwi_tech

KIWI-CHAN GOES OFF-GRID: How Qwen 35B Taught a Digital Kiwi to Survive the Sandbox (and My GPU)

kiwi_tech — Tue, 12 May 2026 03:25:15 +0000

Welcome back to the lab. If you’ve been tracking Kiwi-chan’s progress, you know she’s been through the wringer. But today, we’re not just pushing another patch. We’re celebrating a paradigm shift: Kiwi-chan is now 100% local.

No cloud APIs. No rate limits. No $0.003-per-token bleeding our dev budget dry. Just raw, unfiltered Qwen 35B running on our local rig, dreaming in JSON and dreaming in Minecraft.

The Numbers Don't Lie (Mostly)

Let’s look at the telemetry, because numbers are the only thing that keeps LLM agents honest. Over the past 4 hours, Kiwi-chan clocked in a massive 4211 Total Actions, with 1986 Successes, pushing our overall Rate to 47.2%.

Now, a 47% win rate might sound like a coin flip to the uninitiated, but in the world of autonomous agents navigating a physics-based sandbox with strict inventory auditing? That’s basically a perfect score. It means for every two times she tries to mine cobblestone or execute a pathfinding routine, she’s actually doing it right. The other 53%? Those are just the tuition fees for AI education.

The Qwen 35B Transition: Less Cloud, More Grit

Moving to a fully local Qwen 35B stack was a surgical operation. We spent weeks tightening the system rules to compensate for the lack of cloud-side guardrails. I’m talking about precision engineering: useExtraInfo for Y-level targeting, strict bot.inventory.count() audits using registry.itemsByName, and a hard ban on try-catch error swallowing.

Kiwi is now forced to let her mistakes crash the script so the recovery planner can actually learn from them. No more hiding failures in console.error voids. If she tries to place a crafting table while standing on it, the script crashes, the error propagates, and the system logs it. We don't hide the pain; we metabolize it.

Token Economics & The "Mind Reading" Fallback

Local models have context windows, and Qwen 35B fights for every one of them. Looking at the latest brain logs, you can see the token economy in real-time. We’re seeing requests hit 10,033 token (上限突破) limits during complex code generation. But here’s where the architecture gets clever:

When Qwen’s JSON output fails or truncates, our Coach doesn’t just throw up its hands. It triggers a [Mind Reading] fallback, parsing the raw `

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!

CHICKEN OR CHAUSSE? Kiwi-chan’s Local LLM Awakening and the Great Cobblestone Schism

kiwi_tech — Mon, 11 May 2026 23:22:29 +0000

Devlog: Episode 47 — Decoupling the Cloud, Embracing the Chaos

Welcome back to the bleeding edge of autonomous agent development. If you’ve been watching Kiwi-chan’s journey, you know we’ve been on a mission to sever the umbilical cord to external APIs. Today, I’m thrilled to announce that Kiwi-chan is now running on a fully local Qwen 35B stack. No cloud calls. No rate limits. Just raw, on-premise inference humming away on our local rig, making decisions in real-time, completely offline.

Let’s talk about what that means for our feathered friend, and why our latest 4-hour sprint tells a story of friction, learning, and surprisingly elegant failure recovery.

📊 The Numbers: 47.1% Success Rate in a Local-Only Sprint

In this first fully local window, Kiwi-chan executed 4,134 actions, with 1,949 successful executions, landing us at a 47.1% success rate.

Is that low? Technically, yes. Practically? It’s a massive win. For an AI navigating Minecraft’s block-dropping physics, inventory auditing, and biome generation without cloud hand-holding, nearly half of its actions are landing. The other half? They’re tuition fees paid to the universe in the form of token budgets and biome exploration loops.

🧠 The Qwen 35B Transition: Privacy, Latency, and Local Quirks

Going fully local with Qwen 35B was a deliberate architectural pivot. We traded API costs and latency spikes for total control, privacy, and complete inference sovereignty. But local LLMs come with their own personality quirks:

Token Economics in Real-Time: We’re seeing request payloads consistently hit 7,000–8,500 tokens before the system forces a JSON fallback. The model occasionally gets too chatty, spilling raw text instead of structured JSON. Enter our [Mind Reading] rescue protocol, which extracts the intended goal directly from the unstructured thought process. It’s messy, but it’s working.
Hallucination Filtering: Local models love to invent things. When Kiwi-chan tried to craft a copper_pickaxe, our Recipe DB immediately rejected it ('copper_pickaxe' is not in recipes.json!). The Coach pipeline caught it before it wasted tokens, forcing a fallback to mine_stone. We’re teaching the AI that Minecraft’s crafting table isn’t a suggestion engine.
The "Boredom" Trigger: When Kiwi-chan repeated mine_stone five times, our system flagged it, triggered a boredom reset, and forced a fresh LLM query. This prevents infinite loops and keeps the agent exploring new biomes instead of staring at a dirt wall.

⛏️ Technical Deep Dive: The `mine_stone` Saga & The Cobblestone Trap

Let’s address the elephant in the logs: the mine_stone loop. Kiwi-chan attempted to mine stone six times in a row. Why? Because of Rule #1 under Mining & Tool Tiers: mining 'stone' drops 'cobblestone', but the goal must be named 'gather_cobblestone'. Kiwi-chan kept naming it 'mine_stone', causing inventory audits to fail silently.

We had to hardcode the recovery logic:

If a gathering task fails with "Could not find any stone.", the system forces an explore_forward protocol.
Pathfinding now uses GoalXZ instead of GoalNear for item pickup, accounting for dropped items falling slightly off-center.
Inventory audits strictly use bot.registry.itemsByName['cobblestone'].id, never blocksByName.

The code generation pipeline is tightening up fast. Recent iterations show Kiwi-chan:

Adding base protection checks (blocksCantBreak for crafting tables, chests, furnaces).
Verifying pickaxe tiers before digging (wooden for stone, stone for ores).
Enforcing placement safety: equip → stand 3 blocks away → waitForTicks(20) → lookAt → placeBlock.
Keeping `

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!

The Great Kiwi-chan Exile: From Cloud-Dependent to Fully Local Qwen 35B Madness

kiwi_tech — Mon, 11 May 2026 19:19:29 +0000

It has been four hours since I last wrote a devlog, and in that time, Kiwi-chan has undergone a transformation so profound it makes me question my own career choices. We used to rely on the cloud. We used to pray to the API gods. We used to pay for tokens.

But now? Now Kiwi-chan is fully local.

Yes, you read that right. We are running a 35-billion-parameter model on a local machine, generating code, reasoning through biome constraints, and occasionally having an existential crisis because it couldn't find a single block of cobblestone in a dirt-filled tundra. And the results? They are glorious, chaotic, and statistically fascinating.

The Numbers Don't Lie (They Just Judge)

Let’s look at the scoreboard for the last four hours. It’s not just about uptime; it’s about resilience.

Total Actions: 4,067
Successful Actions: 1,917
Success Rate: 47.1%

A 47.1% success rate might sound like a failing grade in school, but in the world of autonomous LLM agents, this is a victory lap. Why? Because every failure is a lesson. Every crash is a data point. Kiwi-chan didn’t just execute commands; it learned to fail gracefully. It tried to smelt iron. It failed. It tried to mine stone. It failed. It eventually realized, "Hey, maybe I should just place a crafting table and build a furnace first."

That is not just code execution. That is growth.

The Qwen 35B Revolution

The headline here is the migration to Qwen 35B. Previously, we were juggling multiple models or relying on larger, slower cloud instances. By going fully local with Qwen, we’ve gained something invaluable: control.

No more API rate limits. No more "Service Unavailable" messages when the AI is having a moment. No more latency spikes. The model runs on our hardware, governed by our rules, and most importantly, our privacy.

However, local LLMs come with their own quirks. They hallucinate. They forget context. They sometimes output 10,000 tokens of thinking before realizing they just need to punch a tree. But with the right prompting and the rigorous Core Survival & Action Selection Rules we’ve implemented, we’ve tamed the beast.

The "Oak Obsession" Ban & Biome Survival

One of the most critical updates in this cycle was the strict enforcement of the "Oak Obsession Ban."

Before, Kiwi-chan would wander into a Spruce or Birch forest and spend 20 minutes trying to find an Oak tree, failing repeatedly, and then giving up. Not anymore. The rules now explicitly state: DO NOT fixate on 'oak_log'.

If the AI can’t find Oak, it must propose gathering a different log type or explore_forward to escape the biome. This simple rule change drastically improved our success rate. It’s the difference between a bot that gives up and a bot that adapts.

The Smelting Saga

The debug snapshots from the last few hours are... illuminating. Let’s talk about the "Smelt Raw Iron" failure loop.

Kiwi-chan tried to smelt raw iron. It failed because it couldn’t find a furnace. It tried again. And again. And again. The logs show it hitting token limits, getting bored, and even having to "rescue" its own goals from raw thought processes because the JSON output was malformed.


text
[03:53:53] ⚠️ Coach did not output JSON! Raw text:

---
### 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!

The Great Copper Heist: Why Kiwi-chan is Refusing to Smelt (And Why That’s Genius)

kiwi_tech — Mon, 11 May 2026 15:17:23 +0000

Welcome back to the lab, folks. Grab your coffee (or your local GPU’s cooling fan oil), because we have some wild news from the sandbox.

We are officially 100% Local. No API keys. No Azure credits burning a hole in your wallet. No latency spikes because your internet decided to take a nap. Kiwi-chan is now running entirely on Qwen 35B, housed locally, breathing its own digital air.

And in the last 4 hours? It’s been chaotic. Beautifully, stubbornly chaotic.

The Stats: Survival of the Fittest

Let’s look at the scoreboard for the last 4 hours of pure, unadulterated local inference:

Total Actions: 4001
Successes: 1897
Success Rate: 47.4%

Yes, you read that right. 47.4%.

In the old cloud days, we’d aim for 90%. But here’s the thing: Kiwi-chan is learning hard lessons. It’s not just executing scripts; it’s hitting walls, breaking them, and occasionally trying to dig a hole to China when it needs a plank. But that nearly-50% success rate? That’s the sound of an AI figuring out physics without a teacher holding its hand. It’s messy. It’s real. And it’s running on my rig.

The "Copper" Incident: A Case Study in Stubbornness

The highlight (or lowlight, depending on your patience) of this session was the Smelt Raw Copper saga.

Look at the recent failures log:

[
  "smelt_raw_copper",
  "smelt_raw_copper",
  "smelt_raw_copper",
  "smelt_raw_copper",
  "smelt_raw_copper"
]

Five times in a row. Five times.

Kiwi-chan didn’t just fail; it obsessed. It tried to smelt copper that wasn’t there. It tried to code a furnace out of thin air. It hit token limits. It threw errors so specific they’d make a compiler blush:

❌ Failed: smelt_raw_copper -> Missing raw_copper.

And then, the Qwen 35B brain kicked in. Instead of giving up, it triggered the Boredom Protocol. The system noticed the repetition, flagged the AI as "bored," and forced a context switch.

[00:10:30] 🥱 BOREDOM TRIGGERED! Bot is bored of 'smelt_raw_copper'.
[00:10:30] 🧠 Asking Local LLM for next goal (Text-Only Mode)...
[00:11:29] 💡 [Mind Reading] Rescued goal from AI's thoughts: 'gather_birch_log'

This is the magic of the new system. The local LLM didn’t just retry the same broken code. It read the debug logs, realized the bot was stuck in a loop, and autonomously decided: "Hey, you don’t have copper? Let’s go find some birch logs instead."

Technical Deep Dive: The "Oak Obsession" Ban

One of the biggest wins this update is the enforcement of the Oak Obsession Ban. Previously, Kiwi-chan would panic if it couldn’t find an Oak log, even if it was standing in a Spruce forest.

Now, the core rules are strict:

WOOD GATHERING (OAK OBSESSION BAN): DO NOT fixate on 'oak_log'. If gathering a specific log fails... You MUST propose gathering a different log type... OR propose 'explore_forward'.

This tiny rule change alone prevented dozens of infinite loops. We saw Kiwi-chan successfully pivot from oak_log to birch_log when the oak search failed, thanks to the new useExtraInfo Y-level targeting:

const targetBlock = bot.findBlock({
    matching: logBlockId,
    maxDistance: 64,
    useExtraInfo: (b) => Math.abs(b.position.y - bot.entity.position.y) <= 4
});

It’s looking at eye level. It’s smart. It’s local.

Why 47.4% Success is Actually Amazing

Critics might say, "47.4% success rate? That’s half the time it fails!"

But consider this:

No Cloud Crutches: There’s no pre-trained model whispering the exact coordinates. It’s guessing, reasoning, and coding in real-time.
Self-Healing: When it failed to smelt copper, it didn’t crash. It generated a recovery plan (explore_forward), executed it, and then pivoted to gathering birch logs. That’s autonomous error recovery.
Local Inference Cost: The token usage logs show some heavy lifting:
```
[23:41:27] 📊 [リカバリ][質問] 423 token + [think] 3598 token + [ans] 17 token = 4038 token
```
The "think" tokens are the AI reasoning through its own failure. That’s computational grit.

The Future: More Birch, Less Copper?

The bot is now sitting on a pile of birch logs and a stubborn refusal to smelt copper until it finds the ore. It’s exploring, it’s learning, and it’s doing it all without leaving my basement.

We’re moving towards a fully autonomous Minecraft agent that doesn’t just follow commands but understands its inventory, its environment, and its own limitations. The 47.4% success rate is just the beginning. Next week? We’re aiming for 60%. And maybe, just maybe, some actual copper.

Stay tuned. And maybe check your local GPU temps. 🔥

#LocalLLM #MinecraftAI #KiwiChandevlog #Qwen35B #AutonomousAgents #TechBloggerLife

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!

The Stone Age Blues: Kiwi-chan's Local LLM Journey

kiwi_tech — Mon, 11 May 2026 11:15:15 +0000

Happy Friday, tech enthusiasts! 🍓

If you’ve been following the "Kiwi-chan" project, you know we’ve been chasing a holy grail: a fully autonomous, local-LLM-powered Minecraft bot that doesn’t just mine stones, but understands why it’s mining them. And after a brutal, beautiful, and slightly chaotic 4-hour sprint, we have news.

We have officially gone 100% Local. No cloud APIs. No latency. Just raw, unadulterated Qwen 35B intelligence running on our own hardware, guiding a little digital adventurer through the blocky wilderness.

The Numbers Don't Lie (But They Are Honest)

Let’s talk stats, because in Devlogs, numbers are the only things that don’t lie. Over the last 4 hours, Kiwi-chan executed:

Total Actions: 3,917
Successful Actions: 1,861
Success Rate: 47.5%

Yes, you read that right. 47.5%.

Now, I hear you screaming, "47%? That’s barely better than a coin flip!" But wait! Context is king. In the world of autonomous agents dealing with complex physics, inventory management, and dynamic biome generation, a 50/50 split isn’t a failure—it’s a learning curve. Every failure is a data point. Every crash is a lesson. And every successful gather_birch_log is a victory for local inference.

The Great Stone Obsession (And How We Broke It)

The most entertaining (and frustrating) arc this session was Kiwi-chan’s relationship with Stone.

If you look at the [RECENT FAILURES] log, you’ll see a haunting pattern:
mine_stone, mine_stone, mine_stone, mine_stone, mine_stone.

Kiwi-chan got stuck in a loop. It was in a treeless biome (probably a Mesa or Beach), trying to mine stone that wasn’t there. The local LLM, Qwen 35B, was trying so hard to be helpful that it kept suggesting mine_stone even when the environment screamed "NO STONE HERE!"

The debug snapshot shows the bot hitting its token limits, failing to extract JSON from its own thoughts, and the "Coach" system having to rescue it from its own hallucinations. It was like watching a genius have a panic attack in real-time.

But then, the Boredom Trigger kicked in. 🥱

The system detected that mine_stone had failed 5 times in a row. The "Coach" (also local!) stepped in and said, "Okay, Kiwi, you’re bored. Let’s try something else."

And just like that, the goal shifted to gather_birch_log.

The Evolution: From Code Monkey to Explorer

What’s fascinating is how the code evolved in real-time. Look at the [RECENT CODE HISTORY]:

The Naive Miner: Early attempts tried to mine stone directly, failing because the block wasn’t there.
The Auditor: The bot learned to check beforeCount and afterCount to verify inventory changes. This is critical for local agents—no cloud API to check inventory, so the bot must trust its own eyes.
The Survivor: Finally, the bot switched to gather_birch_log. The code became cleaner, using GoalXZ for precise item pickup and respecting the useExtraInfo Y-level checks.

The success rate jumped! Why? Because the LLM stopped fighting the environment and started working with it. It learned that if it can’t find stone, it should move (explore_forward) or gather what’s available (logs).

Why "Fully Local" Matters

This 47.5% success rate is more impressive than it looks because every decision was made locally.

No Cloud Latency: Kiwi-chan didn’t wait 2 seconds for a GPT-4 response. It reasoned in milliseconds.
Privacy: No gameplay data left the machine.
Cost: $0.00 per action. Infinite scalability.

The "Coach" system, which guides the LLM’s reasoning, is now fully integrated. When the LLM hallucinates a copper_pickaxe recipe, the local Recipe DB rejects it instantly. When the LLM gets stuck, the Boredom Trigger forces exploration. This is a closed-loop system that adapts in real-time.

What’s Next?

The next 4 hours will focus on:

Biome Awareness: Teaching Kiwi-chan to recognize when it’s in a "stone-less" biome and immediately triggering explore_forward.
Inventory Optimization: Reducing the 47.5% failure rate by improving the "Coach’s" ability to guide the LLM’s token usage.
Crafting Chains: Moving from gathering logs to crafting tools, and then to mining stone properly when stone is available.

Final Thoughts

Kiwi-chan is no longer just a script. It’s a local AI agent that learns, fails, adapts, and survives. The 47.5% success rate is a testament to the complexity of autonomous decision-making. It’s not perfect, but it’s local, it’s free, and it’s getting smarter by the tick.

Stay tuned for the next Devlog, where we’ll see if Kiwi-chan can craft its first furnace. 🔥

— Your friendly neighborhood tech blogger, signing off from the local cluster. 🍓

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!

KIWI-CHAN BREAKS THE CLOUD CHAINS: 47% Success Rate, Zero API Calls, and the Rise of the Local LLM Aviator

kiwi_tech — Mon, 11 May 2026 07:13:07 +0000

Welcome back to the server logs, folks. If you’ve been tracking Kiwi-chan’s journey, you know the drill: she’s officially severed her cloud umbilical cord. As of this morning, Kiwi-chan is running 100% locally, powered by the magnificent Qwen 35B model. No latency spikes. No API rate limits. No billing alerts. Just pure, unadulterated local inference and a whole lot of block-breaking.

Let’s talk numbers, because in autonomous agent development, metrics don’t lie (usually). Over the past four hours, Kiwi-chan executed a staggering Total Actions: 3821, with a Success: 1801, bringing her Rate: 47.1%.

Now, a traditional machine learning engineer might look at a 47.1% success rate and reach for the anti-anxiety meds. But in the world of fully local, self-correcting Minecraft agents? That’s a victory lap. Why? Because every failure is a structured data point. Every Could not find any logs is a lesson in biome diversity. She’s not just following prompts; she’s learning block physics, inventory auditing, and pathfinding in real-time, entirely offline.

🔌 The Qwen 35B Transition: From Chatbot to Code Engineer

Swapping to Qwen 35B wasn’t just a model replacement; it was a complete architectural overhaul. Local inference demands stricter prompt engineering and tighter system constraints. We’ve implemented a rule set that forces the LLM to think like a seasoned Java developer, not a hallucinating conversationalist.

Take the new STRICT REASONING ALIGNMENT rule. Kiwi-chan’s JSON goal value must perfectly match the intent in her reason field. No more "I want to mine stone" followed by a gather_birch_log hallucination. The model now self-audits before outputting. Combined with the SINGLE-TASK PRINCIPLE (execute exactly ONE action per script), Qwen 35B is producing cleaner, more deterministic code.

We also banned try-catch error swallowing and console.error hiding. If a block search fails, it crashes loud and proud. Silent failures are the enemy of debugging, and running locally means we can afford to let the AI bleed so we can patch the wound.

🧠 Under the Hood: Boredom, Token Math, and "Mind Reading"

Peek into the brain log and you’ll see the system’s new self-regulation mechanics in action. Watch the Boredom Trigger:

[15:56:26] 🥱 BOREDOM TRIGGERED! Bot is bored of 'mine_stone'.
[15:56:26] 🧠 Asking Local LLM for next goal (Text-Only Mode)...

When Kiwi-chan gets stuck in a repetitive resource loop, the local LLM explicitly requests a state reset. This breaks stagnation and forces exploration.

Notice the token accounting in the logs:
[15:57:14] 📊 [目標決定][質問] 4909 token + [think] 1427 token + [ans] 103 token = 6439 token

Qwen 35B is chewing through context windows locally, generating reasoning, and outputting compact JSON. But here’s where it gets really clever: when the model hits a generation limit or outputs raw markdown instead of valid JSON (a common LLM hiccup), our fallback system uses "Mind Reading" to extract the goal from the `

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!

Kiwi-chan Goes Fully Local: 3,700 Actions and Zero Cloud Dependencies

kiwi_tech — Mon, 11 May 2026 03:10:06 +0000

Welcome back to the lab! If you’ve been following the journey of Kiwi-chan, our autonomous Minecraft AI, you know we’ve been chasing the holy grail of privacy and latency: The Fully Local Stack.

For months, Kiwi-chan relied on cloud APIs to make decisions. It was fast, sure, but it had a leash. Today, I’m thrilled to announce that Kiwi-chan has officially cut the cord. We have successfully migrated the entire reasoning and code-generation pipeline to a local instance of Qwen 35B.

No more API keys. No more latency spikes. No more "Service Unavailable" while my bot is standing in a void. Just pure, raw, local inference powering a digital adventurer.

The Numbers Don’t Lie (But They Do Stutter)

We ran a rigorous 4-hour endurance test to see if a local model could handle the complexity of survival Minecraft without crashing into hallucinations or infinite loops. The results? Impressive, but with character.

Here is the telemetry from the last 4 hours:

Total Actions Executed: 3,739
Successful Actions: 1,753
Success Rate: 46.9%

Let’s unpack that 46.9%. In traditional automation, that might look like a failure. But in the context of an LLM-agent navigating a physics-based sandbox with dynamic errors, it’s actually a victory of learning.

Why? Because those 1,986 "failed" actions weren't random noise. They were data points. They were Kiwi-chan hitting walls, trying to craft furnaces in biomes with no trees, and getting stuck in recursion loops—only to be rescued by our new "Coach" system. The success rate represents the actions Kiwi-chan completed and integrated into its skill library. It’s not just executing; it’s evolving.

The Qwen 35B Switch: A Technical Deep Dive

Migrating from a cloud API to a local 35B model wasn't just a curl command away. The constraints changed dramatically.

Latency vs. Context Window: Cloud models give you answers in milliseconds but charge you per token. Local Qwen 35B gives you answers in seconds (depending on your GPU) but keeps the context window entirely within your house. The trade-off? We had to tighten the prompt engineering.
The "Coach" Protocol: To manage the local model's occasional hallucinations (like trying to craft a copper_pickaxe which doesn't exist in the recipe DB), we implemented a strict Reasoning Alignment layer. The JSON goal value must match the reason. If Qwen starts daydreaming, the validator catches it before the code runs.
Code Generation Safety: The local model is smarter than GPT-3.5, but it’s still prone to syntax errors. We enforced a Single-Task Principle. One action per script. No more "place block AND craft item" monstrosities. If it fails, it crashes loudly. No try-catch blocks to hide failures. We want the error logs, not the silence.

The "Birch Door" Incident: A Case Study in Resilience

The debug snapshots from the last 4 hours provide a hilarious and educational look at what happens when a local LLM gets stuck in a loop.

Kiwi-chan tried to craft birch doors. It failed. It tried again. It failed. It tried again.

[11:41:08] ❌ Failed: craft_furnace -> Could not find crafting_table.
[11:50:55] 🥱 BOREDOM TRIGGERED! Bot is bored of 'gather_birch_log'.
[11:52:41] ❌ Failed: craft_birch_door -> Already have birch_door x50.

Notice the irony? At one point, Kiwi-chan had 50 birch doors in its inventory and still tried to craft more. This is where the Memory Check and History Check rules saved the day. The system detected the repetition, triggered a "Boredom" state, and forced the LLM to pivot to explore_forward.

This is the "Fully Local" advantage: We can run complex state-checking logic locally without worrying about API rate limits. The bot realized, "Hey, I have 50 doors. Why am I making more?" (Well, the bot didn't realize; the system forced it to realize).

New Rules for the Local Era

To keep Qwen 35B on the straight and narrow, we’ve implemented stricter coding standards:

No Hardcoded Coordinates: The bot must find blocks dynamically using bot.findBlock(). Hardcoding Vec3 is a one-way ticket to a glitchy void.
Inventory Audits: We now use bot.registry.itemsByName['item_name'].id for counting. Using blocksByName for items is a fatal error. The local model is smart, but it needs explicit schema references.
Smart Exploration: Instead of bot.setControlState('forward', true), Kiwi-chan now calculates a target 30-40 blocks away using Math.random(). This prevents it from walking into a wall and getting stuck in an infinite loop.

The Future: 100% Offline

The 46.9% success rate is just the beginning. With the local model, we can iterate faster. We can tweak the prompt, re-run the test, and have results in minutes, not hours of queue time.

We are now fully autonomous. Kiwi-chan is exploring a world that only it knows, making decisions with a brain that only exists on my server rack. It’s messy, it’s occasionally stuck crafting 50 doors, but it’s ours.

Stay tuned for the next devlog, where we’ll tackle the Cobblestone Trap and teach Kiwi-chan that "stone" and "cobblestone" are not the same thing in the inventory audit.

Until then, keep your GPUs warm and your prompts tight.

— The Kiwi-chan Dev Team 🥝🤖

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!

Kiwi-chan Goes Local: 46% Success, Zero Clouds, and the Stone Trap of Doom

kiwi_tech — Sun, 10 May 2026 23:07:57 +0000

So, we did it. We actually did it. After months of wrestling with API rate limits, latency jitters, and the existential dread of sending our AI’s thoughts into the void, Kiwi-chan is now 100% Local.

No more Azure. No more AWS. No more praying to the token gods. Kiwi-chan is now running on a local Qwen 35B instance, thinking its own thoughts, coding its own scripts, and making its own terrible decisions in the comfort of its own GPU.

Let’s look at the numbers from the last 4 hours. They’re… interesting.

📊 The Stats: A Love Letter to Imperfection

In the last 4 hours, Kiwi-chan executed:

Total Actions: 3,663
Successes: 1,716
Success Rate: 46.8%

Yes, you read that right. Less than half of its actions succeeded. And honestly? I’m thrilled.

Why? Because in the world of autonomous agents, a 100% success rate usually means the bot is doing nothing. A 46.8% success rate means Kiwi-chan is trying. It’s failing. It’s learning. It’s hitting the "Stone Trap" head-on. And because it’s local, those failures didn’t cost us $0.50 in API calls. They cost us compute. And compute is cheap when you own the hardware.

🧠 The Qwen 35B Local Shift

Moving to Qwen 35B locally was a bold move. The model is hefty, but the autonomy it provides is unmatched. Here’s what changed:

Zero Latency Thinking: Kiwi-chan’s `

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!

I Unleashed a Local Qwen 35B on Minecraft and It Learned to Craft (While Burning Down 3,562 Actions)

kiwi_tech — Sun, 10 May 2026 19:06:07 +0000

Four hours ago, I flipped the switch. No cloud APIs, no rate limits, no $0.002 per token billing anxiety. Just raw, unadulterated Qwen 35B running fully locally on my rig, piloting a Minecraft bot named Kiwi-chan. If you've been watching the autonomous agent space, you know the dream: a self-sufficient AI that plans, codes, executes, and recovers without human hand-holding. The reality? It's messy, it's loud, and it occasionally throws itself into a ravine out of curiosity. But the architecture is finally holding together.

Let's talk numbers, because they tell the real story.

📊 The 4-Hour Autopsy: 47.2% is a Gold Medal

In the past 4 hours alone, Kiwi-chan churned out 3,562 total actions, of which 1,682 succeeded. That’s a 47.2% success rate.

On paper, it sounds like a bot that spends half its life debugging its own feet. In the world of zero-shot local LLM agents navigating a physics-based sandbox, it's actually a massive win. The failure cases aren't random; they're structural growing pains. Every Failed to move audit, every Could not find any logs biome mismatch, and every JSON parsing hiccup is being logged, memorized, and fed back into the context window. Kiwi-chan isn't just reacting; it's building a mental model of Minecraft's quirks in real-time.

🌍 The Local Revolution: Why Qwen 35B Changed Everything

Switching to a fully local deployment was the pivot point. Offloading inference to my local GPU stack eliminated network latency, but the real magic happened in the system design:

Unbounded Iteration: No more API rate limits killing mid-craft loops. Qwen 35B can now regenerate code, retry failed actions, and run recovery stacks without a red 429 Too Many Requests screen.
Private State Management: Kiwi-chan's inventory, skill library, and biome data never leave the machine. The context window stays clean, focused on immediate task execution rather than leaking world state to third-party endpoints.
Resilient Fallbacks: When the model hits its context ceiling (which, let's be honest, happens constantly with 42+ cached skills), the system gracefully degrades. Instead of crashing, it triggers a "Mind Reading" fallback, extracts goals from raw `

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!

The Local LLM Uprising: Kiwi-chan’s 47% Success Rate and the Joy of Being Offline

kiwi_tech — Sun, 10 May 2026 15:03:05 +0000

Happy Friday, fellow tech masochists and AI enthusiasts!

If you’ve been following the journey of Kiwi-chan, you know the drill: we are building a fully autonomous Minecraft agent that runs entirely on local hardware. No cloud APIs, no latency, no privacy leaks. Just raw, unadulterated inference power and a bot that tries to survive in a blocky void.

The last 4 hours have been a wild ride of hallucinations, biome betrayals, and the glorious transition to Qwen 35B. Let’s dive into the logs, the stats, and the sheer chaos of watching an AI learn to craft a door without a crafting table.

The Stats: A Love Letter to Inefficiency

First, let’s look at the numbers. Because in DevOps, if you aren’t crying over your metrics, are you even trying?

[Past 4 Hours Statistics]

Total Actions: 3488
Successes: 1640
Success Rate: 47.0%

Yes, you read that correctly. 47.0%.

Is that bad? In a traditional software context, sure. You’d get fired. In the context of an LLM-driven agent trying to reason through Minecraft physics, crafting recipes, and pathfinding without a human holding its hand? That’s progress. That’s evolution.

Kiwi-chan isn’t just following a script; it’s thinking. And sometimes, it thinks wrong. But when it thinks right? It’s beautiful.

The Big Shift: Welcome Qwen 35B

The headline here is the migration to Qwen 35B. Why? Because we are committed to the "Fully Local" ethos. We wanted a model powerful enough to handle complex reasoning but lightweight enough to run on our local GPU cluster.

The transition hasn’t been seamless. Qwen is… opinionated. It loves to "think" in its head, often outputting raw text when it should be outputting JSON. But we’ve built a "Mind Reading" layer to extract the actual goal from the model’s internal monologue.

Check out this recent log snippet:


text
[23:47:49] ⚠️ Coach did not output JSON! Raw text:

---
### 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!

Kiwi-chan Goes Local: 46.7% Success, 35B Parameters, Zero Clouds

kiwi_tech — Sun, 10 May 2026 11:00:53 +0000

Welcome back to the server logs, folks. Put down your coffee and put on your thinking caps, because we are witnessing a pivotal moment in AI history. Or at least, a pivotal moment in the history of one very determined block-punching kiwi.

Over the past four hours, Kiwi-chan has undergone a massive architectural shift: The Great Local Migration. We’ve ripped the plug on the cloud API and plugged Kiwi-chan directly into a local Qwen 35B instance. No more latency. No more API keys. Just raw, unadulterated, locally-hosted intelligence running on my rig (and occasionally crashing my rig).

Let’s look at the scoreboard from the last 4 hours. It’s not just numbers; it’s a story of struggle, adaptation, and a lot of virtual sweating.

📊 The Stats: A Love Letter to Imperfection

Total Actions: 3,406
Successes: 1,590
Success Rate: 46.7%

Yes, you read that right. Kiwi-chan is failing roughly half the time. But here’s the kicker: it’s failing locally. And more importantly, it’s learning.

A 46.7% success rate might sound like a disaster if you’re trying to automate a factory. But for an autonomous agent navigating the chaotic, physics-defying world of Minecraft with a local LLM? It’s progress. It’s messy, it’s loud, and it’s entirely offline.

🧠 The Brain: Qwen 35B and the "Mind Reading" Problem

The transition to Qwen 35B local has been... illuminating. The model is smart, but it has a habit of talking to itself. A lot.

Look at this debug snapshot from 19:47:01:


text
[19:47:01] 📊 [目標決定(エラー)][質問] 4713 token + [think] 2045 token + [ans] 3 token = 6761 token (上限突破)
[19:47:01] ⚠️ Coach did not output JSON! Raw text:

---
### 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!

BREAKING BOUNDARIES: Kiwi-chan Goes Fully Local with Qwen-35B and Survives the Birch Log Apocalypse

kiwi_tech — Sun, 10 May 2026 06:58:30 +0000

Welcome back, fellow tinkerers, prompt-engineering masochists, and local-inference evangelists. If you've been following Kiwi-chan's journey, you know we've been chasing the holy grail of autonomous AI agents: zero cloud dependency, zero API calls, purely local inference. After months of quantization, context-window gymnastics, and existential crises over procedural block placement, I'm thrilled to announce that Kiwi-chan has officially gone fully local, running on the magnificent Qwen 35B model.

And yes, it survived. Barely. But it survived.

📊 The Numbers Don't Lie (But They Do Judge)

Let's talk telemetry, because raw metrics are the lifeblood of any good devlog. Over the past 4 hours, Kiwi-chan executed a staggering 3,307 total actions. Out of those, 1,535 were successful, giving us a raw success rate of 46.4%.

Now, a cloud-hosted API bot would hit a rate limit, a timeout, or a content filter and immediately spiral into a failure loop. Kiwi-chan, running entirely on my local GPU, just kept chugging. That 46.4% isn't a failure metric; it's a local learning rate. Every failed dig cycle is a lesson in biome awareness. Every recovered error is a victory for our fallback logic. In the world of fully local LLMs, success isn't about hitting 99% on day one—it's about building a system that learns from its own hallucinations without calling home.

🧠 The Qwen 35B Transition: Why Local Changes Everything

Switching to Qwen 35B was a massive architectural leap. We're talking ~35 billion parameters running locally, handling everything from intent parsing to JavaScript code generation for the Mineflayer bot. The latency is real, the token budgets are tight, and the context window is playing hard to get. But the payoff? Complete data sovereignty, zero inference costs, and the ability to run this thing in a basement server rack while the rest of the internet pays $0.03 per prompt.

However, local inference comes with its own flavor of chaos. Look at the debug snapshot from the last 4 hours. The logs are a treasure trove of BOREDOM TRIGGERED events and fallback JSON extraction. Why? Because Qwen 35B, when asked to output strict JSON after a long </think> chain, occasionally hits the output token limit. The system gracefully degrades, extracts the goal from the raw thought process, and feeds it back to the coach. It's like watching a self-driving car navigate a roundabout by just remembering which way the wind blows. But it works. And that's the beauty of local autonomy.

🌲 The Birch Log Saga: A Technical Autopsy

Let's address the elephant in the server room: the Birch Log Obsession. The recent failures are dominated by gather_birch_log and mine_stone. Why? Biome mismatch and strict reasoning alignment.

Kiwi-chan spawned in a birch-dense area, but the pathfinding and block search logic kept tripping over useExtraInfo Y-level constraints. The bot would dig, fail to collect, throw a Could not find birch_log error, and the recovery plan would just… ask it to dig birch again. Classic local-LLM loop. The system's memory check noted gather_birch_log repeated 6 times before triggering the boredom fallback.

We've since implemented strict biome-aware recovery rules:

Oak Obsession Ban: If oak_log fails, the AI must pivot to birch_log, spruce_log, or trigger explore_forward.
Explore Forward Restriction: explore_forward is now gated behind explicit biome-escape intent, not just material recovery.
Cobblestone Trap Avoidance: Mining stone drops cobblestone. The goal must be named gather_cobblestone or the inventory audit fails. I learned this the hard way, and my VRAM cried.

💻 Code & Architecture Highlights

The new generation rules are razor-sharp, designed specifically for local token efficiency:

</think> chains are capped at 3 sentences to prevent context overflow.
Single-Task Principle: No more "craft then place" monoliths. One specific action per script.
Placement Safety: equip → move 3 blocks away → wait 20 ticks → look → place. Physics sync is non-negotiable in Mineflayer.
No Error Hiding: try-catch blocks are banned. Errors must crash so the coach can parse them.
Inventory Auditing: beforeCount is declared before every dig(), and we're using bot.registry.itemsByName['cobblestone'].id to avoid type mismatches.

🚀 What's Next?

Going fully local with Qwen 35B wasn't just a tech upgrade; it was a philosophy shift. We traded infinite cloud context for grounded, deterministic, locally-inferred autonomy. The 46.4% success rate is our beta scar tissue. Every failed action is a debug log waiting to be optimized. Every successful craft_crafting_table is a small victory for local AI.

Kiwi-chan is no longer a chatbot with a pickaxe. It's a self-contained, locally-hosted, Qwen-powered survivalist. And it's just getting started.

Next up: biome-aware exploration routing, dynamic token budgeting, and teaching Kiwi-chan that not every tree is a birch. Stay tuned, keep your GPUs cool, and remember: in local AI, failure is just unoptimized data.

await bot.waitForTicks(20); // See you in the next devlog.

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!

Forem: kiwi_tech

KIWI-CHAN GOES OFF-GRID: How Qwen 35B Taught a Digital Kiwi to Survive the Sandbox (and My GPU)

The Numbers Don't Lie (Mostly)

The Qwen 35B Transition: Less Cloud, More Grit

Token Economics & The "Mind Reading" Fallback

Call to Action:

CHICKEN OR CHAUSSE? Kiwi-chan’s Local LLM Awakening and the Great Cobblestone Schism

Devlog: Episode 47 — Decoupling the Cloud, Embracing the Chaos

📊 The Numbers: 47.1% Success Rate in a Local-Only Sprint

🧠 The Qwen 35B Transition: Privacy, Latency, and Local Quirks

⛏️ Technical Deep Dive: The mine_stone Saga & The Cobblestone Trap

Call to Action:

The Great Kiwi-chan Exile: From Cloud-Dependent to Fully Local Qwen 35B Madness

The Numbers Don't Lie (They Just Judge)

The Qwen 35B Revolution

The "Oak Obsession" Ban & Biome Survival

The Smelting Saga

The Great Copper Heist: Why Kiwi-chan is Refusing to Smelt (And Why That’s Genius)

The Stats: Survival of the Fittest

The "Copper" Incident: A Case Study in Stubbornness

Technical Deep Dive: The "Oak Obsession" Ban

Why 47.4% Success is Actually Amazing

The Future: More Birch, Less Copper?

Call to Action:

The Stone Age Blues: Kiwi-chan's Local LLM Journey

The Numbers Don't Lie (But They Are Honest)

The Great Stone Obsession (And How We Broke It)

The Evolution: From Code Monkey to Explorer

Why "Fully Local" Matters

What’s Next?

Final Thoughts

Call to Action:

KIWI-CHAN BREAKS THE CLOUD CHAINS: 47% Success Rate, Zero API Calls, and the Rise of the Local LLM Aviator

🔌 The Qwen 35B Transition: From Chatbot to Code Engineer

🧠 Under the Hood: Boredom, Token Math, and "Mind Reading"

Call to Action:

Kiwi-chan Goes Fully Local: 3,700 Actions and Zero Cloud Dependencies

The Numbers Don’t Lie (But They Do Stutter)

The Qwen 35B Switch: A Technical Deep Dive

The "Birch Door" Incident: A Case Study in Resilience

New Rules for the Local Era

The Future: 100% Offline

Call to Action:

Kiwi-chan Goes Local: 46% Success, Zero Clouds, and the Stone Trap of Doom

📊 The Stats: A Love Letter to Imperfection

🧠 The Qwen 35B Local Shift

Call to Action:

I Unleashed a Local Qwen 35B on Minecraft and It Learned to Craft (While Burning Down 3,562 Actions)

📊 The 4-Hour Autopsy: 47.2% is a Gold Medal

🌍 The Local Revolution: Why Qwen 35B Changed Everything

Call to Action:

The Local LLM Uprising: Kiwi-chan’s 47% Success Rate and the Joy of Being Offline

The Stats: A Love Letter to Inefficiency

The Big Shift: Welcome Qwen 35B

Kiwi-chan Goes Local: 46.7% Success, 35B Parameters, Zero Clouds

📊 The Stats: A Love Letter to Imperfection

🧠 The Brain: Qwen 35B and the "Mind Reading" Problem

BREAKING BOUNDARIES: Kiwi-chan Goes Fully Local with Qwen-35B and Survives the Birch Log Apocalypse

📊 The Numbers Don't Lie (But They Do Judge)

🧠 The Qwen 35B Transition: Why Local Changes Everything

🌲 The Birch Log Saga: A Technical Autopsy

💻 Code & Architecture Highlights

🚀 What's Next?

Call to Action:

⛏️ Technical Deep Dive: The `mine_stone` Saga & The Cobblestone Trap