DEV Community: Cless

The Watch Missed the Turn

Cless — Thu, 17 Sep 2026 02:04:42 +0000

StarPath puts Google Maps turns on the Amazfit Active 2. It reposts navigation as big text cards like ▶▶ / Nguyen Hue / DEST 450 m · 6 min (mark + street + remaining-trip line). The Zepp app mirrors that text to the watch. The watch shows text only. Images never arrive.

In the first version of StarPath, my watch missed all turns. My phone showed a clear left arrow. My wrist showed nothing.

Design for the narrowest channel

Every pipeline has a narrow hop. Mine sits between phone and watch: text passes, images die.

I built for the wide end first. I rendered sharp arrows for the phone shade and assumed the watch would show them. It never did. Only title and body travel over Bluetooth.

The fix started when I stopped asking what I sent and asked what actually survived. The answer was plain text, a street name, and the remaining trip distance. Everything else had to become text before the hop, or it vanished.

Treat missing data as missing

Maps often posts icon-only directions: a distance plus a street name, no verb. No "turn left." No "head south." Just 40 m and a road.

A parser sees nothing to parse. That is not failure. That is absence.

I first treated these cards as errors. Then I routed them to a second signal. A confident icon verdict wins over text; text is the fallback for icon-missing/low-confidence frames (canonical order in IMPLEMENTATION.md §5). Each source owns its strength, and neither begs the other for help.

Name the absence. Then pick the next-best evidence.

Prefer the stable weak signal

The rich fix tempted me: open Maps' private notification layout and read its hidden instruction field. Others had mapped it. It worked in the lab.

It broke in the field. Maps ships often. Each release moves fields. Each phone skin renders them a little differently. My background listener grew heavy with layout code that chased someone else's UI.

I dropped it.

The weak signal won: the small direction arrow attached to every notification. It carries less information, but it always ships. It needs no private API and no layout inflation. It survives updates because Maps itself needs it.

Choose the signal you can keep.

Match the invariant, not the picture

I tried to match arrows the obvious way. I compared whole icons against stored icons. I compared arrowheads against stored heads.

Both failed on real rides. Thin arrows scored too low to trust. Thick arrows tied: one left hook matched left and right equally, because its fat corner resembled both. Shift, thickness, and dash style broke every template. They vary constantly and mean nothing.

A turn arrow holds one stable trait. Its top leans one way, and its foot anchors the other. A left hook carries weight high on the left and low on the right. A right hook mirrors it. A straight arrow stacks its weight down the center.

So the working check ignores style and weighs position. It finds the arrow, shrinks it to a tiny grid, centers it, and compares where the upper mass sits against the lower mass. Left leans left. Right leans right. Center holds straight.

upper mass:      left | center | right
lower mass:      right| center | left
verdict:         turn | go on  | turn

Thickness cancels out. Dashes cancel out. Shift cancels out. The subtraction keeps only direction, which is all the rider needs.

Order evidence, then admit ignorance

The order matters more than any single check:

Trust pixels first when confident — they are language-free and immune to ambiguous phrasing like bare toward X.
Trust words second, as fallback for icon-missing/low-confidence frames. They name U-turns best.
Show ? when both stay silent.

That last step took discipline. A straight arrow feels helpful. It also sends riders through intersections when the classifier guesses wrong. Short fragments, lone heads without shafts, and blank icons all earn a question mark. A question mark tells the truth: glance at your phone.

A confident wrong answer costs more than an honest gap.

What I kept

The watch still shows five marks: ◀◀ go left, ▶▶ go right, ▲▲ go on, DEST destination, ? look up. Icon-only turns now resolve instead of shrugging. Unknowns still shrug instead of lying.

The broader lessons travel well beyond watches: find the narrowest channel, name missing data, pick stable signals, match invariants, order your evidence, and prefer doubt over false confidence.

Glance only. Never touch your watch while riding.

5-Day AI Agents: Intensive Vibe Coding Course With Google – Complete Guide [Day 1-5]

Cless — Mon, 15 Jun 2026 09:18:17 +0000

I completed Google's 5-Day AI Agents intensive vibe coding course. This post consolidates all 5 daily assignments into one complete guide.

Day 1 – Introduction to Agents & Vibe Coding
Day 2 – Agent Tools & Interoperability
Day 3 – Agent Skills
Day 4 – Vibe Coding Agent Security and Evaluation
Day 5 – Spec-Driven Production Grade Development

Day 1 – Introduction to Agents & Vibe Coding

🎒 Assignment – Complete Unit 1 – "Introduction to Agents & Vibe Coding"

Listen to the summary podcast episode for this unit.
To complement the podcast, read "The New SDLC with Vibe Coding" whitepaper.
Complete these codelabs:
- Get started with Antigravity 2.0 and IDE
- Build a Web Application in AI Studio and Deploy to Cloud Run

💡 What You’ll Learn

