Google’s most advanced AI model, Gemini 3.5 Pro, remains unreleased as of July 18—nearly two months after the company pledged it would arrive “next month.” Third-party reports now point to a July 17 launch that also came and went without an official word, leaving developers with no confirmed availability, pricing, or performance specifications. For Windows-based teams building AI-driven tools, the message is clear: the only production-ready Gemini 3.5 model today is Flash, and waiting for Pro means betting on a product that still exists only in leaks and rumors.

The Missing Model

When Google unveiled the Gemini 3.5 family at I/O on May 19, the event was anchored by two models: Flash, a speed-optimized workhorse, and Pro, the flagship. Flash shipped immediately with a published benchmark slate, API endpoints, and a clear pricing page—$1.50 per million input tokens and $9 per million output tokens. Pro was nowhere to be found. CEO Sundar Pichai asked developers for patience: “Give us until next month to get it to you.” That month passed, and Pro stayed hidden.

Reuters reported on June 24 that the launch had moved from June to July so Google could incorporate early feedback. Then, a series of leaks from HackerNoon and Geeky Gadgets, citing unnamed internal sources, painted a more dramatic picture: Google had scrapped the original Pro model entirely and restarted pre-training from scratch. The reported culprits: failure in recursive tool-calling environments—the multi-step chains essential for agentic coding—and inability to generate structurally consistent SVG scene layouts. If true, these were not cosmetic bugs. They were foundational cracks that no amount of fine-tuning could fill.

As of July 18, the public Gemini API still lists only gemini-3.5-flash and the older gemini-3.1-pro-preview. No model card, no benchmark package, no confirmed context window. All circulating specs—the 2-million-token window, the Deep Think reasoning layer, the $15/$60 per-million-token pricing—come from third-party reports. Google has not confirmed any of them.

Why This Matters for Windows Developers

For a Windows shop integrating AI into code generation, document processing, or support automation, an unshipped model is a risk, not a resource. The gap between a promised capability and a deployable service can stall entire feature roadmaps.

Here is what the Pro delay means in practical terms:

  • No specification is final. The 2-million-token context window widely attributed to Pro would, if real, double Flash’s 1-million-token ceiling. But independent research, including the Chroma “Context Rot” study testing 18 frontier models, shows that every model’s reasoning degrades as context grows—often sharply before the advertised limit. Gemini 3.1 Pro already demonstrates this: its multi-range context recall falls to roughly 26% at 1 million tokens. Without an official model card and independent long-context benchmarks, the 2-million-token figure is a rumor, not a planning parameter.
  • Pricing is unknown. The speculated $15/$60 per-million-token rates would position Pro as a premium service, but until a pricing page appears, you cannot model total cost for enterprise workloads. Flash’s pricing is confirmed and economical for high-volume agent loops.
  • No public benchmark suite. Google shared official Flash results—76.2% on Terminal-Bench 2.1, 83.6% on MCP Atlas—allowing developers to evaluate it against their own needs. For Pro, there are no such numbers, leaving teams to rely on hearsay.

Windows environments add another layer of complexity. AI models often plug into PowerShell scripts, CI pipelines, endpoint management, and local toolchains. A model that changes response structure or fails under complex tool calls can break automations that were built around assumptions about its behavior. Without a shipping product, you cannot test these integrations.

The Long Wait: A Timeline of Silence

  • May 19, 2026: Google announces Gemini 3.5 Flash and Pro. Flash goes live; Pro is described as “coming soon,” with Pichai’s “next month” remark.
  • Late May – June: Early access to Pro reportedly begins on Vertex AI for select enterprise customers, but public documentation remains absent.
  • June 24: Reuters reports a delay to July, citing early-tester feedback.
  • July 9: GPT-5.6 Sol launches publicly. Same day, Grok 4.5 opens to all users. The competitive clock ticks louder.
  • July 13: TechTimes publishes an analysis pegging the rebuild theory, noting that no official confirmation exists for any Pro spec. The July 17 target is reported but unconfirmed.
  • July 17: The rumored launch date passes. No public announcement, no API update.
  • July 18: Gemini 3.5 Pro remains unshipped. The only clickable model on Google’s official page is Flash.

Throughout this window, Flash has been absorbing production traffic. Salesforce’s Agentforce integration, announced in June, uses Gemini 3.5 Flash for agentic tasks, demonstrating that the speed-optimized model can carry enterprise workflows. Flash’s benchmarks show it outperforming the older Gemini 3.1 Pro on several coding and reasoning tasks, making it a viable near-term choice.

