Google DeepMind's Three New Models for AI Agents

If I had to boil this down to one line, it’s this: use Gemini 3.5 Flash-Lite for cheap first-pass routing, Gemini 3.6 Flash for the main agent work, and Gemma 4 when you need to run things on your own systems.

Here’s the short version. The article compares three models across the points that matter most for AI agents: latency, cost, tool use, multimodal input, planning, and deployment control. One model is built for high-volume triage, one fits day-to-day execution, and one is built for self-hosted and private workloads.

What stood out to me most:

• Gemini 3.5 Flash-Lite is the low-cost traffic splitter for classification, extraction, and routing, with sub-200 ms latency
• Gemini 3.6 Flash sits in the middle as the main workhorse for tool calls, document work, and workflow steps, at around ~500 ms latency
• Gemma 4 shifts the trade-off toward open weights, Apache 2.0 licensing, local deployment, and private data handling
• Gemma 4 ranges from 2.3B to 31B parameters, with up to 256K context
• The 26B A4B MoE version activates 3.8B of 25.2B parameters at inference
• A tiered setup can lower spend by keeping simple tasks on smaller models and sending hard cases to larger ones

If you’re choosing fast:
pick Flash-Lite for routing, Flash for execution, and Gemma 4 for self-hosted control.

Google's 3.6 Flash Proves AI Agents Are About to Get Cheap

Quick Comparison

In other words, this isn’t about picking one “best” model. It’s about matching each model to the job using a unified LLM API so your agent stack stays fast, cost-aware, and under your control where needed.

1. Gemini 3.6 Flash

Agent workload fit

Of the three models, Gemini 3.6 Flash is the throughput-first option. Use it for high-volume agents that need low latency, steady cost, and fast turnarounds.

Latency and throughput

That makes it a good match for request-heavy flows like ticket triage, document lookup, or large-scale task routing. In these cases, speed matters most when the model also needs to act in a steady, dependable way.

Tool use and customization

You can pair it with function calling, retrieval, policy checks, and human approval steps to keep automation controlled. For example, it works well for an agent that reads a request, pulls source documents, calls tools, and sends edge cases to a human.

Next, Gemini 3.5 Flash-Lite shifts the trade-off toward lighter, lower-cost agent tasks.

2. Gemini 3.5 Flash-Lite

Agent workload fit

Gemini 3.5 Flash-Lite is the default low-cost model for high-volume classification, extraction, and routing. Think of it as the lightweight control layer in an agent stack: it handles the bulk of the traffic while larger models step in for tougher calls.

Latency and throughput

Its sub-200 ms latency makes it a strong fit for fan-out workflows, batching, and fast routing. When an agent system breaks one large job into many small tasks, Flash-Lite can clear those subtasks fast, then pass the results back for consolidation.

Cost and deployment model

Its low cost makes it the default first-pass model for large queues of simple tasks. If deployment control and open weights matter more than this setup, Gemma 4 shifts that trade-off.

Tool use and customization

Flash-Lite supports structured outputs and light task tuning for routing and extraction. A common pattern is simple: use Flash-Lite as the first-pass classifier or extractor, then send only edge cases to a stronger model. That way, larger agents can save heavier models for planning, multimodal reasoning, and hard exceptions.

3. Gemma 4

Agent workload fit

Gemma 4 is the control-first pick for agent stacks that need to run locally, work with sensitive data, and stay easy to tune. Its Apache 2.0 license lets teams fine-tune and deploy it on local systems, which fits regulated or offline setups with strict data-governance rules. It can also redact PII at ingress before data leaves local systems, which is handy for healthcare and finance teams ^[1].

That matters because local control isn't just about privacy. It's also about deciding how much you can tune the model, where it runs, and what kind of workload it can handle. With Gemma 4, that comes down to model size, context window, and runtime cost.

Latency and throughput

Gemma 4 runs from a 2.3B mobile model up to a 31B server model. That gives teams room to match the model to the job instead of forcing one model to do everything. Small models can handle edge tasks, while larger ones can take on planning or long-context reasoning.

The 26B A4B MoE variant stands out here. At inference, it activates 3.8B of 25.2B parameters, which helps keep runtime more efficient. On context length, the smaller models support 128K tokens, while the 12B, 26B A4B, and 31B models support 256K tokens. That's a good fit for long documents and long agent traces ^[1].

Cost and deployment model

