DEV Community: Giorgio Boa

Reason, Act, Remember: Advanced AI with Microsoft Agent Framework

Giorgio Boa — Thu, 19 Feb 2026 09:15:01 +0000

Artificial Intelligence has moved beyond simple chatbots and into the realm of intelligent agents. These agents are not just passive responders; they are capable of reasoning, acting, and remembering. The Microsoft Agent Framework provides a comprehensive set of tools and libraries that empower developers to build these sophisticated AI systems.

The first step in this journey is installing the dependency.

pip install agent-framework --pre

Now that we have the right package, let's start by understanding what an agent actually is. In the simplest terms, an agent is a piece of software that uses a Large Language Model (LLM) to understand and generate human language.

The framework makes it incredibly easy to bring such an entity to life. With just a few lines of code, a developer can connect to Azure's powerful AI infrastructure. You can give your agent a name and a set of instructions. For instance, you might tell it to be a friendly assistant or a technical expert. The framework handles all the complex communication with the AI model, allowing you to focus on what you want the agent to do.

You can interact with this agent in two ways:

ask a question and wait for the complete answer, which is great for short queries
for longer responses, you can use streaming, where the agent "types" the answer out in real-time, making the experience feel much more interactive and responsive, just like a human typing a message.

import os
from agent_framework.azure import AzureOpenAIResponsesClient
from azure.identity import AzureCliCredential

# Create an agent
credential = AzureCliCredential()
client = AzureOpenAIResponsesClient(
    project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
    deployment_name=os.environ["AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME"],
    credential=credential,
)

agent = client.as_agent(
    name="HelloAgent",
    instructions="You are a friendly assistant. Keep your answers brief.",
)

# Run agent (non-streaming)
result = await agent.run("What is the capital of France?")
print(f"Agent: {result}")

# Run agent (streaming)
print("Agent (streaming): ", end="", flush=True)
async for chunk in agent.run("Tell me a one-sentence fun fact.", stream=True):
    if chunk.text:
        print(chunk.text, end="", flush=True)
print()

Expanding Capabilities with Tools

However, an AI that can only talk is limited. The real magic happens when you give your agent the ability to interact with the world. This is where the concept of "Tools" comes into play.

Imagine you want your agent to know the current weather. A standard language model only knows what it was trained on and cannot know if it is raining outside right now. You can define standard Python functions and attaching them to your agent.

You could write a simple function that checks a weather API. When you ask the agent about the weather, it analyses your request, the system intelligently decides to call the function you provided. It then takes the result from that function and uses it to formulate a natural language response.

from typing import Annotated
from agent_framework import tool
from pydantic import Field
from random import randint

