Working Above the Loop: What I Learned at Capacita+ About the Reality of AI Agents

This week I attended Capacita+: Build with Gemini, an official training event by Google Cloud focused on transitioning into the agentic era. The event connected technical colleges and universities across Brazil to the main stage in São Paulo.

The event format was remarkably dynamic. Dante Olivier kicked things off as host, while technical leadership came from Mikaeri Ohana, developer and Technical Relations Lead at Google Cloud. Bringing in Lorrane Silva (Pequena Lô) was a great move to ground the discussion in everyday reality. Instead of letting the conversation get bogged down in tech jargon, she asked the questions everyday users actually care about: how does this genuinely help me, and why should I care?

The central takeaway was unmistakable: chatting with a model inside a popup window is one thing, but deploying an agentic system to handle real-world processes is an entirely different game.

Foosball with Gemma and Gemini: edge AI and real-time commentary

Before the keynote, one of the on-site interactive installations demonstrated an ingenious architectural division: a foosball table equipped with computer vision to deliver live play-by-play commentary.

The clever design decision was avoiding the trap of constantly streaming high-resolution video directly to the cloud, which would introduce heavy latency and prohibitive costs:

• At the edge (Edge with TPU): A camera captured game frames every fifteen seconds, sending them directly to a local Gemma model running on an on-device TPU. This lightweight model handled the heavy computer vision workload, tracking ball possession, shot attempts, and player movements.
• In the cloud (Gemini): Gemini received only this pre-processed, structured telemetry. Armed with this clean context, it stepped in as the live commentator, narrating plays, calculating real-time win probabilities, and even playing the role of a humorous VAR referee to disallow contentious goals.

This separation - offloading high-frequency triage to a lightweight edge model while reserving the heavy cloud model for deep reasoning - is the pattern that makes the most sense for balancing latency and operational costs.

Bot, assistant, or agent: where conversation ends and action begins

Many people label any terminal or chat window with AI as an “agent.” Mikaeri clarified the spectrum with a simple, practical definition:

“An agent is given a goal, considers the context, decides how to move forward, and takes action.”

• Mikaeri Ohana, Technical Relations Lead at Google Cloud

• Traditional chatbot: The typical retail banking bot. The one prompting you to “press 1 for account balance or press 2 to speak with an agent.” It operates on rigid if/else trees. The moment you step outside the pre-programmed script, it hits a dead end.
• AI assistant: Here enters the generative model capable of parsing context and natural language, such as Gemini or NotebookLM for research and synthesis. It summarizes documents, generates code, and answers open-ended questions effortlessly. But you remain the pilot driving every single step. You send the prompt, read the output, request an adjustment, and pick the next move.
• AI agent: This is where the operating dynamic shifts. Instead of dispatching piecemeal instructions, you assign an overarching objective. The agent evaluates the goal, surveys the available context, creates a multi-step plan, and triggers external tools to deliver completed work.

The evolution progressed through distinct milestones. First, AI learned to generate coherent text and images. Then came function calling, allowing it to invoke external APIs. Now we have systems capable of pursuing autonomous goals and self-correcting along the way:

Brain, hands, and nervous system: how the pieces fit together

To illustrate how an agentic architecture stands up, the human body analogy was one of the most effective explanations of the day:

1. The Brain (Model): The large language model (such as Gemini). It reasons, interprets instructions, and decides what actions are needed. But a brain in a jar cannot interact with the physical world. It can only converse.
2. The Hands (Tools): The integrations that allow the system to act. These fall into three primary categories:
   • Standard tools: Everyday web services, such as flight booking APIs, mapping services, or weather endpoints.
   • Custom functions: Purpose-built integrations for internal systems, like logging work hours, querying warehouse inventory, or generating proprietary reports.
   • Authorized data retrieval (RAG): Secure pathways allowing the agent to query private repositories, technical manuals, and access-controlled databases before formulating responses.