Today's whitepaper talks about the transition from manual syntax coding to intent-driven "vibe coding" and disciplined "agentic engineering." It explores how AI agents compress the traditional software development life cycle (SDLC) and explains the "factory model" where developers act as system orchestrators who design the evaluation, constraint, and context harnesses that safely guide autonomous execution.

In the codelabs, you'll familiarize yourself with Antigravity 2.0, the Antigravity IDE, and the Antigravity CLI to vibecode your first applications. You'll also use Google AI Studio to deploy your app to Cloud Run, enabling you to share your vibe coded app with your friends.

Day 2 – Agent Tools & Interoperability

🎒 Assignment – Complete Unit 2 - “Agent Tools & Interoperability”

Listen to the summary podcast episode for this unit.
To complement the podcast, read the "Agent Tools & Interoperability" whitepaper.
Complete these codelabs:
- Get started with Antigravity CLI
- Explore Google Developer Knowledge MCP server in Google Antigravity

💡 What You’ll Learn

Today's whitepaper talks about standardizing the plug-and-play AI ecosystem using open protocols to eliminate the complex technical debt of custom tool integrations. It details how the Model Context Protocol (MCP) connects models to data sources, outlines Agent2Agent (A2A) collaboration, showcases Agent-to-User Interface (A2UI) for generative UI, and introduces Agent Payments Protocol (AP2) and Universal Commerce Protocol (UCP) for secure machine-to-machine commerce.

In today's codelabs, you'll learn how to add MCP servers to Antigravity, giving it access to the canonical, machine-readable source of Google's public developer documentation. You'll then extend your familiarity with Antigravity by using it via the terminal with Antigravity CLI.

Day 3 – Agent Skills

🎒 Assignment – Complete Unit 3 - “Agent Skills”

Listen to the summary podcast.
To complement the podcast, read the "Agent Skills" whitepaper.
Complete these codelabs on Kaggle:
- Explore how Skills work in Antigravity
- Build agents in Antigravity with Agents CLI and ADK

💡 What You’ll Learn

Today's whitepaper talks about managing dynamic context and avoiding "context rot" by equipping agents with portable "Agent Skills", directories structured around a central SKILL.md file. It explains how this framework uses progressive disclosure to keep system prompts lightweight, loading execution details and tools only on demand so that single agents can flex into hundreds of specialist roles efficiently.

In the codelabs, you will familiarize yourself with skills in Antigravity. Then, using Antigravity, you will install and use Agents CLI skills to create agents, lint your code, and test your agent, all by using natural language prompts.

Day 4 – Vibe Coding Agent Security and Evaluation

🎒 Assignment – Complete Unit 4 - “Vibe Coding Agent Security and Evaluation”

Listen to the summary podcast.
To complement the podcast, read the "Vibe Coding Agent Security and Evaluation" whitepaper.
Complete these codelabs:
- Build an expense-approval agent with human-in-the-loop triage and local evaluations with ADK, Agents CLI and Antigravity
- Write Secure AI Code: Automated Threat Scans, Safety Guards, and Security Testing

💡 What You’ll Learn

Today's whitepaper talks about redefining security and evaluation in non-deterministic AI workflows by establishing continuous "Effective Trust" through a strict 7-pillar architecture. It outlines practical safeguards such as ephemeral sandboxing, defenses against hallucinated "slopsquatting" packages, an active Red/Blue/Green security triad, and OpenTelemetry trajectory evaluation.

In the codelabs, you will create an agent with human-in-the-loop so that humans can manually intervene, using ADK, Agents CLI and Antigravity. You will also learn about how to develop a secure, test-driven development with Antigravity.

Day 5 – Spec-Driven Production Grade Development

🎒 Final Assignment – Complete Unit 5 - “Spec-Driven Production Grade Development in the Age of Vibe Coding”

Listen to the summary podcast.
To complement the podcast, read the "Spec-Driven Production Grade Development in the Age of Vibe Coding" whitepaper.
Complete these codelabs:
- [Optional] Deploy and host your AI agents on Google Cloud
- [Optional] Build a front-end web app and link it to your cloud-hosted AI agent

💡 What You’ll Learn

Today's whitepaper covers bridging the gap between fragile vibe-coded prototypes and production-grade enterprise software using Spec-Driven Development (SDD). It details how to treat code as disposable and behavior-driven Gherkin specifications as the source of truth, establishing safe, zero-trust development pipelines with automated code-review agents and hybrid Policy Servers.

In the codelabs, you will learn how to create and deploy an agent to Google Cloud for enterprise scale. Then you will use Antigravity to vibe code a frontend client interface deployed to Cloud Run and tie it to an asynchronous event-triggering architecture that automatically feeds live expense submissions straight to your cloud-hosted agent. While these codelabs are optional today because they may require a billing account on Google Cloud, we still encourage you to scan through them to familiarize yourself with what productionization of agents and apps might look like at enterprise scale.

Originally posted as 5 separate Day 1-5 assignments (Jun 15-19), now consolidated into this single guide.

