Have You Ever Had Your AI Coding Assistant Just… Stop Working?

Imagine you're in the middle of an exciting coding session with your AI assistant. You ask it to edit a file, and instead of actually making the change, it just describes what it would do — like a chef who reads the recipe out loud but never picks up a knife. Frustrating, right?

This is exactly what many OpenClaw users experience when they connect Google's Gemini 2.5 Pro model to save on costs. OpenClaw — the popular open-source alternative to Claude Code — supports multiple AI models, and Gemini's lower pricing makes it an attractive option. But the integration comes with some significant bugs that every user should know about before diving in.

In this guide, we'll walk through the three most common bugs, explain why they happen in plain language, and share practical workarounds you can use today.

Why This Matters for You

The whole point of an AI coding agent like OpenClaw is tool calling — the ability to actually do things, not just talk about them. When you ask the AI to read a file, it reads the file. When you ask it to edit code, it edits the code. This is what separates an AI agent from a simple chatbot.

When Gemini's tool calling breaks down, your powerful AI agent essentially becomes a very expensive autocomplete. You still get text responses, but the AI can no longer interact with your codebase, run commands, or make changes. For beginners who chose Gemini to save money, this instability can end up costing more in wasted time than the savings on API fees.

Understanding these issues upfront helps you make informed decisions about which model to use and when.

Bug #1: Fake Tool Calls — The AI Pretends to Work

GitHub Issue #3344 — This is the most commonly reported problem.

Instead of actually executing tools, the Gemini model outputs text that looks like a tool call but isn't one. Users see messages like:

> [Historical context: a different model called tool "read" with arguments...]

This is like asking a delivery driver to deliver your package, and instead of actually delivering it, they just text you: "Package delivered" — while the package is still sitting in their van.

What's happening technically? Claude and Gemini handle tool calls differently under the hood. Claude uses XML-style tool_use blocks, while Gemini uses function_call format. When OpenClaw's message converter doesn't properly translate between these formats, Gemini ends up mimicking the text description of a tool call rather than triggering the actual mechanism.

How to spot it: Check the logs. If you see stopReason: "stop" instead of stopReason: "tool_use", the tool was never actually called. In the chat interface, you'll see raw technical text instead of actual file contents or code changes.

Bug #2: thoughtSignature Verification Failures

GitHub Issue #5001 — This one tends to hit you mid-conversation.

Gemini models (especially the Gemini 3 family) attach a thoughtSignature — essentially a digital stamp — to their tool call responses. Think of it like a wax seal on an old letter, proving it's authentic.

The problem? When OpenClaw sends the conversation history back to Gemini for the next turn, it includes this old signature. Gemini's API checks the signature, finds it can't be re-validated in this new context, and throws an error: "Thought signature is not valid."

What you'll experience:

• Your first tool call works perfectly
• The second or third tool call crashes with a cryptic error
• The entire conversation freezes
• You're forced to start a brand new session

Root cause: OpenClaw doesn't strip out the thoughtSignature field before sending conversation history back to the API. It's like trying to reuse a one-time password — it was valid once, but it can't be validated again.

Bug #3: Model Switching Causes Complete Stalls

GitHub Issue #13461 — This affects users who switch between models mid-conversation.

OpenClaw lets you start a conversation with one model and switch to another partway through. A common pattern is starting with Claude (for accuracy) and then switching to Gemini (to save money). But when you do this, the conversation history from your Claude session gets passed to Gemini — and Gemini doesn't know what to do with Claude's unsigned tool call records.

What happens:

1. You start a session with Claude and make several tool calls
2. You switch to Gemini mid-conversation
3. You ask Gemini to perform a task that requires tool calls
4. Gemini outputs the "Historical context" shim text instead of calling tools
5. The session effectively freezes

This is particularly severe with large contexts (200K+ tokens), where Gemini has more historical tool call records to get confused by.

The underlying issue: OpenClaw's Google adapter generates a descriptive text template when it encounters unsigned tool calls from a different model. Unfortunately, this template is so well-structured that Gemini treats it as something to copy rather than something to learn from.

The Long Conversation Problem

Beyond these three specific bugs, Gemini 2.5 Pro has a broader stability issue with extended conversations. Reports from the Google AI Developer Forum paint a concerning picture:

• Context overload: Once conversations exceed about 9-12K tokens, tool calling behavior becomes unpredictable
• Infinite loops: The model sometimes makes dozens of unnecessary tool calls for simple tasks, burning through API credits
• Empty responses: Sessions may terminate with no output at all, or return 500 server errors
• Preview vs. production paradox: In some cases, Google's preview (experimental) models actually perform better than the stable release — the opposite of what you'd expect

Some developers theorize that Google "distilled" the production model for cost efficiency, inadvertently degrading its tool-calling capabilities. Whatever the cause, the takeaway for users is clear: long, tool-heavy sessions with Gemini require extra caution.

Practical Workarounds You Can Use Today

The good news is that these issues are manageable with the right strategies:

Quick Fixes

1. Start fresh sessions frequently. When tool calls stop working, use the /new or /reset command. This clears the problematic conversation history and gives you a clean slate. Most tool call issues resolve immediately.

2. Don't mix models in one session. If you want to use Gemini, start with Gemini. If you start with Claude, stick with Claude for that session. Model switching mid-conversation is the #1 trigger for Bug #3.

3. Keep conversations short. Aim for 50-70 messages before starting a new session. This helps avoid the long-conversation instability issues and the thoughtSignature validation problems.

4. Stay updated. OpenClaw releases frequently include compatibility fixes for Gemini. Running the latest version can prevent many known issues.

Choosing the Right Model for the Job

• High-stakes code changes: Use Claude. Its tool calling is native and reliable.
• Simple Q&A and explanations: Gemini works great here — no tool calls needed, so the bugs don't apply.
• Balanced approach: Use Claude for critical tasks that need tool calling, and Gemini for conversational tasks. Just don't switch between them in the same session.

Getting Started With a More Stable Setup

If you're new to AI coding agents and want to avoid these headaches entirely, the simplest path is to stick with Claude models when using OpenClaw. Since OpenClaw was forked from Claude Code, compatibility with Claude is naturally the strongest.

For those who find the installation and configuration process daunting, cloud-based solutions like EasyClaw offer a simpler entry point. EasyClaw provides a pre-configured OpenClaw environment in the cloud — no installation, no model compatibility troubleshooting, and you can be up and running in minutes. It's especially helpful for beginners who want to focus on using AI agents rather than debugging provider integrations.

Wrapping Up

Connecting Gemini 2.5 Pro to OpenClaw can save you money on API costs, but it currently comes with real trade-offs in stability — particularly around tool calling. The three key bugs we covered (fake tool calls in Issue #3344, thoughtSignature failures in Issue #5001, and model-switch stalls in Issue #13461) are well-documented and actively discussed in the community. By understanding these issues and applying the workarounds we've shared, you can make informed decisions about when Gemini is the right choice and when you're better off with Claude. The ecosystem is improving rapidly, so keep your OpenClaw installation updated and don't hesitate to start with a stable setup while the Gemini integration matures.