Running Gemma 4 on your own hardware cuts out per-token API fees, but the bill doesn't vanish. It moves to servers, scaling, and uptime. So instead of paying a provider, you're paying for the stack behind the model.

Gemma 4 also gives teams a few ways to trim memory use. Quantization-Aware Training (QAT) checkpoints are available in GGUF, Mobile-optimized wNa8o8, and Compressed Tensors w4a16 formats. These can lower memory needs while keeping output quality close to bfloat16 ^[1].

That setup makes the model a strong fit when agents need local control and structured execution, and when the team is ready to manage the infra that comes with it.

Tool use and customization

Gemma 4 supports native function calling and a native system role, which gives agent developers more direct control over conversation flow and task execution ^[1]. It also works with transformers, vLLM, and llama.cpp ^[1], so it can slot into stacks many teams already use.

The Unified 12B variant can take image and audio inputs directly. That's useful for multimodal agents that need one fine-tuning path across text, image, and audio inputs ^[1].

Gemma 4 also includes a built-in "Thinking" mode. It helps on harder tasks, but it adds latency. In plain terms: use it for planning and complex reasoning, not for fast routing ^[1]. So while Gemma 4 leans hard into control, that control comes with infra demands and some speed trade-offs.

Trade-Offs, Integration Options, and Pros and Cons

If you look at these models as a stack, they divide pretty cleanly into three jobs: triage, execution, and local control.

So the main decision isn't just which model is best. It's whether you want one model to handle everything, or a tiered setup where each model takes the part it does best.

A tiered architecture tends to fit complex, enterprise-scale agents best. Flash-Lite can take on high-volume triage and routing at the lowest latency and cost. Gemini 3.6 Flash can handle core workflow execution, tool use, and long-context work. Gemma 4 fits regulated or private workloads that need self-hosting or private cloud deployment.

Used this way, teams can cut costs in a meaningful way compared with sending every request to one higher-capability model. At that point, the trade-off shifts: deployment control vs. operational simplicity.

For image or video generation outside text reasoning, APIMart can route tasks through a single multimodal API.

The table below sums up the main integration paths.

In practice, these trade-offs shape a pretty simple choice: use one model end to end, or split routing, execution, and private workloads across different layers.

Conclusion

The right model comes down to three things: task complexity, budget, and deployment control.

With that lens, Gemini 3.5 Flash-Lite is the first pick for lightweight routing. It fits high-volume routing and extraction work well. Use it for classification, extraction, and first-pass routing. If the job needs more coordination, step up to Gemini 3.6 Flash.

Gemini 3.6 Flash works as the default execution layer for production agents. It sits between Flash-Lite’s lower cost and Gemma 4’s control-first deployment, which makes it a solid default for teams that want strong output at scale. If deployment control matters most, Gemma 4 becomes the better fit.

Gemma 4 is built for teams that need control, privacy, or offline access. It fits regulated settings because it supports on-device or self-hosted processing and local PII redaction. Its open weights also make domain fine-tuning simpler.

Use Flash-Lite for routing, Gemini 3.6 Flash for execution, and Gemma 4 for self-hosted control.

FAQs

When should I use a tiered model setup?

Use a tiered model setup when you need to balance performance, cost, and reliability as your app grows.

Here’s the basic idea: send simple, high-volume tasks to lower-cost models, and save frontier models for complex, high-stakes work.

That split can cut API costs by 60% to 80%, especially when you only escalate a request after a lighter model fails to meet your confidence threshold.

It’s a pretty simple tradeoff. You don’t need your most advanced model handling every routine task. Let the lighter model take the first pass, then bring in the heavier model only when the job calls for it.

How do I choose between Gemini 3.6 Flash and Gemma 4?

Choose based on what matters most to you: speed, scale, or control.

Gemini 3.6 Flash is a high-performance multimodal model built for low-latency, high-volume tasks. That makes it a strong fit for real-time apps and cost-sensitive workflows.

Gemma 4 makes more sense if you want more control and flexibility, like local deployment or running the model on your own infrastructure. Go with Gemini 3.6 Flash for fast, scalable production. Pick Gemma 4 for private, on-device use or custom fine-tuning.

What agent tasks fit Flash-Lite best?

Flash-Lite is a good fit for high-volume, cost-sensitive work where efficiency matters more than deep reasoning. It does especially well with basic data extraction and classification.

It also works well as the first layer in a model cascade. In many setups, it can handle 70% to 85% of requests before sending tougher queries to premium models. That can cut costs by 60% to 75% while keeping standard agent workflows steady.