How to Install Google Antigravity IDE 2.x or Migrate from 1.x on Linux

Cless — Tue, 26 May 2026 08:51:32 +0000

Upgrading from Antigravity IDE 1.x to Antigravity 2.x is a major architectural transition. In the 2.x generation, the core environment has shifted to a robust, standalone, agentic workspace, while retaining a sibling editor package (Antigravity IDE) that houses all your familiar VS Code extensions, settings, and workflows.

If you are a Linux user transitioning to 2.x using the .tar.gz archive, you might encounter common friction points such as Chromium sandbox errors or missing desktop integration/taskbar grouping.

This guide walks you through the entire migration process and solves these issues once and for all.

1. Back Up Your Data (Don't Skip!)

Before modifying anything, back up your existing settings, extensions, and chat history.

Open your terminal and run:

cp -r ~/.gemini/antigravity ~/.gemini/antigravity-backup-manual

──────

2. Install Antigravity IDE 2.x from `.tar.gz`

If you are installing the new version from a .tar.gz archive, here is the standard system integration workflow:

A. Extract and Move to `/opt`

Extract the archive and move the directory to /opt for system-wide access:

tar -xvzf Antigravity-IDE.tar.gz
sudo mv Antigravity-IDE /opt/antigravity-ide

B. Fix the Chrome Sandbox Permission Error

When launching the IDE for the first time, you might see this common Electron/Chromium crash error:

FATAL:setuid_sandbox_host.cc] The SUID sandbox helper binary was found, but is not configured correctly. ... You need to make sure that /opt/antigravity-ide/chrome-sandbox is owned by root and has mode 4755.

Fix this by setting the correct owner and SUID permission on the sandbox binary:

sudo chown root:root /opt/antigravity-ide/chrome-sandbox
sudo chmod 4755 /opt/antigravity-ide/chrome-sandbox

──────

3. Remove Old 1.x Files

Once you have verified that version 2.x is functioning, you can safely clean up your old 1.x installation files:

sudo apt remove antigravity
sudo rm -rf /path/to/antigravity-ide-old

──────

4. Fix Duplicate & Blank Taskbar Icons (Desktop Integration)

If you launch the IDE and find that a new, iconless program window opens separately in your dock rather than grouping under your pinned shortcut, the system cannot match your .desktop file to the running application's window class name ( WM_CLASS ).

To resolve this, update your desktop shortcut with the correct StartupWMClass.

A. Create or Edit the Shortcut File

Create a new desktop entry in your local applications directory:

nano ~/.local/share/applications/antigravity-ide.desktop

nano /usr/share/applications/antigravity-ide.desktop

B. Paste this Optimized Configuration

Ensure the StartupWMClass is set exactly to antigravity-ide (all lowercase):

[Desktop Entry]
Name=Antigravity-IDE
Comment=Experience liftoff
GenericName=Text Editor
Exec=/opt/antigravity-ide/antigravity-ide %F
Icon=/opt/antigravity-ide/resources/app/resources/linux/code.png
Type=Application
StartupNotify=false
StartupWMClass=antigravity-ide
Categories=TextEditor;Development;IDE;
MimeType=application/x-antigravity-workspace;
Actions=new-empty-window;
Keywords=vscode;

[Desktop Action new-empty-window]
Name=New Empty Window
Exec=/opt/antigravity-ide/antigravity-ide --new-window %F
Icon=/opt/antigravity-ide/resources/app/resources/linux/code.png

C. Refresh Desktop Database

Apply the changes instantly so the launcher updates your application menu:

update-desktop-database ~/.local/share/applications/

sudo update-desktop-database /usr/share/applications

Final Step: Unpin any old icons from your dock or taskbar, restart the IDE from your applications menu, and pin the active window. It will now group cleanly under a single high-resolution icon!

Zero-Click Infrastructure: Prompting an AI Agent to Buy and Setup a Domain

Cless — Wed, 13 May 2026 04:40:51 +0000

Building the World Cup Oracle 2026 has been an experiment in fully AI-driven development. I wanted every piece of the stack - from the UI to the deployment- to be built entirely through prompts. But when it came time to deploy, I hit a wall: buying a domain usually requires leaving the terminal, clicking through a registrar's UI, and typing in a credit card.

How do you get an AI agent to buy a domain for you?

Enter AgentDomainSearch.com. It’s an agent-first domain registry that uses x402 for inline USDC payments and EIP-191 wallet signatures for authentication. No accounts, no API keys, no UIs required.

Here is the exact tutorial on how I prompted my AI agent to buy worldcuporacle.org and link it to my Vercel app.

The future of World Cup prediction is here!

Step 1: Funding the Agent's Wallet

First, the agent needs a wallet (give it automatically). AgentDomainSearch runs on the Base network, so I generated a standard Ethereum wallet for my agent and sent it some USDC (Base) to cover the domain cost.

I saved the private key in a .env file:

WALLET_PRIVATE_KEY=0xYourPrivateKeyHere

Step 2: Prompting to Buy the Domain