What You Should Build On Now

If you are leading a Windows development team, your immediate decision is not “Flash vs. Pro.” It is whether Gemini 3.5 Flash fits the task you are trying to solve—and whether your architecture treats model selection as a configuration switch, not a permanent commitment.

1. Define Your Workloads Precisely

“AI coding” is not one thing. Separate your use cases:
- Code generation from natural language prompts
- Code review and bug detection
- Document summarization and retrieval-augmented generation (RAG)
- Agentic tasks that chain tool calls (running scripts, modifying files, querying databases)
- Support automation or internal chatbot responses

Each has different tolerance for latency, cost, and failure. Flash handles the first three well within its context range. For heavy multi-file refactoring or tasks requiring deep reasoning over very long documents, you may eventually need Pro—but that need should be proven by testing, not assumed.

2. Build a Realistic Evaluation Set

Curate a test corpus drawn from your team’s actual projects. Include:
- Typical successes (where the current manual approach works)
- Hard cases that trip up junior developers
- Known failure modes (edge cases, version-specific quirks)
- Tasks that should be rejected—requiring human judgment or corporate policy awareness

Evaluate Flash against this set now. Measure completion rate, required developer corrections, and time saved. Only then can you credibly assess whether Pro, when it arrives, offers a genuine improvement.

3. Isolate the Model Identifier

Hard-coding a model name into your application is a future maintenance headache. Instead:
- Store the model ID in an environment variable, configuration file, or service-side setting.
- Keep prompts, tool definitions, output parsing, and logging independent of the model.
- When Pro becomes available, swap the identifier and rerun your evaluation suite. Compare results directly.

This turns the Pro upgrade from a risky migration into a controlled experiment—one that can be rolled back easily if the new model introduces subtle regressions.

4. Measure Cost and Latency, Not Just Quality

A model that scores 5% higher on a benchmark but costs ten times more and adds 2 seconds of latency per call may be a net negative for a CI/CD pipeline that makes hundreds of calls per build. Flash’s published pricing and speed profile make these calculations straightforward. Pro’s will need to be verified against your actual throughput requirements once it ships.

5. Maintain Human Approval for Critical Actions

Even with Flash, any agent that can modify source code, create files, invoke administrative tools, or change configurations must include a human-in-the-loop checkpoint. This is especially true on Windows, where a script that reaches into the registry or modifies Group Policy can have far-reaching consequences. No model, whether Flash or Pro, should be trusted to execute such actions without review.

6. Establish a Promotion Gate for Pro

Decide in advance what metric would justify switching to Pro for a given workload. For instance:
- Code generation: task completion rate above 85% with fewer than 0.5 corrections per prompt.
- Agentic tasks: successful tool-call chains longer than 10 steps without human intervention.
- Document QA: recall accuracy over 90% on your internal knowledge base.

When Pro does launch, run it through the same suite and promote it only for workloads where it materially beats Flash. The “Pro” label alone does not win the promotion.

The Argument Against Waiting

Delaying an AI feature until the “best” model arrives can feel cautious, but it often exchanges one set of risks for another. By waiting for Pro, you lose weeks or months of real-world learning: how your team writes effective prompts, where the model is overconfident, which validation steps are essential. These lessons are independent of the underlying model and will apply regardless of whether you later switch to Pro.

Moreover, a model that exists only in rumors cannot be integrated into your licensing discussions, compliance reviews, or customer commitments. Product managers who promise Pro-powered capabilities to stakeholders are hanging those promises on a third-party leak. A safer approach: ship features on Flash with a measurable baseline, and position Pro as a candidate upgrade—not a guaranteed improvement.

What to Watch Next

The next meaningful update from Google will not be a tweet or a leak; it will be the appearance of gemini-3.5-pro in the public API directory, alongside a model card, pricing, and developer documentation. Until then, treat every reported spec—context window, reasoning layer, launch date—as unconfirmed.

Specifically, look for:
- Official context window specification, and whether it applies at standard API tiers.
- Independent long-context retrieval benchmarks, not just acceptance of long prompts. The MRCR v2-style tests that proven model degradation in Gemini 3.1 Pro will be critical.
- Pricing page to model total cost of ownership against Flash and competitors.

If the rebuild reports are accurate, Pro could represent a significant leap in reasoning depth. But a leap is only valuable if it lands. For Windows developers moving forward today, Gemini 3.5 Flash is the only ship in port. Board it, equip it with strong evaluation rigging, and prepare to test the flagship when it finally arrives.