3. The Nervous System (Orchestration): The control loop coordinating the entire workflow. It ensures the brain invokes the right tools in the correct sequence and gracefully handles incomplete or unexpected responses.

Without tools, a model is merely a passive advisor. Without orchestration, tools are nothing more than isolated scripts colliding with each other.

The four-stage loop and the Toronto test

At the center of this orchestration lies an ongoing cycle driven by four verbs: perceive, think, act, and check.

To demonstrate this in practice, the speakers walked through the scenario of planning a six-month study abroad program in Toronto with a thirty-five thousand real budget cap:

• Perceive: The agent ingests travel constraints (destination, dates, strict financial ceiling, and required visa paperwork).
• Think: It breaks the high-level mission down into smaller milestones, separating flight itineraries, campus-adjacent housing, and consular application steps.
• Act: The system queries airline APIs, filters apartment listings on rental platforms, and pulls official consulate document checklists.
• Check: It totals projected expenses and evaluates whether the plan fits comfortably within the assigned budget.

The genuine utility of an agent emerges precisely when things fail during the check phase.

Imagine that the lowest available price combination for airfare and housing totals thirty-six thousand reais. A conventional script would simply throw an exception or exit with an error alerting you that the budget was exceeded.

In an agentic loop, that one-thousand-real budget overrun becomes fresh context for the subsequent iteration. The agent perceives the ceiling breach, thinks through alternative routes, acts by searching for mid-week departures or slightly further transit-connected accommodations, and re-runs the validation check until it converges on an itinerary that satisfies the constraints.

Resisting overengineering: practical criteria for when to deploy agents

One of the best takeaways from the training was the pragmatic restraint against forcing agents into every problem. When requirements are straightforward, building an agent is merely an expensive and brittle way to overcomplicate your stack.

The decision comes down to clear criteria:

• Repetitive workflows with predictable paths: Use standard deterministic automation scripts. They execute faster, never hallucinate, and cost nothing in inference tokens.
• Ad-hoc questions or document summaries: Use a standard conversational assistant. Paste the text, ask your questions, and wrap up the task in two minutes.
• Unpredictable pathways requiring dynamic adaptation and multi-system integration: This is where an agent earns its keep.

The job application workflow highlights this distinction clearly.

If you have already identified your target role and simply need to tune your resume for the job description, pasting it into Gemini in a browser tab gets it done immediately. A standard assistant handles that with ease.

On the other hand, if you want a system to monitor open openings over the next three weeks, cross-reference technical requirements against your project portfolio, and stage tailored cover letters awaiting your final approval, you are dealing with a persistent, non-linear objective. That is a task tailored for an agent.

The human above the loop: judgment remains yours

Autonomy does not mean handing over the keys to the vault and walking away. The agent operates inside the loop, handling the tedious legwork of evaluating options, reconciling data tables, and simulating scenarios. But the person remains above the loop.

The agent can research optimal flight combinations to Toronto and prepare the itinerary, but it should never charge the credit card without your final click of approval. The same principle applies to submitting a job application or executing database deletions.

This resonates with an insightful observation shared during the event by Giulia Bordignon (@spacecoding). She noted that technical syntax and code snippets can be picked up from documentation or search engines in minutes. The lasting differentiator for engineers is human perspective: our ability to observe daily workflows, pinpoint where people are losing time or running into friction, and steer these tools to resolve concrete bottlenecks.

The Google Deep Research feature offers a prime example of this dynamic. It can scour the internet and compile a structured ten-page dossier with cited sources. But unless you know how to calibrate the initial investigation and critically evaluate whether the findings hold up, the output is just digital noise.

At the conclusion of the training, I completed the hands-on lab milestones and earned the official certificate of completion issued by Google Cloud:

Official certificate of completion for Capacita+: Build with Gemini (Google Cloud).

Ultimately, the tooling moves forward, but the judgment remains ours.