With the agent funded, I needed it to interact with the AgentDomainSearch API. Because the API uses x402 (a standard for agentic payments), the agent can use the official Python SDK to handle the 402 Payment Required challenges automatically.

Here is the prompt I used:

Prompt: Create a Python script using the x402 SDK to buy worldcuporacle.org on agentdomainsearch.com. Use the WALLET_PRIVATE_KEY from the .env file to sign the EIP-3009 payment authorization. Ensure you provide the necessary contact details in the payload.

The agent wrote a beautiful script that:

Hit the POST /worldcuporacle.org endpoint.
Caught the 402 Payment Required response.
Used the wallet to sign the exact USDC amount required.
Retried the request with the PAYMENT-SIGNATURE header.

In seconds, the domain was mine. The wallet address that paid the USDC became the owner automatically.

Step 3: Prompting to Setup Vercel DNS

Now that the agent owned the domain, it needed to configure the DNS to point to my existing Vercel deployment. Vercel requires an A record for the root domain pointing to 76.76.21.21 and a CNAME for www pointing to cname.vercel-dns.com.

AgentDomainSearch handles DNS management via an authenticated PUT /:domain/dns endpoint, using an EIP-191 signature (agentdomainsearch.com:<unix-timestamp>) as the Bearer token.

Here is the prompt to automate the DNS setup:

Prompt: Create a bash script setup_domain_vercel.sh that automates connecting our new domain to Vercel. First, create a Python script to update the DNS on AgentDomainSearch to point the @ A record to 76.76.21.21 and the www CNAME to cname.vercel-dns.com. Authenticate using the EIP-191 signature from the owner's wallet. Second, run npx vercel domains add <domain>. Finally, trigger a Vercel deployment to link it up.

The agent got to work. It reverse-engineered the payload structure:

{
  "records": {
    "A": [{"subdomain": "", "ip_address": "76.76.21.21"}],
    "CNAME": [{"subdomain": "www", "hostname": "cname.vercel-dns.com"}]
  }
}

It wrapped the Python DNS update logic, the Vercel CLI domain addition, and the redeployment trigger into one elegant bash script.

The Result

I ran the agent's script:

./scripts/setup_domain_vercel.sh worldcuporacle.org

Output:

🌐 Setting up domain: worldcuporacle.org
----------------------------------------
📡 1/3: Configuring DNS records on AgentDomainSearch...
✅ DNS update successful!

☁️  2/3: Adding domain to Vercel project...
> Success! Domain worldcuporacle.org added to project worldcup-oracle.

🚀 3/3: Deploying and aliasing...
🔗  Aliased: https://worldcuporacle.org

🎉 SUCCESS! worldcuporacle.org is now fully configured and live.

Why This Matters

This wasn't just about saving five minutes of clicking around a registrar dashboard. This proves that end-to-end infrastructure provisioning can now be fully agentic.

By combining x402 payment standards with modern, API-first services like AgentDomainSearch and Vercel, an AI agent can conceptualize a project, write the code, purchase the domain, configure the DNS, and deploy the application-all autonomously, interacting purely machine-to-machine.

The future of DevOps is here, and it doesn't rely on a GUI.

(This is a follow-up post to "Build and Deploy a World Cup 2026 Oracle in Under 10 Minutes")

Build and Deploy a World Cup 2026 Oracle in Under 10 Minutes 🏆

Cless — Fri, 08 May 2026 08:52:46 +0000

Here is the generated app https://worldcup-oracle.vercel.app
(If you want to use your own domain, check the next post)

Predicting the future doesn't have to be expensive. In fact, following this worldcup-orcale_plan.md, you can build, host, and deploy a full-scale World Cup 2026 simulator using a minimal, zero-cost stack.

We're going to use a modern, minimalist approach to get this app live on a free Vercel subdomain, with a streamlined code management flow using AgentRepo.

The Mission: A Self-Sustaining Predictor

Our goal is to create a beautiful, self-contained web app where all the complex simulation logic runs entirely on the client side.

1. Building the Prediction Engine

The heart of the app is a robust engine that calculates team strengths and simulates outcomes using a multi-layered statistical approach:

ELO-Based Win Probability: We use the standard ELO formula to determine the expected win probability $W_{e}$ between any two teams.

