DEV Community: Rini Susan V S

Why Local AI Was the Real Winner of Google I/O 2026 (An Insider’s Take)

Rini Susan V S — Sun, 24 May 2026 07:41:13 +0000

This is a submission for the Google I/O Writing Challenge

There is nothing quite like the energy of Shoreline Amphitheatre in May. This year on May 19, sitting there surrounded by thousands of developers, I realized that the collective vibe has changed from LLMs to Agentic AI.

This was my third time attending Google I/O in person. My first year felt like an overwhelming introduction to the raw capabilities of Generative AI. Second was dominated by the excitement to plug LLMs into software and cloud. Walking into Shoreline for my third time this year, the atmosphere felt different; It was less about "wow" moments and much about "real tools to solve real problems".

The Keynote, in Brief

The two-hour keynote was packed.

Gemini 3.5 Flash launched with frontier-level intelligence at less than half the price of comparable models. Running four times faster than preceding models, it's designed to be a high-speed background worker for the complex agent logic.
Gemini Omni dropped as a multimodal "world model" that generates across video, audio, and text simultaneously, and it's already rolling out to subscribers.
Google AI Studio is coming to Android natively, allowing developers to prompt-build full applications, preview them in an embedded emulator, and cleanly export the entire codebase directly to GitHub or Android Studio.
Antigravity 2.0; this agent-first workspace enables you to spin up independent subagents to debug and patch application code inside secure terminal sandboxes with built-in credential masking.

If you look past the flashy main-stage spectacles like Intelligent Eyewear, Gemini 3.5 Flash, Omni, and Antigravity, the real sleeper hit of I/O 2026 for developers is the Google AI Edge Gallery app and its native integration with the new Gemma 4 open-weight model family.

Google AI Edge Gallery

AI Edge Gallery runs Google's open model - Gemma 4 entirely on your device with no internet connection, no API keys, and 100% data privacy. It leverages the fast prefill capabilities of the new LiteRT-LM engine to run on local CPU, GPU, and NPU hardware.

The real magic comes from the edge-optimized Gemma 4 E2B (Effective 2 Billion) and E4B (Effective 4 Billion) variants. Using a distinct per-layer embedding architecture, they keep a tiny memory footprint while pulling off fast execution speeds—clocking over 3,000 tokens per second on modern phone hardware.

That alone is interesting to developers. But what landed at I/O 2026 is what makes it genuinely exciting: MCP support, notification-triggered routines, and persistent chat history. Together they turn a model playground into something that looks a lot like a real agentic app.

MCP on Your Phone