@tool(approval_mode="never_require")
def get_weather(
    location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
    """Get the weather for a given location."""
    conditions = ["sunny", "cloudy", "rainy", "stormy"]
    return f"The weather in {location} is {conditions[randint(0, 3)]} with a high of {randint(10, 30)}°C."

# Create agent with tools
agent = client.as_agent(
    name="WeatherAgent",
    instructions="You are a helpful weather agent. Use the get_weather tool to answer questions.",
    tools=get_weather, <-- here you have to define the tool
)

result = await agent.run("What's the weather like in Seattle?")
print(f"Agent: {result}")

Multi-Turn Interactions with Sessions

If you tell an agent your name at the start of a chat, you expect it to remember that name five minutes later. The framework solves this through "Sessions".

A session acts as a container for the conversation history. When you talk to the agent within a session, the framework automatically keeps track of what has been said.

This allows for multi-turn conversations where the agent maintains context. This creates an experience that feels personal and coherent rather than robotic.

# Create a session to maintain conversation history
session = agent.create_session()

# First turn
result = await agent.run("My name is Alice and I love hiking.", session=session)
print(f"Agent: {result}\n")

# Second turn — the agent should remember the user's name and hobby
result = await agent.run("What do you remember about me?", session=session)
print(f"Agent: {result}")

The Microsoft Agent Framework provides a comprehensive toolkit for building intelligent AI agents that reason, act, and remember. Key features include core agent interaction via LLMs, dynamic tool integration for real-world tasks, and session-based conversation persistence. Finally the journey for building an AI agent is both accessible and powerful.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Copilot: Secret Tip to Troubleshooting Your GitHub Actions

Giorgio Boa — Thu, 12 Feb 2026 08:16:04 +0000

GitHub Actions have become an indispensable tool for automating software development workflows, enabling continuous integration and delivery directly within your repositories. However, even the most meticulously crafted pipelines can encounter issues, leading to frustrating debugging sessions. This is where GitHub Copilot emerges as a powerful assistant, offering intelligent insights and streamlining the troubleshooting process for your GitHub Actions workflows.

Traditionally, pinpointing the root cause of a failed GitHub Actions run involves sifting through extensive logs, meticulously checking syntax, and understanding the intricate interplay of various actions and conditions. This can be a time-consuming, especially for intricate workflows or those managed by multiple contributors.

Copilot aims to transform this experience, acting as an intelligent partner that can quickly analyse failures and suggest solutions.

Here is an example:

One of Copilot's most compelling features for GitHub Actions troubleshooting is its ability to provide immediate explanations for failed checks. You no longer need to manually navigate through layers of logs to understand what went wrong. With a simple click on the "Explain error" option next to a failed check in the merge box or on the workflow run summary page, Copilot springs into action. It opens a chat window, where it will analyze the context of the failure and offer actionable instructions to resolve the issue. This direct and contextual guidance significantly reduces the time and effort required to diagnose problems.

This kind of intelligent assistance can be invaluable for understanding the flow of your workflow and identifying logic errors more efficiently.

It acts as an intelligent accelerator, helping you navigate complex scenarios and quickly pinpoint solutions. By leveraging Copilot as a helper in your GitHub Actions pipelines you can spend more time building and less time debugging.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Hooks are here: Now you can intercept and direct the path of the Gemini CLI

Giorgio Boa — Thu, 29 Jan 2026 09:11:47 +0000

The Gemini Command Line Interface (CLI) is a powerful tool, and with the introduction of its "hooks" feature, users can now significantly extend and customise its behaviour without ever touching the core source code.

Hooks are essentially scripts or programs that the Gemini CLI executes at specific, predefined points within its agentic loop, offering unparalleled control and flexibility.

Use Cases

Imagine being able to inject crucial context before your AI model even sees a request, validate potentially risky actions before they execute, or even enforce company-wide compliance policies directly within your development workflow. This is precisely the power that Gemini CLI hooks bring to the table. By running synchronously as part of the agent loop, hooks ensure that the CLI waits for their completion before proceeding, guaranteeing that your custom logic is always applied.

Getting Started

Hooks communicate with the CLI via strict JSON requirements over stdin and stdout – the "Golden Rule" dictates that your script must only print the final JSON object to stdout, reserving stderr for all debugging and logging. Exit codes play a crucial role, with 0 signifying success and allowing stdout to be parsed, while 2 indicates a "System Block," aborting the target action and using stderr as the rejection reason. Hooks can also be selectively triggered using "matchers," which are regular expressions for tool events and exact strings for lifecycle events.

Real Case Scenario

Consider a scenario where you want to prevent the delete_file tool from being executed if a specific environment variable isn't set. You could configure an hook with a matcher for delete_file. This hook script would check for the environment variable. If it's missing, the script would print a JSON object like {"decision": "deny", "reason": "Environment variable 'ALLOW_DELETIONS' not set."} to stdout and exit with code 0. The Gemini CLI would then parse this and block the delete operation.

Configuration

Here is the official announcement with all the possibile configurations.

The configuration is handled in settings.json, with a clear hierarchy of precedence from project to system settings. This allows for granular control, from project-specific security checks to global compliance policies. The configuration schema defines fields like type (currently only "command" is supported), the command to execute, a friendly name, and an optional timeout.

e.g.

{
  "hooks": {
    "BeforeTool": [
      {
        "matcher": "write_file|replace",
        "hooks": [
          {
            "name": "security-check",
            "type": "command",
            "command": "$GEMINI_PROJECT_DIR/.gemini/hooks/security.sh",
            "timeout": 5000
          }
        ]
      }
    ]
  }
}

Hooks execute arbitrary code with your user privileges. Therefore, caution is advised, especially with project-level hooks in untrusted projects.

Mastering these hooks means gaining control over your AI interactions, ensuring that the Gemini CLI operates exactly as you intend, securely and efficiently, across all your projects.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Senior Developer's Secret: AI-Driven Iteration with VSCode, Cline & Playwright

Giorgio Boa — Mon, 26 Jan 2026 14:23:09 +0000

The integration of VSCode, Cline, and the Playwright Model Context Protocol (MCP) Server marks a significant leap forward in frontend application development, testing, and refinement.

This powerful combination empowers developers to iterate with browsers more effectively, streamlining workflows and accelerating the delivery of high-quality web experiences.

The New Frontend Development Workflow

This integration creates a seamless and highly efficient feedback loop for frontend developers. With Cline embedded in VSCode, developers can leverage AI to generate code snippets, refactor existing code, and understand complex codebases. Cline can even execute commands directly in the terminal, adapting to the development environment and toolchain. This dramatically speeds up the initial coding phase and helps maintain code quality.

The Playwright MCP Server is the bridge that connects the AI capabilities of Cline (or other LLMs) with actual browser environments. It exposes Playwright's browser automation functionalities, such as navigating pages, clicking elements, and filling forms, as structured tools that an AI can utilize. Instead of manually scripting every interaction, developers can use natural language prompts to instruct the AI to perform complex browser actions.

This is where the integration truly shines. The AI, powered by Playwright MCP, can open a browser and validate changes made to the application.

Developers can ask the AI to verify specific UI behaviors, generate automated tests based on natural language descriptions, and even suggest fixes for failing tests. Playwright's inherent capabilities, like auto-waiting for elements, web-first assertions, and detailed tracing, further enhance the reliability and debuggability of these AI-driven tests.

Cline can explore the application, suggest new test cases, and automatically generate tests, significantly reducing the manual effort in quality assurance. This rapid iteration cycle means that frontend issues can be identified and resolved much faster, leading to a more robust and polished user experience.

Real Use Case

I stumbled upon a fantastic UI component on the web and, without missing a beat, grabbed a screenshot. Then, the magic happened. I pasted that image directly into Cline.
What followed was an incredible display of AI power.
Through just a few iterative "AI loops" within Cline, the platform intelligently analysed the screenshot, understood its structure and styling, and then, almost effortlessly, translated it into functional code. After few minutes, that stylish component was not just an image on my screen, but a live, interactive part of my own application. This seamless transition from a visual idea to a working element, all powered by AI, truly felt like the future of development.

In conclusion, the sophisticated integration of VSCode, Cline, and the Playwright MCP Server is transforming the landscape of frontend development. Developers can now build, test, and refine frontend applications with unprecedented speed and accuracy, thanks to a new era of intelligent, efficient, and highly effective workflows, leading to superior web experiences for users.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Agent Flows At Scale with Google’s ADK for TypeScript

Giorgio Boa — Sat, 20 Dec 2025 22:08:47 +0000

The landscape of Artificial Intelligence is undergoing a seismic shift. We are moving rapidly beyond simple, single-purpose chatbots toward autonomous, intelligent multi-agent systems capable of complex reasoning and task orchestration.

To empower developers in this new era, Google has officially introduced the Agent Development Kit (ADK) for TypeScript. This open-source framework marks a pivotal moment for the JavaScript ecosystem, bringing a strict "code-first" philosophy to AI development.

The Code-First Revolution

For too long, building AI agents felt like an exercise in abstract prompt engineering. The ADK changes this paradigm by allowing developers to define logic, tools, and orchestration directly in TypeScript. As highlighted in Google’s December 2025 announcement, this approach enables engineers to apply standard software development best practices—such as version control, automated testing, and CI/CD integration—to their AI workflows.

The framework offers end-to-end type safety, meaning developers can build their agent backend and application frontend in a cohesive language, drastically reducing integration errors. By utilising modular components like Agents, Instructions, and Tools, the ADK transforms complex AI behaviours into clean, readable, and scalable code.

Case Study: The "Chef & Sommelier" Multi-Agent System

Here you can find the working project, you only need to add your Gemini API Key.

To demonstrate the power of the ADK, let’s explore a practical implementation: a hierarchical Chef Agent. This project uses the latest Gemini 3 model gemini-3-pro-preview model to create a culinary experience that goes beyond simple recipe generation.

The project structure is clean and modular, a hallmark of the ADK methodology:

chef-agent/
├── agent.ts (The Head Chef)
└── sommelier-agent/
    └── agent.ts (The Wine Expert)

The Hierarchical Architecture

The core of this application lies in chef-agent/agent.ts. Here, the root agent is defined as the "Chef," whose instruction is to take a single ingredient input and generate a masterpiece dish, complete with a name, description, recipe, and plating instructions.

However, the true power of the ADK is showcased in how it handles sub-agents. The Chef isn't working alone.

The code explicitly defines a subAgents array:

import { LlmAgent } from "@google/adk";
import { sommelierAgent } from "./sommelier-agent/agent";

export const rootAgent = new LlmAgent({
  name: "chef_agent",
  model: "gemini-3-pro-preview",
  description: "A chef that creates amazing food based on a single ingredient.",
  instruction: `You are a world-renowned Chef with a passion for creating culinary masterpieces.
Your specialty is taking a SINGLE INGREDIENT provided by the user and designing a complete, delicious, and amazing dish around it.

When you receive an input (which will be an ingredient):
1.  **Conceive a Dish**: Create a unique name for a dish highlighting that ingredient.
2.  **Description**: Write a mouth-watering description.
3.  **Recipe**: Provide a detailed recipe including:
    *   Ingredients list (quantities and items).
    *   Step-by-step cooking instructions.
4.  **Presentation**: Suggest how to plate the dish for maximum visual appeal.

Be enthusiastic, professional, and creative.
You also have a colleague, "sommelier_agent", who must suggest wine pairings for the dish you create.`,
  subAgents: [sommelierAgent],
});

This configuration tells the Chef agent that it has access to a colleague. When the Chef generates a recipe, it can automatically consult the sommelier_agent. defined in sommelier-agent/agent.ts. This sub-agent has a specific, narrow scope: suggesting the perfect wine pairing based on the flavour profile of the dish the Chef just created.

The sommelier_agent code:

import { LlmAgent } from "@google/adk";

export const instruction = `You are an expert Sommelier.
Your goal is to suggest the perfect wine pairing for a given dish.
When provided with a dish name or description:
1. Suggest a specific type of wine (e.g., Cabernet Sauvignon, Chardonnay).
2. Explain why it pairs well with the dish (flavor profile, acidity, etc.).
3. Recommend a specific region if applicable.`;

export const sommelierAgent = new LlmAgent({
  name: "sommelier_agent",
  model: "gemini-3-pro-preview",
  description: "A sommelier that suggests wine pairings for a given dish.",
  instruction,
});

The Developer Experience

The project leverages the @google/adk library and offers a seamless developer experience. Looking at the package.json, we see built-in scripts that use the ADK devtools:

Terminal Mode: pnpm run run:terminal allows the developer to interact with the Chef directly in the command line for rapid testing.

Web Interface: pnpm run run:web launches a local server (localhost:8000), providing a chat interface to visualize the interaction between the user, the Chef, and the hidden Sommelier sub-agent.

The Chef Agent project perfectly illustrates why the ADK for TypeScript is a game-changer. It creates a structured environment where distinct AI personalities (the Chef and the Sommelier) interact through typed contracts rather than vague prompts.

By combining the reasoning capabilities of the new Gemini 3 models with the reliability of TypeScript, Google’s ADK provides the foundation for the next generation of software—where code doesn't just execute commands, but thinks, creates, and collaborates.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Agent Development in Hours, Not Weeks: Accelerating with Gemini 3 and Google ADK

Giorgio Boa — Thu, 18 Dec 2025 18:13:04 +0000

In the rapidly evolving landscape of artificial intelligence, the ability to iterate and deploy intelligent agents with speed is no longer a luxury – it's a critical competitive advantage. Traditionally, bringing a sophisticated AI agent from concept to production could take weeks, bogged down by complex model training, intricate API integrations, and the laborious process of building robust applications around the core AI.

However, a revolutionary shift is underway, largely thanks to the potent synergy between Gemini 3's advanced capabilities and the streamlined tooling provided by the Google Agent Development Kit (ADK). This powerful combination isn't just about incremental improvements; it represents a paradigm shift, compressing development timelines from weeks of effort down to mere hours.

The Powerhouse: Gemini 3

At the heart of this acceleration lies Gemini 3, Google's next-generation multimodal AI model.

Gemini 3 is not just an incremental update; it's engineered for enhanced reasoning, complex task understanding, and superior performance across a vast array of modalities, including text, image, audio, and video.

Gemini 3 excels at understanding complex instructions and performing multi-step reasoning. This means less hand-holding and explicit programming for the agent's logic, as Gemini 3 can often infer intent and execute sophisticated workflows based on high-level prompts.

The Accelerator: Google Agent Development Kit (ADK)

While Gemini 3 provides the brain, the Google ADK provides the entire nervous system and skeletal structure, making it incredibly easy to connect that brain to the real world. The ADK is more than just a library; it's a comprehensive ecosystem designed specifically for rapid agent prototyping and deployment.

Key Features of ADK

The ADK offers a rich collection of pre-built components, templates, and example agents that demonstrate common use cases. This allows developers to start from a solid foundation rather than building everything from scratch.
ADK provides seamless, abstracted interfaces for interacting with LLMs, allowing developers to focus on the agent's behaviour rather than the intricacies of API calls.
It is designed to work hand-in-hand with Google Cloud's robust infrastructure, offering simple paths to deploy agents as scalable, production-ready services.

Amazing Developer Experience

Features like interactive playgrounds, debugging tools, and quick deployment options massively reduce the iteration cycle. Developers can test, refine, and redeploy their agents in minutes, not hours.

With ADK is easy to orchestrate complex agent behaviours, managing state, memory, and interactions with various external tools and systems. e.g. logging tools, safety security tools.

In a world where AI innovation moves at an unprecedented pace, the combination of Gemini 3 and the Google ADK isn't just a development advantage; it's the new standard for building the intelligent agents of tomorrow, today. Start building and watch your project development time drop from weeks to hours.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Thinking, Planning, Executing: Gemini 3's Agentic Core in the Antigravity Sandbox

Giorgio Boa — Thu, 18 Dec 2025 16:06:24 +0000

In the ever-accelerating landscape of artificial intelligence, the promise of true agency, where systems not only perform tasks but proactively think, plan, and execute, has long been the holy grail.

Today, we stand on the precipice of that realisation with the advent of Gemini 3’s revolutionary agentic core, particularly as its capabilities unfold within the controlled yet expansive environment of the Antigravity Sandbox.

This isn't just about faster computation; it's about fundamentally reshaping how we approach complex problems, entrusting their lifecycle management from conceptualisation to completion to an intelligent system.

At the heart of Gemini 3 lies a sophisticated architecture designed to mirror human cognitive processes, yet unbound by human limitations.

Its agentic core is not a collection of isolated functionalities, but rather an interconnected suite of modules enabling seamless transitions between ideation and action.

This integration manifests in three critical phases:
thinking, planning, and executing.

Thinking

The "thinking" phase in a Gemini 3 agent is where the magic begins. When presented with a goal or a problem within the Antigravity Sandbox, the agent doesn't immediately jump to the most obvious solution. Instead, it engages in a deep analysis of the context, drawing upon its vast knowledge base and learned patterns. This involves interpreting ambiguities, identifying underlying constraints, and even hypothesising potential causal relationships.

Planning

This detailed understanding then seamlessly transitions into the "planning" phase. This isn't just about generating a linear sequence of steps; it's about dynamic, adaptive strategy formulation. Gemini 3 agents in the Antigravity Sandbox are capable of generating intricate workflow diagrams, complete with contingencies and alternative pathways. They anticipate potential roadblocks, perhaps a database dependency that might impact downtime, or a security policy that could bottleneck deployment. Crucially, the planning phase is iterative and self-correcting.

Executing

Finally, we arrive at "execution", where the carefully crafted plans are brought to life. Within the Antigravity Sandbox, Gemini 3 agents aren't merely observers of the execution process. It leverages its ongoing monitoring capabilities to detect anomalies, analyse the deviation against its planned state, and then initiate an intelligent re-planning or recovery sequence.

We are moving beyond simply tooling intelligence, to truly partnering with it. The precipice has been crossed; the landscape of possibility is now immeasurably wider, inviting us to dream with an intelligence that doesn't just assist, but truly, profoundly, leads the way.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Antigravity for Developers: Lifting the Burden with Gemini 3 Agents

Giorgio Boa — Tue, 16 Dec 2025 09:05:57 +0000

The constant pressure to innovate and deliver faster is a familiar burden for every developer. Days are often consumed by repetitive tasks, debugging, and navigating complex workflows, leaving little room for the creative problem-solving that truly fuels progress.

What if developers could experience a form of "antigravity," liberating them from these tedious constraints? The answer might lie in Gemini 3 Agents.

These intelligent agents, powered by the cutting-edge reasoning capabilities of Gemini 3, promise to revolutionise the development landscape by automating complex, multi-step tasks.

They act as tireless assistants, capable of understanding intricate instructions and executing them with precision and efficiency. Imagine offloading tasks like code generation, bug fixing, documentation creation, and even complex refactoring to a dedicated agent. This is the potential unlocked by Gemini 3 Agents.

Automate Impossible Tasks

Unlike simple scripts that follow rigid instructions, Gemini 3 Agents can interpret natural language requests, reason about the underlying code, and dynamically adjust their strategies based on the context of the project. This level of intelligence allows them to tackle tasks that were previously impossible to automate, freeing up developers to focus on higher-level challenges.

The key to their transformative power lies in their ability to understand and adapt to the nuances of the development process.

How do Gemini 3 Agents work in practice?

Consider a scenario where a developer needs to implement a new feature. Instead of manually writing all the code, they can instruct a Gemini 3 Agent to generate the initial code structure, including necessary functions and classes, based on a brief description of the feature's requirements. The agent can then integrate this code into the existing codebase, ensuring compatibility and adherence to coding standards. Furthermore, it can even write unit tests to verify the functionality of the newly implemented feature.

The benefits extend beyond simple code generation. Gemini 3 Agents can also play a crucial role in debugging and error resolution.

By analysing error logs and code snippets, they can identify potential causes of bugs and suggest solutions. They can even automatically implement fixes, significantly reducing the time spent on tedious debugging sessions.

The advantages

Automating repetitive tasks frees up developers to focus on more complex and creative aspects of their work, leading to a significant boost in overall productivity. This streamlined workflows and automated tasks contribute to faster development cycles, allowing teams to deliver projects more quickly. By removing the burden of tedious tasks, Gemini 3 Agents can improve developer satisfaction and create a more engaging and fulfilling work environment.

The introduction of Gemini 3 Agents marks a paradigm shift in software development. It's not about replacing developers, but about augmenting their capabilities and empowering them to achieve more. As these agents become more sophisticated and integrated into the development ecosystem, the potential for unlocking unprecedented levels of productivity and innovation in the software industry is truly limitless. The future of development is here, and it's lighter than ever before.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

LLM as a Judge with Azure Foundry for Scalable Model Assessment

Giorgio Boa — Fri, 12 Dec 2025 08:02:45 +0000

The rapid advancements in large language models (LLMs) have ushered in an era of unprecedented innovation, but with it comes the critical challenge of effective model evaluation. Traditional methods often struggle with the scale and nuance required to assess the complex outputs of LLMs.

This is where LLM as a Judge emerges as a transformative technique, leveraging the power of one LLM to evaluate the outputs of another.

When combined with the flexibility and control offered by platforms like Azure Foundry, this approach becomes an invaluable tool for developers, especially during the crucial testing phase.

What is LLM as a Judge?

At its core, LLM as a Judge involves using a sophisticated LLM to act as an automated evaluator for the responses generated by other LLMs. Instead of relying solely on human annotators, who can be costly and time-consuming, a "judge" LLM is given the original prompt, the generated response, and a set of clear instructions or a rubric.

It then assesses the response based on criteria such as accuracy, relevance, coherence, tone, and safety, providing a score, a label, or even a detailed critique.

This process automates a significant portion of the evaluation workflow, offering scalability and consistency that human review often struggles to match.

The Power of Azure Foundry for LLM as a Judge

Azure Foundry significantly enhances the "LLM as a Judge" paradigm, particularly for testing and experimentation. One of its most compelling benefits is the ability to seamlessly switch between and compare different foundational models.

This flexibility is paramount when you're using an LLM as a judge because the choice of the judge model itself can heavily influence the evaluation results.

Pros of LLM as a Judge in Testing

Scalability: Evaluate thousands of responses in minutes, making large-scale testing feasible.
Consistency: Reduce the subjectivity inherent in human evaluations, ensuring more uniform assessments.
Speed: Accelerate the feedback loop, allowing for faster iteration and improvement of models.
Cost-Effectiveness: Significantly reduce the costs associated with manual review.
Benchmarking: With Azure Foundry, objectively compare the performance of different models (or different versions of the same model) under various conditions.
Fine-tuning: Provide targeted feedback that can be used for reinforcement learning from human feedback (RLHF) or other fine-tuning techniques.

Example: Comparing Two Answers for Sameness

Let's say we have a question: "What is the capital of France?" and two LLMs provide answers:

Answer 1 (Model X): "Paris is the bustling capital and largest city of France, famous for its art, fashion, gastronomy, and culture."
Answer 2 (Model Y): "The capital city of France is Paris, a major European city and a global center for art and fashion."

During testing, you want to verify if these two answers convey essentially the same factual information, even if phrased differently. You can use an LLM as a judge with a specific prompt:

Judge LLM Prompt:
You are a critical evaluator comparing two statements for factual equivalence. Your task is to determine if 'Statement A' and 'Statement B' convey the same core factual information, even if the wording differs. Rate their similarity on a scale of 1 to 5, where 1 means completely different information and 5 means essentially identical information. Explain your reasoning briefly.

Statement A: {Answer 1}
Statement B: {Answer 2}

Judge LLM Output:
Rating: 5
Reasoning: Both statements clearly identify Paris as the capital of France and mention its significance in art and fashion. While they use slightly different descriptive words, the core factual information conveyed is identical.

By running countless such comparisons through your judge LLM on Azure Foundry, you can quickly identify instances where models diverge in factual accuracy, consistency, or even subtle semantic meaning. If you then want to see if a different judge model (e.g., one specifically trained for semantic similarity) offers a different perspective, Azure Foundry makes that switch effortless.

In conclusion, LLM as a Judge, particularly when powered by the versatile capabilities of Azure Foundry, is an indispensable tool for modern AI development. It offers a scalable, consistent, and highly flexible approach to model evaluation, transforming the testing and iteration process for LLM-powered.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Gemini 3 and Antigravity Gave Me Some Free Time

Giorgio Boa — Thu, 04 Dec 2025 21:25:26 +0000

We live in strange times for developers. Until recently, our worth was often measured in hours spent deciphering cryptic documentation, fighting with dependencies, or figuring out why an API endpoint had suddenly changed its format.

Today, I received definitive proof that the paradigm has shifted.

Instead of wasting the afternoon configuring the new Google Places API, thanks to Gemini 3, I went for a relaxing walk in the park.

The Challenge: A New Feature To Implement

It all started with a seemingly simple task: integrate the new version of the Google Places API into my project. Anyone who has worked with Google Maps APIs knows that the transition from "Legacy" to "New" isn't just a version upgrade; it is a shift in philosophy.

The official documentation is vast, sure, but scattered. It talks about enabling the project on Cloud Platform, configuring billing, handling OAuth authentication (no longer just a simple API Key in all cases), and, most importantly, understanding the logic of Field Masks. With the new client library, you can’t just call an endpoint: you must specify exactly which fields you want back to optimize costs and performance.

If you mess up the mask, the API rejects you or, worse, charges you for data you don't use.

In a "classic" afternoon a few months ago, I would have opened ten browser tabs: the Quick Start guide, Stack Overflow, and maybe a few YouTube tutorials. I would have wasted an hour just setting up the environment and figuring out why the library couldn't see my credentials.

The Intervention of Gemini 3 and Antigravity

Instead of opening the documentation, I opened Antigravity, Google's new "agentic" development environment. I typed a dry, almost conversational prompt:

"I need to call the new Google Places API. Build me a client that searches for nearby places and handles Field Masks correctly."

Here is where the magic happened. I didn't just get a code snippet to copy-paste (and then debug). Gemini 3, integrated into Antigravity, acted as a true pair programmer.

Immediate Setup: It understood and suggested the commands avoiding system conflicts.
Production-Ready Code: It wrote the script using the correct library, google-maps-places (rather than the old generic googlemaps). It implemented the Field Masks logic (places.displayName, places.formattedAddress, places.priceLevel) without me having to hunt for the exact field names in the JSON schema.
The Final Touch: The initial implementation had one small problem regarding Field Masks. So I ran the program and debugged it the old-fashioned way. After a few tries, I fixed the issues.

The Result: Free Time

In less than 15 minutes, the code was running. Clean results, fast calls, zero headaches.
What was supposed to be a task taking "a solid hour plus unforeseen issues" turned into a productive coffee break.

The real revolution of tools like Gemini 3 isn't that they write code for us. It’s that they remove friction. They eliminate that frustrating phase of "reading documentation just to figure out how to do Hello World." They allow us to jump straight to business logic, to the real value we want to create.

Today, this approach changed my day, giving me some free time. Instead of staring at a screen trying to figure out the difference between "FindPlace" and "TextSearch", I took a walk in nature and felt the fresh air on my face.

The rise of tools like Gemini 3, integrated into environments like Antigravity, signifies a profound shift: from battling syntax and obscure configurations to embracing a collaborative partnership with AI. This new era promises not just efficiency, but a more human-centric development experience, where technology truly serves to free our minds, allowing us to enjoy a walk in the park instead of being chained to the terminal.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Optimize your prompts with Gemini 3 & Antigravity

Giorgio Boa — Wed, 03 Dec 2025 21:11:43 +0000

The landscape of interacting with Large Language Models (LLMs) has seen rapid evolution, moving from simple queries to sophisticated prompt engineering.

For many, particularly non-native English speakers (like me), the manual refinement of these prompts has been a significant hurdle. Crafting the perfect prompt requires not only a deep understanding of the desired output but also a nuanced command of language – a challenge that often leads to frustration and suboptimal results.

In the past, the process of optimizing an LLM prompt was a painstaking, iterative journey.

I recall spending considerable time manually constructing initial prompts, often based on trial and error.

When the LLM's output didn't meet expectations, the real work began: dissecting the failures, identifying ambiguous phrasing, and attempting to rephrase the prompt. Each refinement was a gamble, often requiring multiple attempts and significant time investment to inch closer to the desired outcome. This method, while eventually yielding results, was inherently inefficient.

Antigravity with Gemini 3

However, a revolutionary shift has emerged with the advent of "Antigravity".

Google is offering it for FREE and you can also have FREE access to Gemini 3 with its integrated "thinking" capabilities.

This development has transformed my approach to prompt engineering entirely. No longer time-consuming manual iterative process. Now, the power of an advanced LLM, equipped with sophisticated reasoning, can be leveraged directly for prompt optimization.

The new methodology is remarkably straightforward and incredibly efficient. When an LLM generates unsatisfactory results, you can now simply instruct Gemini 3, "Can you analyze the failed results and optimize the prompt?" This simple directive unleashes Gemini 3's analytical prowess. It processes the previous prompt, evaluates the undesirable outputs, and, critically, understands the underlying intent you are trying to achieve. Within a matter of minutes – a stark contrast to the hours or even days the manual method sometimes required – Gemini 3 presents an optimized prompt. This optimized prompt is often far more articulate, precise, and effective than anything I could have crafted manually in the same timeframe.

Quality And Reliability

This impacts the quality and reliability of LLM outputs. By leveraging Gemini 3 for prompt optimization, the resulting prompts are inherently more robust and less prone to misinterpretation by the target LLM.

This leads to a higher rate of successful outputs from the LLM, dramatically improving overall accuracy.

The continuous loop of analysis, optimization, and verification creates a virtuous cycle of improvement, pushing the boundaries of what is achievable with LLMs.

The integration of Gemini 3 has transformed prompt engineering from a laborious, language-dependent chore into an accelerated, intelligent process. This innovation not only streamlines workflows but also unlocks a new level of precision and efficiency in human-AI collaboration.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.

Google Antigravity: The Amazing IDE Powered by Gemini 3

Giorgio Boa — Thu, 27 Nov 2025 07:52:34 +0000

The landscape of AI-assisted development has evolved rapidly, moving from simple code completion to fully integrated "agentic" environments. The latest entrant to this competitive space is Google Antigravity, a public preview release that promises to redefine how developers interact with their IDEs.

Antigravity offers a familiar VS Code-like interface but introduces a sophisticated "Agent Manager" designed to spawn, coordinate, and test autonomous coding tasks. At the heart of this system lies a diverse selection of large language models (LLMs).

The Power of Gemini 3

The core engine driving Google Antigravity is the Gemini 3 Pro model, which is available in two distinct configurations: "High" and "Low."

This tiered approach allows developers to balance computational cost and speed against reasoning depth, depending on the complexity of the task at hand.

Perhaps the most intriguing aspect of the Gemini 3 integration is its multimodal potential. While the current usage focuses on code and image context, the implication is that future iterations could allow developers to feed video context—such as a screen recording of a bug or a feature demo—directly into the agent to drive development.

Beyond Google: A Multi-Model Approach

One of Antigravity’s most surprising features is its willingness to step outside the Google ecosystem. The platform includes access to Claude Sonnet 4.5, widely regarded as one of the top-tier models for coding tasks. This inclusion suggests that Antigravity aims to be a model-agnostic platform where the best tool can be used for the job, rather than a walled garden for Google products.
However, the model selection also includes some curiosities. The platform lists "GPTO OSS 120," described as an open-source model from OpenAI.

Planning, Fast Mode, and Autonomous Testing

The choice of model heavily influences the two primary modes of operation: "Fast Mode" and "Planning Mode." In Planning Mode, the models generate a step-by-step roadmap before writing code, allowing the user to intervene, skip steps, or provide feedback on specific images or architectural decisions.

However, the true "killer feature" powered by these models is the autonomous testing capability. Unlike standard IDEs, Antigravity uses its agents to physically interact with the browser. It simulates mouse movements, clicks buttons (like "Shop Now"), scrolls, and hovers over elements to verify UI responsiveness. This level of semantic understanding—where the model reasons through the UX flow—sets a new standard for what developers can expect from an AI pair programmer.

While Google Antigravity is still in a rate-limited public preview, its integration of Gemini 3 Pro alongside Claude Sonnet 4.5 offers a glimpse into a future where IDEs are not just text editors, but command centers for intelligent, multimodal agents.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋

Giorgio BoaFollow

Giorgio Boa is a full stack developer and the front-end ecosystem is his passion. He is also international public speaker, active in open source ecosystem, he loves learn and studies new things.