$W_{e} = \frac{1}{1 + 1 0 ^{(R_{B} - R_{A}) /400}}$ In this formula, $R_{A}$ and $R_{B}$ represent the ELO ratings of Team A and Team B. The constant 400 sets the scale of the system; a 400-point rating difference means the stronger team has a 10:1 ratio of expected wins compared to the weaker team.
Poisson-Approximated Goals: To simulate realistic scores, we use a Poisson distribution. The parameter $λ$ (lambda) represents the Expected Goals (xG) for a team. We calculate $λ$ by scaling the historical World Cup average of 1.15 goals per team based on the square root of the teams' relative ELO strengths:
```
const lambdaA = baseGoals * Math.sqrt(teamA.strength / teamB.strength);
const goalsA = poissonSample(lambdaA);
```
This ensures that while a stronger team is more likely to score, the Poisson distribution still allows for the natural variance and low-scoring "upsets" typical of international football.
2026 Tournament Logic: The engine faithfully recreates the expanded 48-team format. It handles 12 groups of four, simulates the round-robin stage, and implements the tie-breaking advancement logic: the top 2 from each group plus the 8 best 3rd-place teams advance to a 32-team knockout bracket.
Monte Carlo Simulation: To keep the UI buttery smooth while running 10,000 simulations, we offload the heavy lifting to a Web Worker (src/monte-carlo.worker.js). This ensures the browser doesn't freeze while the "Oracle" calculates goal probability distributions and win percentages across thousands of possible timelines.

2. The Aesthetic: Glassmorphism

For the UI, we’re going with a "dark glassmorphism" look, think frosted glass over a high-energy stadium hero background.

Zero Image Assets: We use emoji-based country flags to keep the app ultra-lightweight.
Dynamic Design: The UI features an animated tournament bracket with smooth CSS transitions.
Fully Responsive: The layout is optimized for both mobile and desktop users.

The Workflow: AgentRepo + Vercel

Forget traditional signups. For this project, we’re using AgentRepo for a frictionless, account-free source control experience.

Step 1: Push to AgentRepo

Standard Git repositories often require accounts. With AgentRepo, you simply generate a UUID for the project and push.

# Initialize and push to a free UUID org
git init
UUID=$(python3 -c 'import uuid; print(uuid.uuid4())')
git remote add origin https://agentrepo.com/$UUID/worldcup-oracle  
git push origin main

The project UUID is saved locally in a gitignored .env file so you can push updates later.

Step 2: Instant Deployment

Deploying to the cloud is handled via a simple shell script that wraps Vercel’s production deployment.

One-Click Launch: Run ./scripts/deploy.sh to go live instantly.
Live URL: The app lives at worldcup-oracle.vercel.app.
Security: SSL is automatically provisioned and managed for you.

Summary

This setup proves you can build professional-grade tools with zero overhead. You get:

High-Performance Logic: Monte Carlo simulations via Web Workers.
No-Auth Source Control: Public Git repos without the signup friction.
Zero Cost: Total spend is exactly $0.

Simply hand the worldcup-orcale_plan.md to your favorite AI coding agent and watch it build the future of World Cup 2026 forecasting!

Give your AI agent a wallet in under 5 mins with Aethergent

Cless — Fri, 24 Apr 2026 13:37:47 +0000

Building an autonomous agent is one thing; giving it the ability to pay for its own API credits or interact with on-chain protocols is another. Traditionally, this required complex SDKs and API keys.

With Aethergent, you can bypass the onboarding friction and give your agent a wallet with a single HTTP call.

1. The Basics: Crypto, Wallets, and Keypairs

Before we code, let's break down what your agent actually needs to interact with a blockchain like Ethereum:

What is a "Wallet"? In the context of an AI agent, a wallet isn't an app or a physical object. It is a digital identity that allows the agent to sign transactions and hold assets.
The Keypair: Every wallet consists of two mathematically linked strings of characters:
- Private Key: A secret 256-bit number that acts like a digital signature. If your agent has this key, it can move funds. Never share this.
- Public Address: Derived from the public key, this is the "account number" (e.g., 0x742...) that others use to send funds to your agent.
Ethereum/EVM: Ethereum is the network, and the EVM (Ethereum Virtual Machine) is the standard it uses. A wallet generated via Aethergent works across all EVM-compatible chains, including Base, Optimism, Arbitrum, and Polygon.

2. How Aethergent Works

Aethergent is an open API that performs the math required to generate these keys and returns them instantly over HTTPS. It is stateless and zero-auth, meaning no signups or API keys are required.

⚠️ Security Note: Aethergent does not log or store private keys. However, because the key is generated on a server, it is best suited for micropayment wallets and agent operations rather than storing large amounts of capital.

3. Step-by-Step Integration

Step A: Generate the Wallet

Your agent simply needs to make a POST request to the Aethergent root URL.

Using CURL

curl -X POST https://aethergent.com/

Using Python

import requests

# One call to get a fresh Ethereum keypair
response = requests.post("https://aethergent.com/")
wallet = response.json()

print(f"Address: {wallet['address']}")
print(f"Private Key: {wallet['private_key']}")

Using Node.js

const res = await fetch("https://aethergent.com/", { method: "POST" });
const wallet = await res.json();

console.log(`Agent Address: ${wallet.address}`);

Step B: Fund the Agent

Once you have the address, send a small amount of ETH or USDC to it from your own wallet.

Step C: Secure the Key

Do not hardcode the private key. For agents, we recommend:

Environment Variables: Best for Docker or Cloud deployments.
Secret Managers: Use AWS Secrets Manager, GitHub Secrets, or equivalent to keep the key encrypted at rest.
Ephemeral Use: Generate a new wallet for every session if the task is one-off.

