# Google Developer Experts

Experts on various Google products talking tech. - Medium

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## How Do Companies Build Their Own AI? A Look Inside Enterprise AI Architecture

DevFeed: [How Do Companies Build Their Own AI? A Look Inside Enterprise AI Architecture](<https://devfeed.tech/articles/how-do-companies-build-their-own-ai-a-look-inside-enterprise-ai-architecture-132381.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/how-do-companies-build-their-own-ai-a-look-inside-enterprise-ai-architecture-df815f44f896?source=rss----a67bd6fa7d58---4>)

Author: Geeta Kakrani

Published: 2026-11-13T14:23:08Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>), [ai security](<https://devfeed.tech/topics/ai-security.md>), [Retrieval Augmented Generation (RAG)](<https://devfeed.tech/topics/retrieval-augmented-generation-rag.md>), [ai observability](<https://devfeed.tech/topics/ai-observability.md>), [LLM observability](<https://devfeed.tech/topics/llm-observability.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Model Routing](<https://devfeed.tech/topics/model-routing.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [agent-guardrails](<https://devfeed.tech/tags/agent-guardrails.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-architecture](<https://devfeed.tech/tags/ai-architecture.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [enterprise-ai](<https://devfeed.tech/tags/enterprise-ai.md>), [enterprise-ai-architecture](<https://devfeed.tech/tags/enterprise-ai-architecture.md>), [model-context-protocol](<https://devfeed.tech/tags/model-context-protocol.md>), [rags](<https://devfeed.tech/tags/rags.md>)

### AI overview

Production enterprise AI requires multiple engineering layers beyond an LLM and chat interface. The article explains using RAG to ground answers in company documents, and tool calling through MCP to let agents interact with HR, Jira, Slack and other systems. Authentication and RBAC must enforce each user's permissions at the backend; guardrails such as injection detection and PII filtering add protections but do not replace authorization. Semantic caching and model routing can reduce cost and latency, with care for permissions, freshness and quality. Observability tracks retrieval, model calls, tools and execution traces; evaluations test accuracy, faithfulness, retrieval, tool use, security, cost and regressions after changes. Together these layers support safer, more reliable production systems.

### Source excerpt

Building an AI agent is easy. Making it reliable, secure, cost-efficient, and ready for thousands of employees is the real engineering challenge.Imagine your company has deployed an AI assistant for all its employees. An employee opens the chat interface and asks: "What is our company's leave policy?" The AI responds confidently: "You get 30 paid leaves and unlimited sick leave." The answer sounds professional. The employee trusts it and plans their vacation accordingly. But there is a problem. Your company never defined this policy. The AI simply invented the answer. This is called hallucination, and it is one of the biggest challenges when deploying Large Language Models (LLMs) in real business environments. Now imagine another situation. Your company has connected this AI assistant to its HR system, Jira, Slack, and internal databases. Employees can ask questions, apply for leave, raise IT tickets, and access company information. It looks impressive. But what happens when an intern asks for the CTO's or Senior Manager's salary? What happens when someone tries to manipulate the agent into revealing confidential information? What happens when 10,000 employees start using it every day and your API bill increases dramatically? These are not theoretical problems. They are real engineering challenges that appear when we move from AI prototypes to production systems. Building an enterprise AI agent is not just about selecting a powerful model and connecting it to a chatbot interface. It requires multiple layers of engineering. Let's understand these layers through a practical example: building an AI assistant for a company. 1. RAG: Stop Your AI from Inventing Company Policies The first problem is knowledge. An LLM has been trained on large amounts of publicly available information, but it does not automatically know your company's internal documents. It does not know: Your employee leave policy. Your work-from-home guidelines. Your reimbursement process. Your internal I

## Take Claude Code Above Average: Let Antigravity Review It

DevFeed: [Take Claude Code Above Average: Let Antigravity Review It](<https://devfeed.tech/articles/take-claude-code-above-average-let-antigravity-review-it-132382.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/take-claude-code-above-average-let-antigravity-review-it-a945412e7dcf?source=rss----a67bd6fa7d58---4>)

Author: Daniel Gwerzman

Published: 2026-11-13T14:21:02Z

Content type: opinion

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [google-antigravity](<https://devfeed.tech/topics/google-antigravity.md>), [MSP MCP](<https://devfeed.tech/topics/msp-mcp.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [antigravity](<https://devfeed.tech/tags/antigravity.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [design](<https://devfeed.tech/tags/design.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-4-argon](<https://devfeed.tech/tags/gemini-4-argon.md>), [google-antigravity](<https://devfeed.tech/tags/google-antigravity.md>), [google-developer-expert](<https://devfeed.tech/tags/google-developer-expert.md>), [november-2026](<https://devfeed.tech/tags/november-2026.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [process](<https://devfeed.tech/tags/process.md>), [review](<https://devfeed.tech/tags/review.md>), [security](<https://devfeed.tech/tags/security.md>), [stage](<https://devfeed.tech/tags/stage.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The author's central finding is that independent review works best as a dialogue between different AI tools and models, with a human resolving disagreements. In the described setup, Claude Code leads while Antigravity with Gemini 4 Argon reviews; a second review caught concurrent-session risk and missing backups, and later discussion exposed a proposed fix that would fail from a subfolder. The four-stage loop briefs an outside reviewer, requests structured findings and evidence for assumptions, lets the author challenge findings once, then sends changes back for verification and escalates unresolved questions. The author's agy-bridge MCP server connects Claude Code to Antigravity's headless `agy` CLI, preserving review conversations and backing up and comparing project state each turn. Reviewers can read files and run tests but are instructed to write only in scratch space; shell commands cannot be similarly restricted, and project `.agents/` skills may steer review, so the author advises checking them in untrusted repositories. The method is intended for consequential work; reviews take minutes and are unnecessary for throwaway tasks.

### Source excerpt

In November 2026, I spent a day building a small tool with Claude Code: a bridge that lets a second AI agent review Claude's work, run the tests in my project, and argue about what it finds. Partway through the day, the design was revised, the code was written, the tests passed, and Claude was satisfied with its work. Then I gave the same design and code to a different model, running in a different tool. It came back with two findings marked high. Two terminal windows could drive the same review at the same time, each starting its own process behind the other's back. And the reviewer could run shell commands in my project, but nothing backed up my uncommitted work before its turn. One stray git reset --hard would have wiped it. Both were real. Both were cheap to fix. Neither was the kind of thing the author finds by "double-checking". That was the first fix of the day. There were two more. One more thing about that reviewer. It wasn't a second Claude session. It was Antigravity, Google's agentic development platform, running a Gemini model. Today, every review I run goes to Gemini 4 Argon. That pairing is what this article is about: why Claude Code does better work when Antigravity reviews it, the four-stage review I run between them, and the open-source bridge I built so Claude Code can call Antigravity on its own. Why the Author Can't Be the Reviewer Start with what these models are. They learned from everything people have put online: the brilliant answer and the one that ships a security hole, the masterpiece and the first draft. They learned the distribution. So by default, they give you the middle of it. Ask for a function and you get the average function: it works on the happy path and carries the usual number of subtle problems. That isn't a flaw. It's the mathematics of the system. Average is the floor, not the ceiling. The same model has seen far better work than the average. But getting it there takes a process, not a cleverer prompt. The second thing to

## Is Gemini 3.8 Flash a new workhorse? Part 2: Priority inference and Provisional throughput.

DevFeed: [Is Gemini 3.8 Flash a new workhorse? Part 2: Priority inference and Provisional throughput.](<https://devfeed.tech/articles/is-gemini-3-8-flash-a-new-workhorse-part-2-priority-inference-and-provisional-throughput-131169.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/is-gemini-3-8-flash-a-new-workhorse-part-2-priority-inference-and-provisional-throughput-8d10006853b7?source=rss----a67bd6fa7d58---4>)

Author: Artem Nikulchenko

Published: 2026-11-12T15:44:52Z

Content type: news

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [API Business Models](<https://devfeed.tech/topics/api-business-models.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [application](<https://devfeed.tech/tags/application.md>), [billing](<https://devfeed.tech/tags/billing.md>), [flash](<https://devfeed.tech/tags/flash.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-3-8-flash](<https://devfeed.tech/tags/gemini-3-8-flash.md>), [genai](<https://devfeed.tech/tags/genai.md>), [google-gemini](<https://devfeed.tech/tags/google-gemini.md>), [inference](<https://devfeed.tech/tags/inference.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [priority](<https://devfeed.tech/tags/priority.md>), [provisioned-throughput](<https://devfeed.tech/tags/provisioned-throughput.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [standard](<https://devfeed.tech/tags/standard.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [time-to-first-token](<https://devfeed.tech/tags/time-to-first-token.md>), [vertex-ai](<https://devfeed.tech/tags/vertex-ai.md>)

### AI overview

The tests found that Gemini 3.8 Flash's Priority inference and Provisioned Throughput generally reduce response times and variability compared with Standard, but neither prevents long outliers or "freezes." Priority was faster on average than Standard, while Provisioned Throughput changed average latency little and narrowed the spread; long-prompt outliers still occurred. In 24-hour Provisioned Throughput tests, first-token time at Low effort did not depend on prompt size, while full response time generally increased with prompt size. The author describes Standard as flexible pay-per-use, Priority as a higher-priced pay-per-use tier with overflow downgraded to Standard, and Provisioned Throughput as a fixed-term commitment with overflow sent to a lower tier. Under an idealized usage estimate, Provisioned Throughput cost more than twice Priority for a week, but about 25% more for a month; fluctuating demand and idle capacity could raise real costs. The author suggests covering stable demand with provisioned capacity and allowing peaks to spill to lower tiers. Results are specific to the reported tests, and outliers remained across all three models.

### Source excerpt

Is Gemini 3.8 Flash a new workhorse? Part 2. In Part 1, we discovered that Gemini 3.8 Flash has a large spread when it comes to response time. In this part, I want to share my investigation of it further. First of all, let's see if this delay is time-dependent. In the next section, we are running Gemini 3.8 Flash with Low effort on three prompt sizes. Time to first token by hour: Time to first token by hour Total response time by hour: Total response time by hour Based on those results, we can see that USA morning hours have the biggest spread. But unfortunately, no particular time is protected against unexpected "freezes". Considering that "freezes" are more prevalent during the USA morning hours, one can assume that freezes are correlated with higher load on infrastructure serving Gemini 3.8 Flash, since this model is currently the default model for Gemini Workspace and personal Gemini. Priority inference To battle the problem above, GCP has introduced a concept of Priority inference: Highest criticality: Priority requests get the highest criticality, leading to higher reliability, even during peak load. Graceful downgrade: If your traffic exceeds your Priority limits, overflow requests are automatically served at the Standard tier instead of failing. This keeps your application online and helps to ensure business continuity. Transparent response: The API response indicates which tier served your request, giving you full visibility into your performance and billing. Let's see if switching to Priority inference will help with response time. During our test, we need to monitor to ensure we do not exceed Priority limits. For this test, we are running the same prompts at the same time (making parallel calls) on Gemini 3.8 Flash on Standard inference and Priority inference using Low effort. Time to first token: Standard vs Priority Time to first token: Standard vs Priority Total response time: Standard vs Priority Total response time: Standard vs Priority As expected,

## Lights-out for AI coding agents: Gemini, ADK and a canary that rolls itself back

DevFeed: [Lights-out for AI coding agents: Gemini, ADK and a canary that rolls itself back](<https://devfeed.tech/articles/lights-out-for-ai-coding-agents-gemini-adk-and-a-canary-that-rolls-itself-back-131170.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/lights-out-ai-coding-agents-gemini-adk-canary-rollback-36ac910de522?source=rss----a67bd6fa7d58---4>)

Author: Nicola Guglielmi

Published: 2026-11-12T15:44:05Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [google-adk](<https://devfeed.tech/topics/google-adk.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [canary release](<https://devfeed.tech/topics/canary-release.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [adk](<https://devfeed.tech/tags/adk.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [canary](<https://devfeed.tech/tags/canary.md>), [devops](<https://devfeed.tech/tags/devops.md>), [error](<https://devfeed.tech/tags/error.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [google-cloud-platform](<https://devfeed.tech/tags/google-cloud-platform.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [production](<https://devfeed.tech/tags/production.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [rollback](<https://devfeed.tech/tags/rollback.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

Lights-out moves a ticket from code changes to a staged canary using six agent roles, with scripts--not models--making GO/NO-GO decisions from numeric gates. PR checks include risk, secrets, dependencies, static analysis, tests, and mutation testing; post-merge, a signed image is deployed to 5% then 25% of traffic, with PromQL comparisons triggering automatic rollback. A person must approve promotion beyond 25%. It runs locally with Podman and recorded model responses, or live with a Gemini API key; its gates and deployment path remain active in either mode. Coding roles use Gemini CLI by default, while document roles use ADK with evals; Claude and OpenAI options are described, and a Claude change was blocked by the mutation threshold. The Google Cloud profiles are documented but untested, and the project says its approach is not yet proven on repositories outside its own.

### Source excerpt

What I learned putting six agents behind numeric gates, on a laptop, with no cloud account An agent opens a pull request on a codebase nobody on the team trusts. The tests are green. Now what? Do you merge it? Do you read every line? Do you let it reach production, and if so, who notices when it breaks? A lights-out factory runs in the dark because its safety systems are trusted. I wanted to know what that safety system looks like for AI coding agents that write and ship code, so I built one: lights-out. It takes a ticket all the way to production with six agent roles, and stops it at every point where a number says no. One human decision is left, before 100% of the traffic. Everything else is either a gate or a rollback. Reading every line doesn't scale when an agent can write a thousand of them before lunch. So I stopped trying to check the code and started designing the road it drives on: which files a ticket may touch, which numbers a change has to beat, how much real traffic a canary gets before a person looks at it. The agents pick the route, the guardrails decide where it can end up. My job moved from reviewing lines to choosing thresholds, and writing down where each one comes from. It runs complete on a laptop: no cloud account, no API key, no credit card. That constraint shaped most of the design, so I'll come back to it. The rule that comes first The model never decides whether a change is good. A number does. Every station in the pipeline is a script that prints exactly one line on stdout: GO: <name> or NO-GO: <name> -- <reason>. Tests, dependency advisories, static analysis, mutation score, the canary's error rate against stable. The agents write code, review it, explain a release and triage an alert. They never sit where a threshold sits. Written down it sounds obvious. In practice it's the first thing that erodes, because asking a model "is this canary healthy?" is easier than writing the PromQL query. So it became a rule with a check behind it, and ev

## Are Open LLMs Still Underrated, or Just Not Ready for Enterprise?

DevFeed: [Are Open LLMs Still Underrated, or Just Not Ready for Enterprise?](<https://devfeed.tech/articles/are-open-llms-still-underrated-or-just-not-ready-for-enterprise-118017.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/are-open-llms-still-underrated-or-just-not-ready-for-enterprise-1702a5651d54?source=rss----a67bd6fa7d58---4>)

Author: Geeta Kakrani

Published: 2026-11-04T14:26:59Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [llamafile](<https://devfeed.tech/topics/llamafile.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [gemma](<https://devfeed.tech/topics/gemma.md>), [litellm](<https://devfeed.tech/topics/litellm.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [about](<https://devfeed.tech/tags/about.md>), [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [all](<https://devfeed.tech/tags/all.md>), [api](<https://devfeed.tech/tags/api.md>), [approximation](<https://devfeed.tech/tags/approximation.md>), [article](<https://devfeed.tech/tags/article.md>), [attack](<https://devfeed.tech/tags/attack.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [best](<https://devfeed.tech/tags/best.md>), [bill](<https://devfeed.tech/tags/bill.md>), [budget](<https://devfeed.tech/tags/budget.md>), [but](<https://devfeed.tech/tags/but.md>), [cascade](<https://devfeed.tech/tags/cascade.md>), [cases](<https://devfeed.tech/tags/cases.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [google](<https://devfeed.tech/tags/google.md>), [google-gemini](<https://devfeed.tech/tags/google-gemini.md>), [google-gemma](<https://devfeed.tech/tags/google-gemma.md>), [just](<https://devfeed.tech/tags/just.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [open](<https://devfeed.tech/tags/open.md>)

### AI overview

Open LLMs are suited to routine, high-volume work as one layer in a routed AI system, but the evidence does not support replacing frontier models across the board. The article recommends handling repeat requests with caches or rules, routing routine tasks to small open models, reserving frontier models for hard reasoning, and setting token budgets. Reported routing research shows large potential cost reductions, but savings depend on workload and hosting utilization. Self-hosting shifts costs to compute, engineering, quality checks, latency tuning, and security review; cited break-even and performance figures are third-party estimates or benchmark results, not universal comparisons. The article advises testing models in shadow mode on an organization's own tasks, measuring cost per task and utilization, and starting with a narrow pilot. Its survey is small and mostly North American, and its energy-savings evidence is described as thin and largely modeled.

### Source excerpt

Geeta Kakrani Open models already run in production at 42% of enterprises, yet they take only about 5% of what those enterprises spend on AI. That gap, not model quality, is the real story. In Futurum's September 2026 survey, production users said open weights now carry about 34% of their AI tokens, up from 23% a year earlier. Google's Gemma runs in 55% of production accounts, up from 35%. But the money did not follow: the tokens move to open weights, and the budget reappears as servers, compute and engineering time. The survey is small (200 enterprises, 83 production users, mostly North America), so read it as a signal, not a verdict. So are open LLMs underrated, or just not ready? The short answer is neither. They are ready for the routine layer of an AI system, and they pay off only when they sit behind a router with a budget on top. This article covers what open models really cost (hosting, quality, latency, skills), and how to recover from each cost. The promise: stop paying frontier prices for routine work Most agent traffic is routine: tagging, extraction, formatting, simple lookups. Sending all of it to the biggest model is the main reason API bills climb. Open models attack exactly this part, and the research on routing supports the idea. FrugalGPT reports matching the best single LLM (for example GPT-4) with up to 98% lower cost, using prompt adaptation, model approximation and a cascade of models. RouteLLM reports cutting cost by more than 2x in some cases without compromising response quality. In the Futurum survey, low-complexity workloads grew from 39% to 51% of production users' open-weight usage, so enterprises are already using open models where it is safest. These are best-case, benchmark-style results. Your savings depend on how much of your traffic is truly routine, and on what the open model costs to run, which is the next section. The hidden bill: four costs the API price hides An open model has no per-token fee, but it is not free. The cost mo

## Leveling the Playing Field: Building a 100% Offline Kubernetes Docs RAG Exam Assistant with WebAI

DevFeed: [Leveling the Playing Field: Building a 100% Offline Kubernetes Docs RAG Exam Assistant with WebAI](<https://devfeed.tech/articles/leveling-the-playing-field-building-a-100-offline-kubernetes-docs-rag-exam-assistant-with-webai-118018.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/leveling-the-playing-field-building-a-100-offline-kubernetes-docs-rag-exam-assistant-with-webai-566efc066b6f?source=rss----a67bd6fa7d58---4>)

Author: Cyrus Wong

Published: 2026-11-04T14:26:55Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [Local-First](<https://devfeed.tech/topics/local-first.md>), [Web](<https://devfeed.tech/topics/web.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-web](<https://devfeed.tech/tags/ai-web.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [browser](<https://devfeed.tech/tags/browser.md>), [classroom](<https://devfeed.tech/tags/classroom.md>), [cloud-native](<https://devfeed.tech/tags/cloud-native.md>), [data-privacy](<https://devfeed.tech/tags/data-privacy.md>), [devops](<https://devfeed.tech/tags/devops.md>), [embeddinggemma](<https://devfeed.tech/tags/embeddinggemma.md>), [exam](<https://devfeed.tech/tags/exam.md>), [gemma-4](<https://devfeed.tech/tags/gemma-4.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [like](<https://devfeed.tech/tags/like.md>), [litert](<https://devfeed.tech/tags/litert.md>), [litertjs](<https://devfeed.tech/tags/litertjs.md>), [offline](<https://devfeed.tech/tags/offline.md>), [rag](<https://devfeed.tech/tags/rag.md>), [rags](<https://devfeed.tech/tags/rags.md>), [webai](<https://devfeed.tech/tags/webai.md>), [webgpu](<https://devfeed.tech/tags/webgpu.md>)

### AI overview

The article describes Kubernetes WebAI RAG, an offline browser assistant intended to give students consistent AI support during technical assessments without cloud access or inference fees. A maintainer prepares and distributes 16,483 documentation chunks with precomputed embeddings and a BM25 keyword index; students search them locally using semantic and keyword retrieval combined with reciprocal rank fusion, then receive streamed answers from Gemma 4 E2B with citations to a bundled Kubernetes documentation mirror. The Windows 11 setup uses a fixed localhost origin so the roughly 2 GB model can persist in browser OPFS storage. The article specifies Chromium with hardware WebGPU, about 8 GiB of free disk space, and memory limits designed for integrated GPUs. It also describes citation verification, YAML copying, and security measures including a restrictive content policy and inert Markdown rendering. The text presents a detailed implementation and its claimed classroom benefits, but provides no independent performance evaluation.

### Source excerpt

Leveling the Playing Field: Building a 100% Offline Kubernetes Docs RAG Exam Assistant with Web AI, Gemma 4, and WebGPU How to enable fair, zero-cost, air-gapped AI assistance in technical classrooms and assessments -- running entirely in the browser on everyday student hardware. The Classroom & Exam Dilemma: How Can We Use AI Fairly? As educators teaching cloud-native technologies like Kubernetes, we want our assessments to reflect real-world DevOps workflows. In production, engineers don't memorize every nested field of a Kubernetes YAML manifest -- they consult official documentation and use AI assistants to troubleshoot and scaffold configurations. However, allowing AI in a live classroom test or practical exam immediately introduces three critical pain points: The "Pay-to-Win" Equity Gap: Students with paid subscriptions to frontier cloud models (ChatGPT Plus, Claude Pro, Gemini Advanced) gain a massive speed and reasoning advantage over peers relying on free tiers with strict rate limits. Internet Access & Academic Integrity: Opening internet access so students can reach cloud AI APIs also opens the door to messaging apps, file-sharing sites, and unauthorized collaboration. Cloud API Costs & Data Privacy: Provisioning a centralized school-hosted LLM proxy for hundreds of concurrent exam-takers is expensive, vulnerable to rate-limit bottlenecks when everyone hits "Submit" at the same minute, and raises student privacy concerns. What if every student's computer could run an identical, pinned, official-documentation-grounded AI assistant completely offline? In this article, we'll walk through the architecture and implementation of Kubernetes WebAI RAG -- an open-source, 100% offline Retrieval-Augmented Generation (RAG) system running entirely inside the browser using Gemma 4 E2B, EmbeddingGemma, LiteRT-LM, TensorFlow.js, and WebGPU. https://medium.com/media/20d1c5f68aadab894d27095275f8dae3/hrefhttps://medium.com/media/74a7213c2a5fb8e8d7bae9fe600461e8/hrefEvolving fr

## Taming Cloud Costs: A Guide to the FinOps Framework in Google Cloud

DevFeed: [Taming Cloud Costs: A Guide to the FinOps Framework in Google Cloud](<https://devfeed.tech/articles/taming-cloud-costs-a-guide-to-the-finops-framework-in-google-cloud-116037.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/taming-cloud-costs-a-guide-to-the-finops-framework-in-google-cloud-85fff9762107?source=rss----a67bd6fa7d58---4>)

Author: Fed Mestrone

Published: 2026-11-03T13:13:50Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [finops](<https://devfeed.tech/topics/finops.md>), [cost-optimization](<https://devfeed.tech/topics/cost-optimization.md>), [Google Cloud Platform (GCP)](<https://devfeed.tech/topics/google-cloud.md>), [DevOps](<https://devfeed.tech/topics/devops.md>), [Finance](<https://devfeed.tech/topics/finance.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [abstractions](<https://devfeed.tech/tags/abstractions.md>), [accelerate](<https://devfeed.tech/tags/accelerate.md>), [accountability](<https://devfeed.tech/tags/accountability.md>), [applications](<https://devfeed.tech/tags/applications.md>), [based](<https://devfeed.tech/tags/based.md>), [bloat](<https://devfeed.tech/tags/bloat.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [business](<https://devfeed.tech/tags/business.md>), [business-value](<https://devfeed.tech/tags/business-value.md>), [but](<https://devfeed.tech/tags/but.md>), [cause](<https://devfeed.tech/tags/cause.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-costs](<https://devfeed.tech/tags/cloud-costs.md>), [cloud-finops](<https://devfeed.tech/tags/cloud-finops.md>), [cloud-finops-tools](<https://devfeed.tech/tags/cloud-finops-tools.md>), [costs](<https://devfeed.tech/tags/costs.md>), [finops](<https://devfeed.tech/tags/finops.md>), [framework](<https://devfeed.tech/tags/framework.md>), [google](<https://devfeed.tech/tags/google.md>), [google-cloud](<https://devfeed.tech/tags/google-cloud.md>), [google-cloud-platform](<https://devfeed.tech/tags/google-cloud-platform.md>), [guide](<https://devfeed.tech/tags/guide.md>)

### AI overview

The article presents FinOps as a shared engineering, finance, and business practice for making cloud spending visible and accountable while preserving team agility. It recommends a central governance function with financially informed staff embedded in product teams, clear RACI decision rights, and continuous cost allocation, forecasting, and optimization within engineering workflows. Its three-phase cycle is Inform (attribute and analyze costs), Optimize (reduce waste and improve rates), and Operate (apply ongoing guardrails), supported by five pillars covering accountability, measurement, optimization, planning, and tools. Named Google Cloud capabilities include Billing Reports and BigQuery Billing Export for visibility; FinOps Hub, Active Assist/Recommender, committed use discounts, Spot VMs, and BigQuery autoscaling for optimization; and budgets, alerts, Pub/Sub, Functions, policies, quotas, and labeling enforcement for governance. The article stresses that useful reporting depends on accurate resource labels and cost allocation.

### Source excerpt

FinOpsWhy FinOps is the DevOps of the Cloud Era I remember the early days of software engineering [Yes, I was there! Well, maybe not for the very very early days, but early enough...] As languages became more high-level and abstract, we became more productive and could create more software more quickly. But then we started needing new disciplines to manage the inefficiencies that the abstractions introduced: manual testing could no longer keep up with the sheer volume of output, so Test-Driven Development (TDD) came to the rescue; Performance Engineering emerged to wrangle the memory bloat and garbage collection latency introduced by managed languages like Java and Python; similarly, Site Reliability Engineering (SRE) and DevOps were born to manage the dizzying operational complexity that occurred once we abstracted monolithic applications into sprawling, virtualised micro-services. Today, the paradigm has shifted again. The computing power and storage we need for our applications and data are now based on rapidly elastic, globally distributed cloud infrastructure. This has unlocked unprecedented agility, allowing teams to innovate faster and scale instantly to meet global demand, deploying without the friction of physical hardware limits. Yet with infinite scale comes infinite spending potential. Because resources are consumed dynamically, unoptimised code and unchecked architectural decisions no longer just cause performance bottlenecks, they translate directly into an exponential financial drain. This reality has created the need for a new operational framework and cultural shift: Cloud FinOps. Just like DevOps, FinOps helps us to address the exact same underlying "crisis": speed breaks traditional organisational silos. When infrastructure becomes software and spending becomes dynamic, engineering decisions become financial decisions. FinOps brings technology, finance and business together to drive financial accountability and accelerate business value realisation

## Road to Mastery -- Being a Google Developer Expert

DevFeed: [Road to Mastery -- Being a Google Developer Expert](<https://devfeed.tech/articles/road-to-mastery-being-a-google-developer-expert-95457.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/road-to-mastery-being-a-gde-6157b05ed803?source=rss----a67bd6fa7d58---4>)

Author: Obum

Published: 2026-10-22T13:23:07Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [developer-relations](<https://devfeed.tech/topics/developer-relations.md>), [Google](<https://devfeed.tech/topics/google.md>), [Developer Events](<https://devfeed.tech/topics/developer-events.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Web](<https://devfeed.tech/topics/web.md>)

Tags: [2015](<https://devfeed.tech/tags/2015.md>), [2020](<https://devfeed.tech/tags/2020.md>), [2025](<https://devfeed.tech/tags/2025.md>), [ai](<https://devfeed.tech/tags/ai.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [career](<https://devfeed.tech/tags/career.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [community](<https://devfeed.tech/tags/community.md>), [developer](<https://devfeed.tech/tags/developer.md>), [flutter](<https://devfeed.tech/tags/flutter.md>), [full-stack](<https://devfeed.tech/tags/full-stack.md>), [google](<https://devfeed.tech/tags/google.md>), [google-developer-expert](<https://devfeed.tech/tags/google-developer-expert.md>), [mobile-development](<https://devfeed.tech/tags/mobile-development.md>), [production](<https://devfeed.tech/tags/production.md>), [programming](<https://devfeed.tech/tags/programming.md>), [retrospective](<https://devfeed.tech/tags/retrospective.md>), [software](<https://devfeed.tech/tags/software.md>), [speaking](<https://devfeed.tech/tags/speaking.md>), [stacking](<https://devfeed.tech/tags/stacking.md>), [story](<https://devfeed.tech/tags/story.md>), [technologies](<https://devfeed.tech/tags/technologies.md>)

### AI overview

The author describes an additive career path from web development and campus community organizing to work across mobile, blockchain, web, Cloud, and AI. They chose Flutter after comparing native Android with Kotlin, React Native with JavaScript, and Flutter with Dart, citing its hot reload, cross-platform support, approachable syntax, and community. Community referrals led to Flutter client work, while writing, speaking, and mentoring built a record of contributions. The article says GDE candidates need advanced knowledge in a Google technology and sustained community contributions; the author applied, interviewed, and was accepted in 2024, gaining recognition, connections, and speaking opportunities. They also describe blockchain constraints such as failed transactions from long loops and Solidity's 24 KB contract limit, and characterize real-world Web3 integration as unfinished. Future plans include more Cloud and AI community work and a Professional Data Engineer exam.

### Source excerpt

Road to Mastery -- Being a Google Developer ExpertTable of Contents - It's been 5 years ... - What Changed with me? - Entering Mobile Development - Being in the Flutter World - Entering Blockchain & Web3 - The Maestro I've become - The Expert's Paradox - The #GDE Exposure - Honorary Mentions - Parting Words It's been 5 years ... It's been 5 years since I last shared my developer career story. That was back in 2020, when I had become a Google Developer Groups on Campus (GDGoC) Lead. At the time, the GDGoC program was called Developer Student Clubs (DSC). In that piece, I wrote about my story from 2015, when I was first exposed to programming in secondary school, through 2020, when I was deeply involved in the community. Now, in 2025, another five years have passed. In this retrospective, I will walk you through my unique experiences, lessons learned, more community engagements, and of course, about being in the Google Developer Experts (GDE) program. What Changed with me? In 2020, I was a full-stack web developer. Today, I'm a full-stack blockchain, mobile, and web developer. Back then, I was a GDGoC lead, organizing local events in school. Now, I'm a GDE, mentoring others, speaking at greater events, and sharing expert knowledge on Google technologies. At the time, I had built a card game with Java and followed various tutorial projects. I had also built the first version of my portfolio website and delivered my first freelance website gig. Shout out to my cousin, Ebuka, for that referral. Since then, I have worked with various teams and built multi-user production software. I have learned about system architectures and gained mind-blowing developer experiences. I won a big hackathon, published many articles, and spoke at multiple events. I have met many people and, of course, have grown older 😎. It has been an additive process. Learning a new technology does not discard old ones. New experiences do not invalidate previous ones. I am simply stacking knowledge which in tu

## Is Gemini 3.8 Flash a new workhorse?

DevFeed: [Is Gemini 3.8 Flash a new workhorse?](<https://devfeed.tech/articles/is-gemini-3-8-flash-a-new-workhorse-95456.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/is-gemini-3-8-flash-a-new-workhorse-323c9698b34d?source=rss----a67bd6fa7d58---4>)

Author: Artem Nikulchenko

Published: 2026-10-22T13:17:54Z

Content type: comparison

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [compare](<https://devfeed.tech/tags/compare.md>), [flash](<https://devfeed.tech/tags/flash.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-3-6-flash](<https://devfeed.tech/tags/gemini-3-6-flash.md>), [gemini-3-7-flash](<https://devfeed.tech/tags/gemini-3-7-flash.md>), [gemini-3-8-flash](<https://devfeed.tech/tags/gemini-3-8-flash.md>), [gemini-flash](<https://devfeed.tech/tags/gemini-flash.md>), [genai](<https://devfeed.tech/tags/genai.md>), [google-gemini](<https://devfeed.tech/tags/google-gemini.md>), [latency](<https://devfeed.tech/tags/latency.md>), [regions](<https://devfeed.tech/tags/regions.md>), [release](<https://devfeed.tech/tags/release.md>), [vertex-ai](<https://devfeed.tech/tags/vertex-ai.md>), [workhorse](<https://devfeed.tech/tags/workhorse.md>)

### AI overview

The excerpt's latency tests show Gemini 3.8 Flash can be faster on medium and long prompts, but its response times vary much more and sometimes stall for minutes. Tests made parallel calls every five minutes over 24 hours on Standard Tier; model performance still needs evaluation against each project's data and use case. For short prompts, Gemini 3.5 Flash was faster. From Asia, 3.5 also benefited from dedicated regional endpoints, which 3.8 lacks; its Global and Multi-Region endpoints had comparable latency. At Medium effort, 3.8 was slower across tested prompt sizes. Switching from 3.5 Minimum to 3.8 Low was significantly slower, while 3.5 Medium to 3.8 Low favored 3.8 on longer prompts on average, again with wider spread. The author's conclusion is conditional: consider migration for longer prompts at Low or higher effort if occasional severe delays are acceptable; otherwise, test carefully or wait. Release and retirement dates cited are from Vertex AI and may differ from AI Studio.

### Source excerpt

Gemini 3.5 Flash was a workhorse for a lot of projects for quite some time (at least in AI universe terms). Then we saw the release of 3.6 Flash, 3.7 Flash, and finally 3.8 Flash going one after another (and not in preview -- but straight into GA). Leaving aside the reason and politics of this series of rapid releases -- it looks like it stopped at 3.8 Flash, and 3.8 Flash will stay with us for some time (again -- in AI terms...). So, does it mean it is finally time to update projects with Gemini 3.5 Flash to 3.8? And is 3.8 just a pure update? First official dates: +-------------------+-------------------+----------------------------+ | Model Endpoint ID | Release Date (GA) | Retirement Date (EOL) | +-------------------+-------------------+----------------------------+ | gemini-3.5-flash | May 19, 2026 | May 19, 2027 or later | | gemini-3.6-flash | July 21, 2026 | November 19, 2026 | | gemini-3.7-flash | August 13, 2026 | January 28, 2027 | | gemini-3.8-flash | September 2, 2026 | September 2, 2027 or later | +-------------------+-------------------+----------------------------+ Note: Release dates and EOL dates are kind of different a lot of times between Vertex AI and AI Studio (which is weird, to be honest). Dates above come from Vertex AI. Obviously, 3.6 and 3.7 were some kind of bridge releases, and I hope you haven't spent too much time and tokens switching your system to them. But 3.8 looks more promising and may be considered the next workhorse model... Obviously, you will need to evaluate a new model on your dataset and for your use case -- cause it is all very specific to the project. But one thing that we can compare (and it is true for all) -- latency. So, let's do that! But before we compare latency, there are several things that we need to discuss first. Regions Gemini 3.5 Flash and Gemini 3.8 Flash are actually available in different sets of regions. To be precise, both models are supported in Global and Multi-Region endpoints: global (Global routing, lowest

## Gemini 4 Argon Review (2026): What's New, Speed, Pricing & Honest Pros and Cons

DevFeed: [Gemini 4 Argon Review (2026): What's New, Speed, Pricing & Honest Pros and Cons](<https://devfeed.tech/articles/gemini-4-argon-review-2026-what-s-new-speed-pricing-honest-pros-and-cons-93916.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/gemini-4-argon-review-2026-whats-new-speed-pricing-honest-pros-and-cons-a6d3e7590997?source=rss----a67bd6fa7d58---4>)

Author: Geeta Kakrani

Published: 2026-10-21T13:56:21Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [google-antigravity](<https://devfeed.tech/topics/google-antigravity.md>), [API Business Models](<https://devfeed.tech/topics/api-business-models.md>), [gemma](<https://devfeed.tech/topics/gemma.md>), [google-adk](<https://devfeed.tech/topics/google-adk.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [adk](<https://devfeed.tech/tags/adk.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-model](<https://devfeed.tech/tags/ai-model.md>), [ai-studio](<https://devfeed.tech/tags/ai-studio.md>), [antigravity](<https://devfeed.tech/tags/antigravity.md>), [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [chrome](<https://devfeed.tech/tags/chrome.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [code](<https://devfeed.tech/tags/code.md>), [cons](<https://devfeed.tech/tags/cons.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-4-argon](<https://devfeed.tech/tags/gemini-4-argon.md>), [gemini-argon](<https://devfeed.tech/tags/gemini-argon.md>), [google](<https://devfeed.tech/tags/google.md>), [llm](<https://devfeed.tech/tags/llm.md>), [pricing](<https://devfeed.tech/tags/pricing.md>), [review](<https://devfeed.tech/tags/review.md>), [speed](<https://devfeed.tech/tags/speed.md>), [what-s-new](<https://devfeed.tech/tags/what-s-new.md>)

### AI overview

Gemini 4 Argon is presented as a fast reasoning model for long, multi-step tasks, with a 1,048,576-token shared context and a long-decode option for outputs up to one million tokens; the normal output limit is about 65,000. The author reports clear answers and good instruction following from testing it in Google Antigravity, while Google's examples and safety claims are identified as company-reported. It accepts text, images, video, audio and PDFs but outputs text only. Pricing is introductory at $2/$10 per million input/output tokens through November 30, 2026, then doubles; cached input is 95% cheaper. Developers get low, medium or high thinking levels and several agent tools, but there is no free API tier, Live API, explicit caching, image generation or audio generation. Full long output requires long decode through the Gemini API Interactions API in background mode. Benchmarks vary, and Google says cyber and biology safety evaluation continues.

### Source excerpt

I used Google's new AI model. It is fast and smart, with a 1M token window, but a few things still need fixing. Here is my real experience. Google has launched a new model family called Gemini 4, and the first model is Gemini 4 Argon. I have used it myself. In this post I will tell you what is new, what I liked, and what I think Google should improve. I will keep it simple, so you can read it in five minutes. What is Gemini 4 Argon? Gemini 4 Argon is Google's new flagship reasoning model. Google built it for hard work, like: Software engineering (big coding tasks) Deep maths and science problems AI agents that finish many steps on their own Professional work like legal and finance Cyber security defence A quick timeline: 30 September 2026: Google announced Argon. At first only a small group of trusted cyber defenders could use it. 13 October 2026: Argon became available to everyone through the Gemini API, Google AI Studio, Google Cloud, Antigravity and the Gemini app. The model ID for developers is gemini-4-argon. What is new in Gemini 4 Argon?1. A very big context window and output Argon has a 1 million token window (1,048,576 tokens to be exact). Input, thinking and output all share this space. The big news is the long decode feature. Normal replies stop at about 65,000 tokens. With long decode, Argon can write up to 1 million tokens in one go. Google calls this an industry-leading output limit. Why does this matter? You can ask for a full code migration, a long report, or a big document set, and the model does not run out of space so quickly. 2. Better at long, multi-step work Older models often get lost when a task has many steps. Argon is trained to stay on track for long tasks. This is useful for AI agents. Google also shared some examples from its own teams (these are Google's own claims, not independent tests): A big refactor of web page handling in Chrome code Finding performance problems in the open-source ADK-Python and Gemma inference code Moving old For

## Don't Wait for an Outage: Stress-Test Your Google Cloud Observability Setup Today

DevFeed: [Don't Wait for an Outage: Stress-Test Your Google Cloud Observability Setup Today](<https://devfeed.tech/articles/don-t-wait-for-an-outage-stress-test-your-google-cloud-observability-setup-today-93915.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/dont-wait-for-an-outage-stress-test-your-google-cloud-observability-setup-today-a987166fcd68?source=rss----a67bd6fa7d58---4>)

Author: Fed Mestrone

Published: 2026-10-21T12:50:54Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [observability](<https://devfeed.tech/topics/observability.md>), [Google Cloud Platform (GCP)](<https://devfeed.tech/topics/google-cloud.md>), [Cloud Logging](<https://devfeed.tech/topics/cloud-logging.md>), [Cloud Monitoring](<https://devfeed.tech/topics/cloud-monitoring.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>)

Tags: [alert](<https://devfeed.tech/tags/alert.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [basics](<https://devfeed.tech/tags/basics.md>), [business](<https://devfeed.tech/tags/business.md>), [business-context](<https://devfeed.tech/tags/business-context.md>), [cli](<https://devfeed.tech/tags/cli.md>), [code](<https://devfeed.tech/tags/code.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [dashboards](<https://devfeed.tech/tags/dashboards.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [error](<https://devfeed.tech/tags/error.md>), [fake](<https://devfeed.tech/tags/fake.md>), [generate](<https://devfeed.tech/tags/generate.md>), [google-cloud](<https://devfeed.tech/tags/google-cloud.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [it](<https://devfeed.tech/tags/it.md>), [logging](<https://devfeed.tech/tags/logging.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [observability](<https://devfeed.tech/tags/observability.md>), [outage](<https://devfeed.tech/tags/outage.md>), [python](<https://devfeed.tech/tags/python.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The Python-based Observability Testing Tool for Google Cloud generates configurable logs and metrics to validate PromQL, LQL, and Log Analytics SQL queries, exercise live alert routing, and train engineers in a sandbox. YAML jobs run in historical backfill mode for past time windows or live mode for incoming data and alert testing. The excerpt's setup requires Python 3.12+, a Google Cloud project, and a service account with Logs Writer and Monitoring Metric Writer roles; credentials may be auto-detected in Cloud Shell or on a GCE instance. Run `obs-tool -v --dry-run config.obs.yaml` to preview jobs before they call Google Cloud APIs. YAML data sources and variables can add randomized values, and GCE metadata can provide instance context.

### Source excerpt

How to validate alerts, train teams, and simulate chaos without breaking production The silence of a healthy system is a goal for every Site Reliability Engineer (SRE). But when you are building dashboards, writing query logic, or configuring alert policies, silence is your enemy. How do you test a "Critical CPU Load" alert if your CPU usage never goes above 20%? How do you validate a complex Log Analytics SQL query if the specific error pattern hasn't happened in months? Waiting for a real production failure to verify your observability stack is a dangerous strategy. By the same token, you probably don't particularly want to break your systems just to confirm that your alerts are working... What you need is a way to generate noise on demand! Enter the Observability Testing Tool for Google Cloud, a Python-based utility designed to fill your empty dashboards with meaningful, controlled, and realistic data. Why "Fake" Data Provides Real Business Value In a business context, observability is not just about having logs; it's about Mean Time To Detect (MTTD). If your detection logic is flawed, you won't know until it's too late. This tool addresses three critical business problems: Validation of Logic: Prove that your PromQL, LQL (Logging Query Language), and Log Analytics SQL queries actually catch what they are supposed to catch. Alert Simulation: distinct from simple unit testing, this allows you to trigger live alerts in real-time to verify notification channels (PagerDuty, Slack, Email) are routed correctly. Training & Onboarding: It is an excellent resource for training new engineers. You can simulate a "server outage" scenario in a safe sandbox environment and let junior engineers practice debugging using the Google Cloud console. How It Works: The Basics The Observability Testing Tool is a CLI (Command Line Interface) written in Python. It operates on a simple principle: Configuration over Code. You define what logs or metrics you want as well as when they should b

## A Renter's Guide to Sole Tenancy in GCE and GKE

DevFeed: [A Renter's Guide to Sole Tenancy in GCE and GKE](<https://devfeed.tech/articles/a-renter-s-guide-to-sole-tenancy-in-gce-and-gke-90231.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/a-renters-guide-to-sole-tenancy-in-gce-and-gke-59aad94b858f?source=rss----a67bd6fa7d58---4>)

Author: Fed Mestrone

Published: 2026-10-19T14:35:25Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Gke](<https://devfeed.tech/topics/gke.md>), [Google Cloud Platform (GCP)](<https://devfeed.tech/topics/google-cloud.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [virtualization](<https://devfeed.tech/topics/virtualization.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [attack](<https://devfeed.tech/tags/attack.md>), [bare-metal](<https://devfeed.tech/tags/bare-metal.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [critical](<https://devfeed.tech/tags/critical.md>), [crypto](<https://devfeed.tech/tags/crypto.md>), [crypto-mining](<https://devfeed.tech/tags/crypto-mining.md>), [database](<https://devfeed.tech/tags/database.md>), [gaming](<https://devfeed.tech/tags/gaming.md>), [gce](<https://devfeed.tech/tags/gce.md>), [gke](<https://devfeed.tech/tags/gke.md>), [google](<https://devfeed.tech/tags/google.md>), [google-cloud](<https://devfeed.tech/tags/google-cloud.md>), [google-cloud-platform](<https://devfeed.tech/tags/google-cloud-platform.md>), [guide](<https://devfeed.tech/tags/guide.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [high-frequency-trading](<https://devfeed.tech/tags/high-frequency-trading.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [l3-cache](<https://devfeed.tech/tags/l3-cache.md>), [latency](<https://devfeed.tech/tags/latency.md>), [tenancy](<https://devfeed.tech/tags/tenancy.md>)

### AI overview

Google Cloud sole tenancy dedicates physical hosts to workloads on GCE or GKE Standard, addressing physical-isolation requirements, core-based BYOL licensing, and possible noisy-neighbor performance effects. GCE uses node templates and zone-specific node groups; VMs attach through node affinity, with maintenance options to migrate within the group, restart in place, or move to shared hosts. GKE Standard can place node pools on a node group or use sole-tenant affinity. Autopilot does not support sole tenancy, though the text notes GKE Sandbox as an alternative isolation method. With GKE, Cluster Autoscaling can add worker VMs and the Compute Engine Node Group Autoscaler can add physical hosts, but provisioning may be delayed or fail if capacity, limits, or quotas prevent expansion; node auto-provisioning is unsupported. Hosts are charged in full regardless of utilization, and fragmentation can occur both between VMs on hosts and within VMs among Pods, making resource requests, sizing, scheduling, and consolidation important.

### Source excerpt

GCE, GKE and Sole TenancyWhat do property renters and Google Cloud users have in common? The solution to disturbing neighbours: rent the whole building! You have probably been there before, or know someone who has: you finally move into your new dream flat, everything is perfect, you saw so many places before, until this one finally resonated with you on all chords, and now you're living in it... But you're hardly a month into your tenancy and it's clear that your upstairs neighbour is a heavy-metal drummer (who loves to practice at 2:00 AM), the neighbour to your left must be running an industrial crypto-mining rig (that warms your living room wall to a crisp 27°C), and the kids downstairs provide louder entertainment than your own TV. Welcome to standard public cloud infrastructure! Sharing physical bare-metal hardware with third-party companies (technically known as multi-tenancy) is somewhat similar to renting a flat in a building where strangers live in lots of other flats... And ok, I admit it, I may have been stretching the scenario a bit: most people's neighbours are lovely and reasonable -- in the same way, running VMs on shared hardware is for the most part not a problem. However, there may be cases even in cloud computing where sometimes you just wish you did not have anyone else around you. Enter Sole Tenancy on Google Cloud. Why Do We Need Sole Tenancy? In the situation described earlier on, the neighbours' behaviours were such that they'd make anyone wish they had the entire building to themselves. So what would be the triggers in a cloud environment? The "Noisy Neighbour" Syndrome: High-throughput, latency-critical workloads (think high-frequency trading, real-time gaming engines, or massive database engines) don't like L3 cache contention or CPU stealing. Security Risks: several possible attack classes may affect VMs in shared hardware (side-channel attacks, memory remanence, resource exhaustion, ...). Google uses multiple layers of isolation, authenticatio

## Building On-Device AI Agents on Android with Google ADK -- Part 6: Advanced Agent Architectures --...

DevFeed: [Building On-Device AI Agents on Android with Google ADK -- Part 6: Advanced Agent Architectures --...](<https://devfeed.tech/articles/building-on-device-ai-agents-on-android-with-google-adk-part-6-advanced-agent-architectures-90232.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/building-on-device-ai-agents-on-android-with-google-adk-part-6-advanced-agent-architectures-b4b2bffbf1ba?source=rss----a67bd6fa7d58---4>)

Author: Pankaj Rai

Published: 2026-10-19T14:27:20Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [google-adk](<https://devfeed.tech/topics/google-adk.md>), [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>), [hierarchical agent systems](<https://devfeed.tech/topics/hierarchical-agent-systems.md>), [LiteRT](<https://devfeed.tech/topics/litert.md>), [vercel ai sdk](<https://devfeed.tech/topics/vercel-ai-sdk.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [google-adk](<https://devfeed.tech/tags/google-adk.md>), [human-in-the-loop](<https://devfeed.tech/tags/human-in-the-loop.md>), [litert](<https://devfeed.tech/tags/litert.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [on-device-ai](<https://devfeed.tech/tags/on-device-ai.md>)

### AI overview

This Android tutorial demonstrates how to use Google ADK to organize an on-device agent into a supervisor and specialist agents, route requests with `transfer_to_agent`, and pause destructive tool actions for user confirmation through a Jetpack Compose dialog. It also shows Kotlin implementation patterns and a mode selector for comparing single-agent, multi-agent, and human-in-the-loop designs.

### Source excerpt

Building On-Device AI Agents on Android with Google ADK -- Part 6: Advanced Agent Architectures -- Hierarchical Multi-Agent Teams & Human-in-the-Loop Safety Scale from a single agent to an autonomous multi-agent system. Implement supervisor routing with transfer_to_agent and safety approval gates. 1. Beyond the Monolithic Agent Over the course of this series, we have built a capable on-device AI agent: In Part 1, we initialized LiteRT-LM with Gemma on Android. In Part 2, we empowered it with programmatic BaseTool and compile-time @Tool KSP bindings. In Part 3, we explored ToolContext and session artifacts. In Part 4, we built local RAG with Room SQLite. In Part 5, we enabled real-time SSE streaming and an observability drawer. However, as applications scale into production, monolithic single-agent designs hit two major walls: 1. Tool Bloat & Cognitive Overload When an agent is given 15 to 20 tools, its system prompt becomes crowded with tool definitions. On small mobile models (1B to 2B parameters), too many tools degrade instruction following, cause tool hallucination, and dramatically increase prefill latency on mobile CPUs. 2. Unchecked Autonomy An autonomous agent must never perform destructive actions -- such as wiping an entire database, deleting user data, or triggering a financial transaction -- without explicit user confirmation. In this final article, we solve both challenges using Google ADK's most advanced primitives: Hierarchical Multi-Agent Teams: Decomposing our monolithic agent into a Supervisor Agent and specialized sub-agents with ADK's native transfer_to_agent mechanism. Human-in-the-Loop (HITL) Safety Gates: Pausing agent execution to prompt the user with an interactive Compose approval dialog before running destructive code. 2. Architecture One: Hierarchical Multi-Agent Teams Instead of forcing one generalist agent to know everything, we structure our system as a team of focused specialists overseen by a Supervisor Agent: graph TD User["User Prompt"

## If you thought running a DevFest was a walk in the park, here's a demo

DevFeed: [If you thought running a DevFest was a walk in the park, here's a demo](<https://devfeed.tech/articles/if-you-thought-running-a-devfest-was-a-walk-in-the-park-here-s-a-demo-87051.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/if-you-thought-running-a-devfest-was-a-walk-in-the-park-heres-a-demo-1b1c71c955d4?source=rss----a67bd6fa7d58---4>)

Author: Nicola Guglielmi

Published: 2026-10-14T15:11:34Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [browser-game](<https://devfeed.tech/topics/browser-game.md>), [Hackathon-Organiser](<https://devfeed.tech/topics/hackathon-organiser.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [Web app](<https://devfeed.tech/topics/webapp.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [adapters](<https://devfeed.tech/tags/adapters.md>), [badge](<https://devfeed.tech/tags/badge.md>), [based](<https://devfeed.tech/tags/based.md>), [beer](<https://devfeed.tech/tags/beer.md>), [box](<https://devfeed.tech/tags/box.md>), [browser](<https://devfeed.tech/tags/browser.md>), [building](<https://devfeed.tech/tags/building.md>), [call](<https://devfeed.tech/tags/call.md>), [can](<https://devfeed.tech/tags/can.md>), [chat](<https://devfeed.tech/tags/chat.md>), [co-op](<https://devfeed.tech/tags/co-op.md>), [demo](<https://devfeed.tech/tags/demo.md>), [devfest](<https://devfeed.tech/tags/devfest.md>), [firebase](<https://devfeed.tech/tags/firebase.md>), [game-development](<https://devfeed.tech/tags/game-development.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [google](<https://devfeed.tech/tags/google.md>), [here](<https://devfeed.tech/tags/here.md>), [here-s](<https://devfeed.tech/tags/here-s.md>), [heres](<https://devfeed.tech/tags/heres.md>), [innovation](<https://devfeed.tech/tags/innovation.md>), [park](<https://devfeed.tech/tags/park.md>), [running](<https://devfeed.tech/tags/running.md>), [thought](<https://devfeed.tech/tags/thought.md>)

### AI overview

OVERBOOKED! Survive the DevFest turns tech event organizing into a cooperative browser game where players handle event preparations, solve timed problems during the event, and review results in a retro. Its six-event season covers meetups through DevFest, with volunteer roles, venue-specific challenges, sourced tips, and a relaxed mode to teach new mechanics. Gemini is optional and requires the player's own key; it generates community-specific text within fixed tasks, while deterministic code controls rules, scores, and balance. The key stays in the browser and is sent only to Gemini, according to the article. Weekly challenges use the same scenario for everyone, and leaderboard scores are verified by replaying recorded player commands on the server. The game is free, open source under Apache 2.0, and available in five languages; phone play requires landscape orientation.

### Source excerpt

I turned the crises of running tech events into a co-op game. OVERBOOKED! Survive the DevFest: free, in the browser, in five languages.9:52am The keynote speaker texts me that their GPS took them to a field. Their laptop only has USB-C, and the adapters are in the chapter's box, in the control room, on the other side of the building. The Lab Wi-Fi just went down, the check-in queue hits 49 people and the badge printer has decided today is not its day. The staff chat has 47 unread messages. One is from my mom: "Did you eat? I saw you on Instagram, you look tired." Anyone who runs tech events, a GDG, a meetup or a conference, recognizes every line. Attendees usually see none of it and just enjoy a talk that starts on time. Why a game Organizer lessons travel by word of mouth, on a call between organizers or over a beer after the event. Or they are learned the hard way, on the day. After years of GDG events I wanted to make them playable, so you can try them first, fail without consequences and then talk about it together. I couldn't find a game that simulates running a tech event, from a Thursday meetup to a DevFest. So I built one: OVERBOOKED! Survive the DevFest. How it works Every event has three acts. The Countdown. Turn-based rounds of real dilemmas: the venue, the sponsor asking for the attendees' emails, volunteers, catering, the box of adapters. Each dot is a free evening, and there are never enough. Whatever nobody takes on happens anyway. The day. Real time, in the venue. Tap a problem and your organizer walks there and fixes it. Every problem has a ring running out; the yellow triangle is trouble about to happen, and it can be prevented. Meanwhile the staff chat never sleeps, and walking through the crowd means being stopped every three steps. The retro. The local newspaper, the numbers, the key moments, three lessons with sources and questions for the group retro. The season has six events: a Thursday meetup, a Study Jam, a Women Techmakers day (kids' corn

## How to Become a Google Developer Expert (GDE) in 2026: The Process and Honest Tips

DevFeed: [How to Become a Google Developer Expert (GDE) in 2026: The Process and Honest Tips](<https://devfeed.tech/articles/how-to-become-a-google-developer-expert-gde-in-2026-the-process-and-honest-tips-66514.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/how-to-become-a-google-developer-expert-gde-in-2026-the-process-and-honest-tips-6f0eae2931f1?source=rss----a67bd6fa7d58---4>)

Author: Geeta Kakrani

Published: 2026-10-06T22:32:38Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [developer-relations](<https://devfeed.tech/topics/developer-relations.md>), [coding-community](<https://devfeed.tech/topics/coding-community.md>), [Developer Events](<https://devfeed.tech/topics/developer-events.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [Google](<https://devfeed.tech/topics/google.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [community](<https://devfeed.tech/tags/community.md>), [content](<https://devfeed.tech/tags/content.md>), [developer](<https://devfeed.tech/tags/developer.md>), [developer-community](<https://devfeed.tech/tags/developer-community.md>), [events](<https://devfeed.tech/tags/events.md>), [experience](<https://devfeed.tech/tags/experience.md>), [faq](<https://devfeed.tech/tags/faq.md>), [gde](<https://devfeed.tech/tags/gde.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [google](<https://devfeed.tech/tags/google.md>), [google-developer-expert](<https://devfeed.tech/tags/google-developer-expert.md>), [groups](<https://devfeed.tech/tags/groups.md>), [habits](<https://devfeed.tech/tags/habits.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [impact](<https://devfeed.tech/tags/impact.md>), [net](<https://devfeed.tech/tags/net.md>), [process](<https://devfeed.tech/tags/process.md>), [tips](<https://devfeed.tech/tags/tips.md>)

### AI overview

The article says new GDE candidates cannot apply directly: they need a referral from a Google employee or active GDE, then submit a form and, if reviewed positively, complete a technical product interview. It recommends building a portfolio over time, ideally at least two years, that shows expertise and community contributions such as speaking, writing, teaching, and mentoring. Candidates must be at least 18 and interview in English; a degree is not required, and event organizing alone may not qualify. The author suggests tracking activities and proof in a spreadsheet to spot gaps and prepare the application. Applications can be resubmitted six months after an initial submission. Membership is reviewed annually, and the article advises checking the official FAQ because the process may change.

### Source excerpt

"How did you become a GDE?" I get this question almost every week. Sometimes it comes from a student, sometimes from a developer with ten years of experience. The question is always the same, and the worry behind it is the same too: "Where do I even apply?" Here is the short answer: you can't apply directly. And that surprises most people. So in this post I want to give you the full picture. What a GDE is, how the process works today, and the small habits that helped me. I'll keep my own story short, because this post is about your path, not mine. First, what is a GDE? A Google Developer Expert is an independent professional (not a Google employee) whom Google recognizes for deep knowledge of Google technologies and for helping the developer community. According to the official FAQ, the program has over 1,000 members worldwide. GDEs speak at events, create content, run workshops, mentor others and give feedback to Google product teams. Membership is also reviewed every year, so the title is not a trophy you keep forever. You keep it by staying active. A quick note on my own journey I started my career in 2003 as a technical trainer and software developer. Over the years I moved from Java, C++ and .NET to machine learning, and later to Generative AI and AI agents. Teaching was always the thread that connected everything. Before I became a GDE, I was already part of the Google Developer Groups community and I was already speaking at events. I became a GDE (AI/ML) in 2024. There was no secret trick. There was a long list of small things done again and again, and one very boring habit that I will share below. The GDE process today (2026) The process has changed over the years, so please don't rely on old blog posts, including old ones of mine. Here is what the official GDE FAQ says right now. Step 1: Build your portfolio Google asks you to show your impact over a long period, ideally at least 2 years, in the technical area you are applying for. Step 2: Get referred (nom

## Fine-Tuning Small Models for On-Device Agents: Train, Convert, and Measure What Changed

DevFeed: [Fine-Tuning Small Models for On-Device Agents: Train, Convert, and Measure What Changed](<https://devfeed.tech/articles/fine-tuning-small-models-for-on-device-agents-train-convert-and-measure-what-changed-65297.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/fine-tuning-small-models-for-on-device-agents-train-convert-and-measure-what-changed-f7f494a044f3?source=rss----a67bd6fa7d58---4>)

Author: Sasha Denisov

Published: 2026-10-06T07:20:54Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [peft](<https://devfeed.tech/topics/peft.md>), [lora](<https://devfeed.tech/topics/lora.md>), [LiteRT](<https://devfeed.tech/topics/litert.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>), [ML model versioning](<https://devfeed.tech/topics/ml-model-versioning.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-on-device](<https://devfeed.tech/tags/ai-on-device.md>), [apache](<https://devfeed.tech/tags/apache.md>), [build](<https://devfeed.tech/tags/build.md>), [data](<https://devfeed.tech/tags/data.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [edge](<https://devfeed.tech/tags/edge.md>), [edge-ai](<https://devfeed.tech/tags/edge-ai.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [hugging-face](<https://devfeed.tech/tags/hugging-face.md>), [inference](<https://devfeed.tech/tags/inference.md>), [litert](<https://devfeed.tech/tags/litert.md>), [lora](<https://devfeed.tech/tags/lora.md>), [mediapipe](<https://devfeed.tech/tags/mediapipe.md>), [model](<https://devfeed.tech/tags/model.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [trl](<https://devfeed.tech/tags/trl.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

The article presents litetune, an open-source command-line workflow for fine-tuning small models with LoRA, converting them to LiteRT-LM, and verifying converted artifacts against float models on held-out data. In the reported tests, eight-bit conversions stayed close to float on the measured workloads, while four-bit results varied by model and recipe and could show substantial quality losses. The author emphasizes testing the converted artifact and measuring performance on its target device.

### Source excerpt

How litetune rebuilds the LoRA-to-device workflow and measures the model that actually ships. In February 2025, I published a ten-step guide to fine-tuning Gemma with LoRA in Colab, converting the model, and running it on a phone. I build Flutter Edge AI (formerly flutter_gemma), a plugin for running these models directly on the device, so fine-tuning was the natural next step. Today, following that guide step by step no longer works. I first tried to update it, but replacing one stage led to another. LoRA was the only part that stayed the same. So this is not a patched version of the old tutorial. It is a new workflow, with one stage the original did not have: verifying the converted model on held-out data. What Changed in the Workflow The old guide was built around the first Gemma models -- 2B and 7B -- and MediaPipe for on-device inference. The entire path from training to a MediaPipe-ready artifact fit inside a single Colab notebook. Today, its parts are spread across Hugging Face, TRL, litert-converter, and LiteRT-LM. They have different dependencies, and export settings vary by model architecture. LoRA training itself still looks familiar -- the complexity now sits around it. Before training, you need to validate the data and create and record a held-out split. After training, you need to merge the adapter, select the export settings, build a .litertlm file, run it through LiteRT-LM, and compare its outputs with the original model. A working checkpoint does not guarantee that the final artifact will behave the same way. When it became clear that the old notebook could not simply be updated, I decided to put the modern workflow into one tool. That is how litetune started: an open-source command-line tool, released under Apache 2.0, that takes a dataset all the way to a verified .litertlm. Its job is to remove the handwritten glue code between a dataset and a model that an application can run. Instead of maintaining separate scripts for data preparation, LoRA train

## Building On-Device AI Agents on Android with Google ADK: Real-Time SSE Streaming and Agent Inspection

DevFeed: [Building On-Device AI Agents on Android with Google ADK: Real-Time SSE Streaming and Agent Inspection](<https://devfeed.tech/articles/building-on-device-ai-agents-on-android-with-google-adk-part-5-solving-the-frozen-app-problem-63037.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/building-on-device-ai-agents-on-android-with-google-adk-part-5-solving-the-frozen-app-problem-037747544213?source=rss----a67bd6fa7d58---4>)

Author: Pankaj Rai

Published: 2026-10-01T02:32:07Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [On-device AI](<https://devfeed.tech/topics/on-device-ai.md>), [Android](<https://devfeed.tech/topics/android.md>), [google-adk](<https://devfeed.tech/topics/google-adk.md>), [Media Queries](<https://devfeed.tech/topics/media-queries.md>), [PaLM](<https://devfeed.tech/topics/palm.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [android](<https://devfeed.tech/tags/android.md>), [chain-of-thought](<https://devfeed.tech/tags/chain-of-thought.md>), [compose](<https://devfeed.tech/tags/compose.md>), [gemma](<https://devfeed.tech/tags/gemma.md>), [google-adk](<https://devfeed.tech/tags/google-adk.md>), [on-device-ai](<https://devfeed.tech/tags/on-device-ai.md>), [sse](<https://devfeed.tech/tags/sse.md>), [streaming](<https://devfeed.tech/tags/streaming.md>)

### AI overview

This tutorial addresses responsiveness and observability challenges when building on-device AI agents for Android. It describes real-time SSE token streaming and a live Chain-of-Thought inspector built with Jetpack Compose. The excerpt notes that generating a 100-word response with Gemma 2B on a mobile CPU typically takes 4 to 8 seconds in batch mode, leaving users without immediate feedback.

### Source excerpt

Master on-device agent observability. Stream tokens in real time with StreamingMode.SSE and build a live Chain-of-Thought inspector in... Continue reading on Google Developer Experts "

## Building On-Device AI Agents on Android with Google ADK -- Part 4: Local RAG on Android -- Storing...

DevFeed: [Building On-Device AI Agents on Android with Google ADK -- Part 4: Local RAG on Android -- Storing...](<https://devfeed.tech/articles/building-on-device-ai-agents-on-android-with-google-adk-part-4-local-rag-on-android-storing-63036.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/building-on-device-ai-agents-on-android-with-google-adk-part-4-local-rag-on-android-storing-6f6d8947899d?source=rss----a67bd6fa7d58---4>)

Author: Pankaj Rai

Published: 2026-10-01T02:31:58Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Local AI](<https://devfeed.tech/topics/local-ai.md>), [Vectors & LLMs](<https://devfeed.tech/topics/vectors-llms.md>), [google-adk](<https://devfeed.tech/topics/google-adk.md>)

Tags: [adk](<https://devfeed.tech/tags/adk.md>), [ai](<https://devfeed.tech/tags/ai.md>), [android](<https://devfeed.tech/tags/android.md>), [database](<https://devfeed.tech/tags/database.md>), [memory](<https://devfeed.tech/tags/memory.md>), [on-device](<https://devfeed.tech/tags/on-device.md>), [rag](<https://devfeed.tech/tags/rag.md>), [retrieval-augmented-generation](<https://devfeed.tech/tags/retrieval-augmented-generation.md>), [room-database](<https://devfeed.tech/tags/room-database.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>)

### AI overview

The excerpt explains why an on-device agent should retrieve relevant information instead of placing a user's entire history in the prompt: limited context budgets, prefill latency on mobile CPUs, and irrelevant notes can impair responses. It proposes storing notes in a local Room SQLite database for Retrieval-Augmented Generation, but the excerpt ends before describing how retrieval works.

### Source excerpt

Combine Google ADK with Android's Room database to give your on-device agent permanent memory and local Retrieval-Augmented Generation. Continue reading on Google Developer Experts "

## Building On-Device AI Agents on Android with Google ADK -- Part 3: Demystifying ToolContext --...

DevFeed: [Building On-Device AI Agents on Android with Google ADK -- Part 3: Demystifying ToolContext --...](<https://devfeed.tech/articles/building-on-device-ai-agents-on-android-with-google-adk-part-3-demystifying-toolcontext-62303.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/building-on-device-ai-agents-on-android-with-google-adk-part-3-demystifying-toolcontext-f578992168cb?source=rss----a67bd6fa7d58---4>)

Author: Pankaj Rai

Published: 2026-09-30T02:53:40Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [google-adk](<https://devfeed.tech/topics/google-adk.md>), [On-device AI](<https://devfeed.tech/topics/on-device-ai.md>), [Android](<https://devfeed.tech/topics/android.md>)

Tags: [adk](<https://devfeed.tech/tags/adk.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [api](<https://devfeed.tech/tags/api.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [context](<https://devfeed.tech/tags/context.md>), [gemma](<https://devfeed.tech/tags/gemma.md>), [google](<https://devfeed.tech/tags/google.md>), [google-adk](<https://devfeed.tech/tags/google-adk.md>), [ksp](<https://devfeed.tech/tags/ksp.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [on-device-ai](<https://devfeed.tech/tags/on-device-ai.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

The excerpt introduces Google ADK's `ToolContext` as a runtime handle that gives tools access to session context beyond their input arguments and return values. It identifies questions tools may need to answer--who is invoking them, which session is active, and what happened earlier--and introduces ADK Artifacts for persisting intermediate notes or generated files across turns. The excerpt does not provide the promised implementation details or explain artifact versioning.

### Source excerpt

Go deep into the engine. Learn how ToolContext allows tools to inspect the active session, read user metadata, and save versioned... Continue reading on Google Developer Experts "

## Building On-Device AI Agents on Android with Google ADK -- Part 2: Giving Your Agent Hands --...

DevFeed: [Building On-Device AI Agents on Android with Google ADK -- Part 2: Giving Your Agent Hands --...](<https://devfeed.tech/articles/building-on-device-ai-agents-on-android-with-google-adk-part-2-giving-your-agent-hands-61528.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/building-on-device-ai-agents-on-android-with-google-adk-part-2-giving-your-agent-hands-850308e17154?source=rss----a67bd6fa7d58---4>)

Author: Pankaj Rai

Published: 2026-09-29T01:50:37Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [google-adk](<https://devfeed.tech/topics/google-adk.md>), [On-device AI](<https://devfeed.tech/topics/on-device-ai.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Android](<https://devfeed.tech/topics/android.md>), [LiteRT](<https://devfeed.tech/topics/litert.md>), [gemma](<https://devfeed.tech/topics/gemma.md>)

Tags: [adk](<https://devfeed.tech/tags/adk.md>), [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [apis](<https://devfeed.tech/tags/apis.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [call](<https://devfeed.tech/tags/call.md>), [compile](<https://devfeed.tech/tags/compile.md>), [custom](<https://devfeed.tech/tags/custom.md>), [functions](<https://devfeed.tech/tags/functions.md>), [google](<https://devfeed.tech/tags/google.md>), [google-adk](<https://devfeed.tech/tags/google-adk.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [inspect](<https://devfeed.tech/tags/inspect.md>), [ksp](<https://devfeed.tech/tags/ksp.md>), [on-device](<https://devfeed.tech/tags/on-device.md>), [on-device-ai](<https://devfeed.tech/tags/on-device-ai.md>), [time](<https://devfeed.tech/tags/time.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

An on-device Gemma model loaded with LiteRT-LM cannot answer questions about current phone state from training knowledge alone. Google ADK tools provide executable capabilities: the model emits a structured function call naming a tool and its arguments, waits for that tool to run, and can then use the result. The excerpt introduces BaseTool and compile-time @Tool KSP bindings as ways to add capabilities, but does not provide enough detail to compare them.

### Source excerpt

Empower your on-device AI Agent to inspect hardware, call Android APIs, and run custom functions using BaseTool and compile-time @Tool KSP... Continue reading on Google Developer Experts "

## Building On-Device AI Agents on Android with Google ADK -- Part 1: The Engine & Architecture

DevFeed: [Building On-Device AI Agents on Android with Google ADK -- Part 1: The Engine & Architecture](<https://devfeed.tech/articles/building-on-device-ai-agents-on-android-with-google-adk-part-1-the-engine-architecture-61527.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/building-on-device-ai-agents-on-android-with-google-adk-part-1-the-engine-architecture-bf5639a2f439?source=rss----a67bd6fa7d58---4>)

Author: Pankaj Rai

Published: 2026-09-29T01:50:28Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [google-adk](<https://devfeed.tech/topics/google-adk.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [gemma](<https://devfeed.tech/topics/gemma.md>), [Local AI](<https://devfeed.tech/topics/local-ai.md>), [Android](<https://devfeed.tech/topics/android.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [gemma](<https://devfeed.tech/tags/gemma.md>), [google-adk](<https://devfeed.tech/tags/google-adk.md>), [litert](<https://devfeed.tech/tags/litert.md>), [llms](<https://devfeed.tech/tags/llms.md>), [on-device-ai](<https://devfeed.tech/tags/on-device-ai.md>)

### AI overview

This introductory tutorial explains how to build on-device AI agents for Android using Google ADK, LiteRT-LM, and local Gemma models. It covers offline operation, privacy and latency considerations, agent tool use, model packaging, and the initial setup for running an agent turn.

### Source excerpt

Run local Gemma models offline, configure LiteRT-LM, navigate APK packaging traps and establish the foundational primitives of Google's Agent Development Kit. 1. The Shift from Simple Chatbots to Autonomous Agents For the past two years, mobile AI in Android apps has largely meant one pattern: taking user text, wrapping it into a network request, firing it to an expensive cloud API and rendering a markdown stream. While cloud LLMs offer vast knowledge, mobile apps have different requirements: Privacy & Compliance: Sensitive user data (health logs, private notes, device contacts) should never leave the phone. Offline Reliability: Airplane mode, subways, or poor cellular reception shouldn't break app functionality. Deterministic Latency: Skipping network hops eliminates DNS lookups, TLS handshakes and server queuing. Action over Conversation: Users do not just want an AI that talks; they want an AI that acts -- inspecting device battery levels, querying local Room SQLite databases, setting alarms and scheduling tasks. This is where Agents differ from simple LLM wrappers. An Agent is an autonomous system driven by a language model that operates in a loop: it receives a goal, reasons about what to do, inspects available Tools, invokes functions with structured JSON parameters, observes the output and iteratively works until the task is complete. Google introduced the Agent Development Kit (ADK) for Kotlin and Android (google/adk-kotlin). Combined with LiteRT-LM and Google's open-weight Gemma family, we can now build full-fledged, multi-turn, tool-calling agents running entirely on a physical Android device with zero cloud dependencies. In this introductory article, we will build the foundation: configuring the build system, extracting multi-gigabyte models without crashing the Android packager, initializing LiteRT-LM, and executing your first agent turn. 2. The Core Primitives of Google ADK Unlike generic prompting libraries, Google ADK provides an opinionated, productio

## Breaking and Securing AI -- 2: Unmasking the Threat Actors with Google Threat Intelligence

DevFeed: [Breaking and Securing AI -- 2: Unmasking the Threat Actors with Google Threat Intelligence](<https://devfeed.tech/articles/breaking-and-securing-ai-2-unmasking-the-threat-actors-with-google-threat-intelligence-55200.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/breaking-and-securing-ai-2-unmasking-the-threat-actors-with-google-threat-intelligence-468f3a0218de?source=rss----a67bd6fa7d58---4>)

Author: Antonella Blasetti

Published: 2026-09-18T15:29:01Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Threat Hunting & Intel](<https://devfeed.tech/topics/threat-hunting-intel.md>), [ai security](<https://devfeed.tech/topics/ai-security.md>), [Threat monitoring](<https://devfeed.tech/topics/threat-monitoring.md>), [AI software supply chain security](<https://devfeed.tech/topics/ai-software-supply-chain-security.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Single sign-on (SSO)](<https://devfeed.tech/topics/sso.md>), [Endpoint Security & XDR](<https://devfeed.tech/topics/endpoint-security-xdr.md>), [Splunk Enterprise Security](<https://devfeed.tech/topics/splunk-enterprise-security.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [cloud-services](<https://devfeed.tech/tags/cloud-services.md>), [dark-web](<https://devfeed.tech/tags/dark-web.md>), [google-cloud-platform](<https://devfeed.tech/tags/google-cloud-platform.md>), [google-threat-intelligence](<https://devfeed.tech/tags/google-threat-intelligence.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

The excerpt presents Google Threat Intelligence (GTI) as a threat-monitoring and response platform combining Google telemetry, Mandiant incident intelligence, and VirusTotal feeds, with Gemini AI described as helping surface risk insights. It says GTI and Mandiant Digital Threat Monitoring track underground forums, stolen credentials, exploits, and adversary tactics, then feed indicators into Chronicle SecOps and Cloud Armor. The article maps different defenses to risks: Model Armor screens prompts and responses; BeyondCorp applies contextual access checks; Security Command Center and Chronicle monitor cloud settings and behavior; Workforce Identity Federation uses short-lived tokens; and Cloud Storage retention controls protect backups. It illustrates these ideas through accounts of state-linked groups and ransomware syndicates, including destructive attacks, stealthy use of legitimate admin tools, credential theft, and backup deletion. The excerpt also attributes limits on stopping state-backed attackers to evasion, attribution difficulties, legal ambiguity, and escalation risks. These are the article's claims and examples; the supplied text does not independently substantiate or

### Source excerpt

Let's meet the Attackers: Business and evil Secret Services...for the bold only...we all are living inside a new, creeping World War but we do have defenses... Pirate Meccanico As developers and cloud architects, we are building at the absolute frontier of technology -- deploying autonomous agents, dynamic tool-calling systems, and automated pipelines at unprecedented speed. But to build truly remarkable AI systems, we need to understand a fundamental shift: the very capabilities that make AI agents so powerful also introduce an entirely new class of security risks. We need to dive into the Dark Web and cope with Criminals. Why? The cyber underworld operates as a dark reflection of Silicon Valley. Threat actors acquire their cyber weaponry across specialized shops, subscription marketplaces, and invite-only forums hidden within the dark web. To disrupt these activities, enterprise security must take the fight directly to the source. Google has turned the tables on the digital underground by extending its defensive network directly into the dark web. By leveraging Google Threat Intelligence and Mandiant Digital Threat Monitoring, we let Google actively infiltrate these hidden underground forums, scrape real-time adversary telemetry, and flag stolen credentials or pre-staged exploits. We need to look directly into the eyes of our enemies and thoroughly map their digital supply chain.Google Threat Intelligence (GTI) and Google Cloud Services in this article Google built GTI by combining three major cybersecurity powerhouses into a single platform: Google's Global Scale & Telemetry: Insights derived from protecting billions of users and endpoints daily across services like Gmail, Android, Chrome, and Google Cloud. Mandiant Frontline Intelligence: Deep human-curated analysis from elite incident responders directly investigating active breaches, nation-state campaigns, and zero-day exploits worldwide. VirusTotal Crowdsourced Database: Real-time threat feeds scanning millions of

## From Prototype to Production: How to Safely Deploy Gemini Enterprise Agents

DevFeed: [From Prototype to Production: How to Safely Deploy Gemini Enterprise Agents](<https://devfeed.tech/articles/from-prototype-to-production-how-to-safely-deploy-gemini-enterprise-agents-42170.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/from-prototype-to-production-how-to-safely-deploy-gemini-enterprise-agents-c71d3eb35529?source=rss----a67bd6fa7d58---4>)

Author: Geeta Kakrani

Published: 2026-09-18T00:23:09Z

Content type: tutorial

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Authorization](<https://devfeed.tech/topics/authorization.md>), [Google](<https://devfeed.tech/topics/google.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [google](<https://devfeed.tech/tags/google.md>), [google-gemini](<https://devfeed.tech/tags/google-gemini.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [permissions](<https://devfeed.tech/tags/permissions.md>), [policy](<https://devfeed.tech/tags/policy.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

A practical guide to moving Gemini Enterprise AI agents from prototypes into governed production systems. It focuses on identity, permissions, policy enforcement, monitoring, auditing, and accountability for actions involving customer data.

### Source excerpt

A practical look at building a governed, enterprise-ready AI agent with Google's Gemini Enterprise Agent Platform Every team building with AI agents eventually hits the same wall. The prototype works beautifully in a demo -- it answers questions, calls a few tools, feels almost magical. Then someone asks the obvious question: "Can this touch real customer data? Can it take real actions? What stops it from doing something we didn't intend?" That question is exactly why Google introduced the Gemini Enterprise Agent Platform at Cloud Next '26 -- a full rethink of how agents move from prototype to production, built around one idea: an agent should never have more access, more trust, or more autonomy than a human employee doing the same job. This piece walks through what that actually looks like, using a real, common use case: a customer-support agent. The Real Problem With "It Works in the Demo" Prototypes are optimized for one thing: showing that an agent can do a task. Production systems have to answer a harder set of questions: Does the agent only see data it's actually allowed to see? Can we prove, after the fact, exactly what the agent did and why? What happens when someone tries to manipulate it with a cleverly worded prompt? Who is accountable when an agent takes a sensitive action, like issuing a refund? None of these are solved by a better model. They're solved by infrastructure around the model -- identity, permissions, policy enforcement, and monitoring. That's precisely the gap the Gemini Enterprise Agent Platform was built to close. The Four Pillars: Build, Scale, Govern, Optimize Google organizes the platform around four pillars, but for anyone thinking about safety and compliance, one pillar matters most: Govern. It's built on three core components that work together. 1. Agent Identity -- Every Agent Gets Its Own ID In the old world, agents often ran with a shared service account, or worse, borrowed a human's credentials. Gemini Enterprise fixes this with Age

## \[Aug 2026\] AI Community -- Activity Highlights and Achievements

DevFeed: [\[Aug 2026\] AI Community -- Activity Highlights and Achievements](<https://devfeed.tech/articles/aug-2026-ai-community-activity-highlights-and-achievements-41358.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/aug-2026-ai-community-activity-highlights-and-achievements-25e3b1ee42b1?source=rss----a67bd6fa7d58---4>)

Author: Nari Yoon

Published: 2026-09-17T05:12:15Z

Content type: article

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Google AI](<https://devfeed.tech/topics/google-ai.md>), [Google](<https://devfeed.tech/topics/google.md>), [google-antigravity](<https://devfeed.tech/topics/google-antigravity.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Model Context Protocol](<https://devfeed.tech/topics/model-context-protocol.md>), [computer-use](<https://devfeed.tech/topics/computer-use.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [ai-studio](<https://devfeed.tech/tags/ai-studio.md>), [antigravity](<https://devfeed.tech/tags/antigravity.md>), [api](<https://devfeed.tech/tags/api.md>), [automation](<https://devfeed.tech/tags/automation.md>), [community](<https://devfeed.tech/tags/community.md>), [computer-use](<https://devfeed.tech/tags/computer-use.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [google](<https://devfeed.tech/tags/google.md>), [google-ai](<https://devfeed.tech/tags/google-ai.md>), [google-cloud](<https://devfeed.tech/tags/google-cloud.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [ocr](<https://devfeed.tech/tags/ocr.md>), [paper](<https://devfeed.tech/tags/paper.md>), [pitfalls](<https://devfeed.tech/tags/pitfalls.md>)

### AI overview

A monthly roundup of Google AI community activities and achievements, covering Antigravity prototyping and engineering, AI coding agents, MCP-based remote control, computer-use agent orchestration, earthquake research, and TPU fine-tuning and migration guidance.

### Source excerpt

We love sharing the accomplishments of the Google AI communities over the month. We appreciate all the hard work and dedication of our community members. Without further ado, here are the key highlights by products! Agentic DevelopmentAntigravityPrototype App: OCR and Text Extraction by the author Prototyping and Bringing Ideas to Application Using Google AI Studio and Antigravity 2.0 by AI GDE Joan Santoso (Indonesia) shares a rapid prototyping workflow building an AI-powered Form Extractor using the Gemini API, featuring a lightweight OCR and text extraction workflow. Antigravity Engineering Series by GDE Amulya Bhatia (Germany) focuses on key features of Antigravity 2.0 across 10 articles covering topics such as multi-agent orchestration, safety architecture, and workflow automation, accompanied by source code examples. (image soruce) Remote Control for Google Antigravity: Drive Your AI Coding Agent From Telegram 🛰 by GDE Nicola Guglielmi (Italy) introduces an open-source MCP server that turns Telegram into a remote control surface for AI coding agents. Before the Quake: How Antigravity CLI's AI Agents & IoT Data Predict Earthquakes by GDE Kanshi Tanaike (Japan) introduces the paper establishing Unified LAIC-AGW Theory by integrating ultra-dense IoT weather data with seismic moment tensors. It demonstrates a pre-seismic early warning capability by capturing enthalpy anomalies and acoustic-gravity waves. ADKAI GDE Henry Ruiz (US) and AI GDE Margaret Maynard-Reid (US) AI GDE Henry Ruiz (US) and AI GDE Margaret Maynard-Reid (US) introduced UISurf: An Operator-Centric Multi-Agent Platform for Observable and Cross-Environment UI Automation at the Agentic AI Summit 2026. They highlighted how the model-agnostic framework leverages the Google Cloud and Gemini ecosystems, such as GEAP and ADK, to orchestrate and evaluate computer-use agents across web, desktop, and mobile environments. Frameworks and ResearchTPU Introduction to SFT on TPU with Tunix -- 10 pitfalls until 2

[Next page](<https://devfeed.tech/sources/google-developer-experts-medium.md?cursor=WyIyMDI2LTA5LTE3VDA1OjEyOjE1KzAwOjAwIiwgIjM0MDMyOThlLTY4OTgtNGY1ZS1hOGVlLTJhMDA3Nzg2OTUzYSJd>)