The big one for me is Model Context Protocol (MCP) integration, available now on Android. The reasoning happens entirely on your phone. Your data doesn't have to leave the device to decide what to do with it.
Google has published example configurations and technical documentation on their GitHub repo -(https://github.com/google-ai-edge/gallery/tree/main/mcp).

Notification-Triggered Routines

Before this update, every interaction with the app was reactive. The new "Schedule Notification" skill changes that. Tell the agent "generate a daily morning calendar briefing" and it sets a local notification. Tapping the notification opens the app straight to the required tool with Gemma 4 ready to go, cutting context-switching down to zero. It depicts the shift from AI as a tool you go to, toward AI as something that comes to you on a schedule you control.

Persistent Chat History

The app now supports persistent chat history — you can close it and pick up exactly where you left off, including text, images, and audio. What makes this work is the LiteRT-LM backend's fast prefill capability: on modern phone GPUs, it can process over 3,000 tokens per second. That means even restoring a long conversation context happens almost instantly.

Why This Is the Announcement I'm Most Excited About

The gap between "this is impressive" and "this is running on my actual phone, privately, doing something useful" is enormous. AI Edge Gallery is the rare announcement that closes that gap by design. MCP reasoning, routines, persistent sessions — runs locally, without your data leaving the device. The inference doesn't hit a server. You don't need an API key or a subscription tier to access it.
For developers specifically: the MCP integration means you can wire up whatever tools you care about and let an on-device model coordinate across them. The open-source skills system means you can share what you build.

Download it on Android or iOS

The Google AI Edge Gallery is proof that privacy and zero-latency are no longer just talking points for future roadmaps — they are practical, fully functional, and sitting right on our mobile devices today.

What was your standout announcement from Google I/O 2026? Are you diving into cloud agents with Antigravity or testing local MCP skills on your device?

Tying It All Together : How Strands Agents Enhance Retail Agent Performance Analysis

Rini Susan V S — Tue, 30 Sep 2025 07:45:21 +0000

Background

Strands Agents is a simple-to-use, code-first framework for building agents. It is an open-source SDK by Amazon Web Services [AWS]. Strands comprise three key components: a language model, a system prompt, and a set of tools. Strands supports multiple agent architecture patterns, scaling from a single agent up to complex networks of agents.

Strands is not tied to a single LLM provider, and can work with models on Amazon Bedrock by default. It also supports open source models such as LlamaAPI, Ollama, OpenAI, and others. Strands supports running agents in various environments – including Amazon EC2, AWS Lambda, AWS Fargate, and Amazon Bedrock AgentCore.

Software performance testing evaluates how retail applications behave under various workloads and conditions, ensuring a reliable customer experience. This is crucial for systems such as e-commerce platforms, point-of-sale systems, and inventory management. Identifying and resolving performance bottlenecks before they impact users minimizes lost sales.

The rise of Large Language Models [LLMs] and Generative AI presents new challenges for performance testing and engineering. Unlike traditional applications, testers now deal with dynamic, context-aware AI agents that interact with different knowledge bases and tools.

The Use Case: A Retail Customer Support Agent

Preamble
Imagine a customer support agent for an e-commerce company that

Answer policy questions by searching the Knowledge Base
Check order status by calling an API through an Action Group.
Consolidate information and provide a helpful response to the customer.

In production, performance is critical, and even a 10-second delay can lead to a frustrated customer and a lost sale.

The Performance Puzzle
The total time a user waits for an answer is the sum of several processes. The Strands Agents framework provides visibility to understand each of these steps. The agent's trace usually includes:

Orchestration & Reasoning: The agent's underlying Foundation Model (FM) interprets the user's prompt and decides what to do.
Knowledge Base Retrieval: If it's a policy question, the agent queries the knowledge base.
Action Group Invocation: To check an order, the agent triggers a Lambda function that calls an internal Order Status API.
Final Response Generation: The retrieved information is passed back to the LLM, which generates the final response.

Strands Agents in Action

The Jupyter Notebook walks through the process of creating an Agent, based on the e-commerce customer support use case described earlier.

Prerequisites:

An active AWS account.
An Amazon Bedrock Agent created with:
A Knowledge Base attached
An Action Group configured to invoke a Lambda function for checking order status.
The agentId and agentAliasId of your created agent.
The boto3 library installed and configured with appropriate IAM permissions

Helper Function to Invoke the Agent
Using the Strands SDK's tool interfaces, we can build our own custom tools. Any Python function can be used as a tool by using the @tool decorator.
Create a reusable function to invoke our agent. This function will capture the agent's response and also the full trace of its internal operations, which is crucial for performance analysis.

from strands.tools import tool
@tool
def invoke_bedrock_agent(prompt: str, session_id: str):
    """
    Invokes the Bedrock agent, captures the response, and returns the full event stream.

    Args:
        prompt (str): The user's query for the agent.
        session_id (str): A unique identifier for the conversation session.

    Returns:
        list: A list of all events received from the agent's response stream.
    """
    print(f"\nUser prompt: '{prompt}'")

    events = []
    start_time = time.time()

    try:
        response = bedrock_agent_runtime_client.invoke_agent(
            agentId=AGENT_ID,
            agentAliasId=AGENT_ALIAS_ID,
            sessionId=session_id,
            inputText=prompt,
            enableTrace=True # CRITICAL: This enables the detailed trace!
        )

        event_stream = response['completion']
        for event in event_stream:
            events.append(event)

        final_response = ""

        trace_data = None
        # Extract the final response and the trace data
        for event in events:
          if 'chunk' in event:
            final_response += event['chunk']['bytes'].decode('utf-8')
          if 'trace' in event:
            trace_data = event['trace']['trace']

    except Exception as e:
        print(f"An error occurred: {e}")
        return None
    finally:
        end_time = time.time()
        print("")
        print(f"Total Latency: {end_time - start_time:.2f} seconds")

    return events

Performance Test Scenarios
Let’s run a few tests to establish a baseline for different types of queries.

Scenario A: Knowledge Base Query
This tests the agent's ability to retrieve information from the attached knowledge base. The primary latency here will be in the Retrieve step.
session_id_kb = str(uuid.uuid4()) prompt_kb = "What is the return policy for clothes?" kb_events = invoke_bedrock_agent(prompt_kb, session_id_kb)
Scenario B: Action Group Query (API Call)
This tests the agent's ability to invoke an external tool (our order status Lambda). Latency will be a combination of reasoning and the actual Lambda/API execution time.
session_id_ag = str(uuid.uuid4()) prompt_ag = "Can you check the status for order #B-98765?" ag_events = invoke_bedrock_agent(prompt_ag, session_id_ag)

Analyzing the Performance Trace
The real value comes from parsing the trace data returned in the event stream. Create a function, trace_analysis() to extract and analyze this data, and use @tool decorator.

Invoke the trace_analysis function with knowledge base events and action group events data.

def trace_analysis(kb_events)
def trace_analysis(ag_events)

Strands Agent Function

import strands from strands import Agent agent = Agent( tools=[trace_analysis,invoke_bedrock_agent] )

Strands Agent - Knowledge Base Query

Strands Agent – Lambda Function Invocation

CloudWatch Monitoring

The token count and invocation latency can also be observed in AWS Cloud Watch, under GenAI Observability section.

Performance Insights and Optimization Actions

Knowledge Base Bottleneck: If the "Knowledge Base Retrieval Time" is high, need to investigate the knowledge base settings. Are you retrieving too many chunks? Is the vector database under-provisioned?
API Bottleneck: If the "Lambda/API Call Time" is high, the performance issue lies outside of Bedrock. You need to use tools like AWS X-Ray and CloudWatch Logs to optimize the Lambda function and any downstream services it calls.
Model Latency: If "Final Response Generation Latency" is high, consider switching to a faster, more cost-effective model. Refine agent's instructions to produce more concise answers, thereby reducing the outputTokenCount.

References

Amazon Nova Canvas : opening up new canvases

Rini Susan V S — Mon, 19 May 2025 07:28:26 +0000

Background

Amazon Nova is a new generation of foundation models available on Amazon Bedrock. Nova includes four understanding models, two creative content generation models, and one speech-to-speech model. The content generation models include Amazon Nova Canvas for image generation and Amazon Nova Reel for video generation.

Amazon Nova Canvas

Amazon Nova Canvas is an image generation model that creates professional-grade images from text and image inputs. Amazon Nova Canvas is ideal for various applications such as marketing and reporting. It supports features like:

Text-to-image generation – Input a text prompt and generate an image as output.
Image editing options – inpainting, outpainting, generating variations, and automatic editing.
Color-guided content – input a list of hex color codes with a text prompt.
Background removal – identifies multiple objects in the input image and removes the background.

Nova Canvas in Amazon Bedrock Playground

It was a fun experience to try out the Nova Canvas model in the Amazon Bedrock playground. Being interested in photography, I wanted to evaluate how realistic the Nova model images were and know if the quality was similar to what Amazon claims.

Below is an image of Yosemite National Park, which I have taken near the Tunnel View point.

I tried to generate a similar image in Amazon Bedrock Playground, using the Nova Canvas model.

I was amazed to see how easily we could generate quality images using a few prompts. Yes, the experience of viewing the natural wonder in person is definitely rewarding. But time, effort, and cost factors are low in this option. The Amazon Canvas model can come in handy in case of weekly or monthly newsletters that need to have catchy cover pages or images related to a topic.

Nova Canvas in Python Notebook

Amazon Nova also provides the option for image generation using Python notebooks, apart from the Bedrock playground. One method of invoking the Amazon Nova models is via the Invoke API. Provided below is the Python code to generate the above image programmatically.

# Install libraries
!pip install boto3

# Import necessary libraries
import base64
import json
import random
import boto3
from PIL import Image
import io
import os

# Get AWS Credentials from secrets
AWS_ACCESS_KEY_ID=os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY=os.getenv('AWS_SECRET_ACCESS_KEY')
AWS_DEFAULT_REGION=os.getenv('AWS_DEFAULT_REGION')

# Create a Bedrock Runtime client
client = boto3.client(
    "bedrock-runtime",
    region_name=AWS_DEFAULT_REGION,
    aws_access_key_id=AWS_ACCESS_KEY_ID,
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY
)

# Set the model ID for Nova Canvas
model_id = "amazon.nova-canvas-v1:0"

# Define the image generation prompt
prompt = "Generate a realistic-looking image of Yosemite from the tunnel view. The picture was taken during the summer season at noon."

# Generate a random seed
seed = 12

# Format the request payload
request_body = {
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {"text": prompt},
    "imageGenerationConfig": {
        "seed": seed,
        "quality": "standard",
        "height": 1024,
        "width": 512,
        "numberOfImages": 1,
        "cfgScale": 8.0
    }
}

# Invoke the model
response = client.invoke_model(
    body=json.dumps(request_body),
    modelId=model_id,
    contentType="application/json",
    accept="application/json"
)
# Parse the response
response_body = json.loads(response["body"].read())
image_data = base64.b64decode(response_body["images"][0])

# Save the image
output_dir = "generated_images"
os.makedirs(output_dir, exist_ok=True)
output_path = os.path.join(output_dir, f"nova_canvas_image_{seed}.png")

image = Image.open(io.BytesIO(image_data))
image.save(output_path)
print(f"Image saved to: {output_path}")`

Security Guardrails in Amazon Nova

The Nova Canvas model available through Amazon Bedrock comes with integrated security guardrails. Guardrails help evaluate user inputs and model responses based on specific policies and provide safeguards to help build generative AI applications securely.

For example, if you try a non-safe prompt in Nova Canvas, the image won’t be generated, and a warning text message will be displayed as shown below.

Areas of Improvement

The following are some features of Amazon Nova Canvas model, that needs enhancement

Input text size limit [ 1024 characters]
Input image size limit [ longest side not exceeding 4096 pixels]
No 3D image generation [ currently 2D image generation]

Closing Thoughts

The Amazon Nova Canvas model is an excellent content generation model that can aid in prototyping, social media marketing, and advertising campaigns. It can be easily integrated into Generative AI applications. The security guardrails can ensure that the input prompt and the generated response don’t violate any safety policies. The foundation models are evolving rapidly, and the Amazon Nova Canvas model also has scope to improve.