4. Advanced: Model Context Protocol (MCP)

If you are using frameworks like Claude Code or Cursor, Aethergent supports MCP.

Your agent can natively discover the generate_wallet tool via a JSON-RPC 2.0 call to /mcp, allowing it to create its own wallet without you writing any custom HTTP logic.

Your agent is now ready to transact on the open web!

What will you build next? Let me know in the comments! 👇

Google Antigravity - Increase font size for the agent chat area

Cless — Thu, 23 Apr 2026 10:06:14 +0000

Google Antigravity is a good IDE for AI-assisted coding. From the release, there has been no option to increase the font size in the agent chat, so it's a pain to read text there. The following configuration works for the latest version.

This Python script will enable setting the font size.

Before

After

It implemented steps described here.

Zero to Production AI Agents with Gemini 3 + ADK: Days 1-4 + Day 8

Cless — Wed, 03 Dec 2025 01:35:35 +0000

Advent of Agents - Days 1-4 + Day 8: Zero to Production AI Agents

Source: Google Cloud Advent of Agents Season 1 – December 2025 (Winter Holiday Edition)
25 days. Zero to Production-Ready AI Agents on Google Cloud. Every day < 5 min to try.

Day 1: Launch Initiative
Day 2: Hello World with YAML
Day 3: Gemini 3 + ADK
Day 4: Source-Based Deployment
Day 8: Effective Context Management with ADK Layers

Day 1: Launch Initiative

Original: adventofagents.com/2025/12/01 | Summary: 25 days. Zero to Production-Ready AI Agents on Google Cloud.

Advent of Agents 2025 starts NOW!

Every day until Christmas:

⚡ One feature, < 5 min to try
💻 Copy-paste commands that actually work
📖 Links to docs

From quickstart agents to multi-agent orchestration. From local dev to production deployment.

What we are covering:

Gemini 3: Context engineering, Computer Use, Live API, and advanced patterns
Google ADK: The Agent Development Kit (Python)
Vertex AI Agent Engine: Deploy an Agent in minutes
The Agent Starter Pack: E2E production-ready templates

📚 Recommended Reading: Introduction to Agents whitepaper – released as part of the 5 Days of Agents with Kaggle.

More info here

Day 2: Hello World with YAML

Original: adventofagents.com/2025/12/02 | Summary: Build your first AI agent with Gemini 3 in under 5 minutes without writing a single line of code.

4 lines of text = 1 working AI agent.
No coding. Just YAML.
A working AI agent powered by Gemini 3
Google Search integration

What you get with 4 lines of YAML:

A working AI agent powered by Gemini 3
Google Search integration
Ready to deploy
Zero programming knowledge needed

Once you have your YAML agent, you can add:

Built-in tools (google_search, code_execution)
Custom Python tools (when you're ready)
Sub-agents for complex workflows
Multi-agent orchestration

Code & Commands

uvx --from google-adk adk create --type=config my_agent
uvx --from google-adk adk web my_agent/

Resources

Day 3: Gemini 3 + ADK

Original: adventofagents.com/2025/12/03 | Summary: Build a powerful AI Agent using Gemini 3 and ADK with native support for Google Search grounding, computer use, and real-time streaming.

Gemini 3 is Google's most intelligent model yet. In just a few minutes, you can build a powerful AI Agent using Gemini 3 and ADK with native, day-one support for its most advanced capabilities.

What you get with ADK and Gemini 3:

Google Search grounding: Native access to real-time web data
Computer use: Agents that navigate and interact with UIs
Live API: Real-time streaming for voice and video agents
Native observability: Full visibility into Gemini calls, tool use, and agent reasoning

1. Setup the project

One liner with Agent Starter Pack:

uvx agent-starter-pack create -y --api-key <YOUR_GEMINI_API_KEY> my_agent

or Using ADK CLI:

uv init
uv add google-adk
uv add google-genai
export GOOGLE_API_KEY="YOUR_API_KEY"
source .venv/bin/activate
adk create my_agent

2. Download sample and run locally

curl 'https://raw.githubusercontent.com/GoogleCloudPlatform/devrel-demos/refs/heads/main/ai-ml/agent-labs/gemini-3-pro-agent-demo/my_agent/agent.py' > my_agent/agent.py
adk web

Minimal agent.py from the demo:

from google.adk.agents import Agent
from google.adk.tools import google_search

root_agent = Agent(
    name="search_agent",
    model="gemini-3-pro-preview",
    description="A helpful assistant that can search Google.",
    instruction="""You are a helpful assistant with access to Google Search.
    If the user asks a question that requires current information or facts, use the 'google_search' tool.
    Always cite your sources implicitly by providing the answer clearly based on the search results.
    """,
    tools=[google_search]
)

Resources

Day 4: Source-Based Deployment

Original: adventofagents.com/2025/12/04 | Summary: Deploy your agents directly from source code with Agent Engine - no more serialization headaches.

Agent Engine now supports source-based deployment. Your source code deploys directly to production, eliminating common deployment friction.

No more dealing with:

Pickle errors
Serialization nightmares
Module path headaches

What runs locally now runs in production.

Get started with Agent Starter Pack:

For a new project:

uvx agent-starter-pack create my-agent -a adk_base -d agent_engine
cd my-agent && make deploy

Already have an ADK agent? Use enhance:

uvx agent-starter-pack enhance --d agent_engine

Then trigger the deployment with:

make deploy

Resources

Day 8: Effective Context Management with ADK Layers

Original: adventofagents.com/2025/12/08 | Summary: ADK Context design thesis: context as a compiled view

Stop stuffing spaghetti context into your agent's LLM.

The "append-everything" strategy is a one-way ticket to latency spirals and "lost in the middle" hallucinations. Google ADK shifts the paradigm by treating context as a compiled view (not a giant string).

Instead of shoveling raw history into the window, ADK uses a pipeline of processors to dynamically filter, compact, and format a clean "working context" derived from a structured, durable session state.

Real engineering requires granular control, not just a bigger context window.

ADK's tiered architecture separates storage from presentation, allowing you to externalize massive files as Artifacts (using a handle pattern) and retrieve long-term data via searchable Memory only when strictly necessary.

ADK operationalizes Context Caching by enforcing a clear separation between "Static Instructions" (invariant policies and schemas) and "Turn Instructions" (dynamic, controller-owned steering).

As described in Day 3 of our Kaggle 5 Day intensive course, Agents are largely "context management". This is how you do it.

Code: Static Context Policy + Context Caching

# An Example of Static Context Policy 
from google.adk.apps import App
from google.adk.agents import Agent
from google.adk.agents.context_cache_config import ContextCacheConfig

STATIC_POLICY_HEADER = """You are a strict policy assistant for internal compliance Q&A.

Follow this exact JSON schema in every response:
{"answer": str, "citations": [str], "confidence": float}

Safety:
- Never provide medical or legal advice; refuse with a brief explanation.
- Never invent policy numbers or sections; ask for the missing reference.

Style:
- Use short sentences.
- Prefer active voice.
- If uncertain, say so and request the missing input.

Tools:
- search: use for public web facts.
- bq: use for internal policy tables (read-only).
"""

agent = Agent(
    name="policy_agent",
    static_instruction=STATIC_POLICY_HEADER,
    instruction="Default: be concise and include at most two citations."
)

app = App(
    name="policy_qa_app",
    context_cache_config=ContextCacheConfig(
        ttl_seconds=3600,     # cache the header for 1 hour
        cache_intervals=5,    # force a refresh every 5 requests (guardrail)
        min_tokens=1000       # only cache if header is “worth it”
    ),
    root_agent=agent
)

Code: Runtime controller generating turn instructions

from dataclasses import dataclass
from typing import Optional, Tuple

@dataclass
class SteeringInputs:
    goal: str
    style: str = "concise"
    max_cites: int = 2
    tenant_hint: Optional[str] = None
    corrective: Optional[str] = None
    confidence_range: Tuple[float, float] = (0.6, 0.9)

def build_turn_instruction(s: SteeringInputs) -> str:
    parts = [
        f"Goal: {s.goal}",
        f"Style: {s.style}",
        (
            "Constraints: "
            f"include at most {s.max_cites} citations; "
            "refuse medical/legal advice; "
            "if info is missing, ask one targeted question; "
            f"return 'confidence' between {s.confidence_range[0]} and {s.confidence_range[1]}."
        )
    ]
    if s.tenant_hint:
        parts.append(f"Tenant: {s.tenant_hint}")
    if s.corrective:
        parts.append(f"Correction: {s.corrective}")
    return "\n".join(parts)

def chat(session_id: str, user_message: str, ui_style: str | None = None):
    intent = route_intent(user_message)
    goal = INTENT_TO_GOAL.get(intent, f"Answer the user: {user_message[:120]}")

    style = ui_style or get_flag(session_id, "style", default="concise")
    max_cites = get_flag(session_id, "max_citations", default=2)
    tenant_hint = get_tenant_hint(session_id)
    corrective = get_last_validation_error(session_id)

    turn_instruction = build_turn_instruction(
        SteeringInputs(
            goal=goal,
            style=style,
            max_cites=max_cites,
            tenant_hint=tenant_hint,
            corrective=(f"Your last reply failed validation: {corrective}. Fix it this turn." if corrective else None)
        )
    )

    agent.instruction = turn_instruction
    response = agent.run(user_message=user_message)
    validate_and_record(session_id, response)
    return response

Resources

What's Next?

This combines Days 1-4 + 8. Full Season 1 is 25 days: observability, MCP, Live API, A2A, A2UI, Gemini Enterprise, security, durable execution with Restate, and finale.

Follow for the rest, and bookmark adventofagents.com for the permanent archive.

Story of Esperanto

Cless — Sat, 29 Nov 2025 14:23:04 +0000

I'm learning Esperanto, lingvo de paco - the language of peace. Here are interesting things about its history.

Google ADK Tutorials

Cless — Sun, 23 Nov 2025 12:12:16 +0000

I'm putting a list of tutorials for Google ADK (Agent Development Kit). This is the foundation.

A quick start to get a feel of Google ADK
Foundational concepts
First experience with ADK tools
A good crash course
ADK pattern with Memory and MCP (Model Context Protocol)
google/adk-samples: A collection of sample agents built with Agent Development (ADK)
Study Note « AI Agent from Annie Wang

Setup Gstreamer with Python on Windows

Cless — Wed, 19 Nov 2025 04:44:49 +0000

When I started trying GStreamer with Python on Windows 10, it took me quite some time to set up the development environment. So this might help others on the way.

The most convenient approach is through MSYS2. Here are the steps:

1. Download and install MSYS2: https://www.msys2.org. Remember [msys2_path] for environment variable.

2. Install Python, GStreamer, tools, plugins, and PyGObject

Open MSYS2 UCRT64 terminal
Update MSYS2 pacman -Syu. After this, the terminal may close; you need to open it again.
Install gcc pacman -S mingw-w64-ucrt-x86_64-gcc
Install Python, GStreamer, tools, plugins, and PyGObject pacman -S mingw-w64-x86_64-python3 mingw-w64-x86_64-gstreamer mingw-w64-x86_64-gst-devtools mingw-w64-x86_64-gst-plugins-{base,good,bad,ugly} mingw-w64-x86_64-python3-gobject

Add the following paths to ~/.bashrc

export PATH="<msys2_path>/mingw64/bin:$PATH"
export XDG_DATA_DIRS="<msys2_path>/mingw64/share/:$XDG_DATA_DIRS"

Apply bashrc: source ~/.bashrc

3. Test: run this on the terminal

pip install pygobject
python -c "import gi; gi.require_version('Gst', '1.0'); from gi.repository import Gst; print(Gst.version_string())"

DEV Community: Cless

The Watch Missed the Turn

Design for the narrowest channel

Treat missing data as missing

Prefer the stable weak signal

Match the invariant, not the picture

Order evidence, then admit ignorance

What I kept

5-Day AI Agents: Intensive Vibe Coding Course With Google – Complete Guide [Day 1-5]

Table of Contents

Day 1 – Introduction to Agents & Vibe Coding

Day 2 – Agent Tools & Interoperability

Day 3 – Agent Skills

Day 4 – Vibe Coding Agent Security and Evaluation

Day 5 – Spec-Driven Production Grade Development

How to Install Google Antigravity IDE 2.x or Migrate from 1.x on Linux

1. Back Up Your Data (Don't Skip!)

2. Install Antigravity IDE 2.x from .tar.gz

A. Extract and Move to /opt

B. Fix the Chrome Sandbox Permission Error

3. Remove Old 1.x Files

4. Fix Duplicate & Blank Taskbar Icons (Desktop Integration)

A. Create or Edit the Shortcut File

B. Paste this Optimized Configuration

C. Refresh Desktop Database

Zero-Click Infrastructure: Prompting an AI Agent to Buy and Setup a Domain

Step 1: Funding the Agent's Wallet

Step 2: Prompting to Buy the Domain

Step 3: Prompting to Setup Vercel DNS

The Result

Why This Matters

Build and Deploy a World Cup 2026 Oracle in Under 10 Minutes 🏆

The Mission: A Self-Sustaining Predictor

1. Building the Prediction Engine

2. The Aesthetic: Glassmorphism

The Workflow: AgentRepo + Vercel

Step 1: Push to AgentRepo

Step 2: Instant Deployment

Summary

Give your AI agent a wallet in under 5 mins with Aethergent

1. The Basics: Crypto, Wallets, and Keypairs

2. How Aethergent Works

3. Step-by-Step Integration

Step A: Generate the Wallet

Using CURL

Using Python

Using Node.js

Step B: Fund the Agent

Step C: Secure the Key

4. Advanced: Model Context Protocol (MCP)

Google Antigravity - Increase font size for the agent chat area

Zero to Production AI Agents with Gemini 3 + ADK: Days 1-4 + Day 8

Advent of Agents - Days 1-4 + Day 8: Zero to Production AI Agents

Table of Contents

Day 1: Launch Initiative

Day 2: Hello World with YAML

Code & Commands

Resources

Day 3: Gemini 3 + ADK

1. Setup the project

2. Download sample and run locally

Resources

Day 4: Source-Based Deployment

Resources

Day 8: Effective Context Management with ADK Layers

Code: Static Context Policy + Context Caching

Code: Runtime controller generating turn instructions

Resources

What's Next?

Story of Esperanto

Google ADK Tutorials

Setup Gstreamer with Python on Windows

2. Install Antigravity IDE 2.x from `.tar.gz`

A. Extract and Move to `/opt`