The type of model, whether general-purpose, fine-tuned, or multimodal, dictates the agent's cognitive capabilities.

An agentic system ultimately curates the input context window for the Language Model.

An agentic system allows an LM to plan tool usage, execute the tool, and incorporate results into the input context window of the next LM call.

The orchestration layer uses reasoning techniques like Chain-of-Thought or ReAct to break down complex goals and decide when to think versus use a tool.

This layer is responsible for providing agents with the memory to 'remember' information.

Once deployed, agents can be accessed by users through a graphical interface or programmatically via an Agent-to-Agent (A2A) API.

This involves a chain of reasoning, like planning to use 'get_team_roster' and then 'calendar_api' to book travel.

Instead of acting immediately, the agent enters its 'Think It Through' phase to devise a multi-step plan for providing a delivery status.

The agent identifies the need to find the order in the internal database to confirm existence and retrieve details.

From order details, the agent extracts the shipping carrier's tracking number and queries the external carrier's API for live status.

Finally, the agent synthesizes the gathered information into a clear, helpful response for the user.

In its first 'Act' phase, the agent calls the find_order("12345") tool, observing a full order record with tracking number 'ZYX987'.

The orchestration layer then calls the get_shipping_status("ZYX987") tool, observing the result 'Out for Delivery'.

With all data gathered, the agent plans the final message and generates the response: 'Your order #12345 is 'Out for Delivery'!

Its strength lies in extensive training, allowing it to explain concepts and plan problem-solving deeply.

The trade-off is a complete lack of real-time awareness, being 'blind' to facts outside its training data.

This fundamental ability to interact with the world, using tools like search or APIs, is the core capability of a Level 1 agent.

Strategic planning enables proactive assistance, such as an agent reading a flight confirmation email and adding key context to a calendar.

Here, agents treat other agents as tools, exemplified by a 'Project Manager' agent delegating tasks to specialized team members.

At this level, an agent can identify gaps in its own capabilities and dynamically create new tools or even new agents to fill them.

Real-world success requires a model excelling at agentic fundamentals: superior reasoning for complex problems and reliable tool use.

You may choose more than one model, a 'team of specialists,' using models like Gemini 2.5 Pro for planning and Gemini 2.5 Flash for simpler tasks.

Natively multimodal models like Gemini live mode streamline image/audio processing, while specialized tools like Cloud Vision API or Speech-to-Text API convert data to text for language-only models.

A robust tool interface involves defining what a tool can do, invoking it, and observing the result.

Longstanding standards like the OpenAPI specification provide a structured contract describing a tool's purpose, parameters, and expected response.

Open standards like the Model Context Protocol (MCP) are popular for simpler discovery and connection to tools due to convenience.

A few models, like Gemini with native Google Search, invoke functions as part of the LM call itself.

The framework must provide precise control, enabling a hybrid approach where LM reasoning is governed by hard-coded business rules.

The framework must be built for observability, generating detailed traces and logs that expose the entire reasoning trajectory for unexpected agent behavior.

For dynamic or non-linear tasks, a 'manager' agent segments complex requests and intelligently routes sub-tasks to specialist agents, then aggregates responses.

For linear workflows, the Sequential pattern acts like a digital assembly line where one agent's output becomes the next agent's input.

This pattern creates a feedback loop, using a 'generator' agent to create content and a 'critic' agent to evaluate it against quality standards.

For high-stakes tasks, the Human-in-the-Loop (HITL) pattern is critical, creating a deliberate pause for human approval before significant agent action.

KPIs should go beyond technical correctness to include goal completion rates, user satisfaction scores, task latency, operational cost per interaction, and business goals like revenue or retention.

The LM Judge evaluates if the agent's output is correct, factually grounded, and follows instructions.

This automated evaluation, run against a golden dataset of prompts, provides a consistent measure of quality.

Creating evaluation datasets involves sampling scenarios from existing production or development interactions, covering the full breadth of use cases and unexpected ones.

Run new versions against the evaluation dataset, compare scores to existing production versions, and use A/B deployments for maximum safety.

Beyond automated evaluations, important factors include latency, cost, and task success rates, which should be compared in A/B deployments.

Traces expose the exact prompt, model's internal reasoning, chosen tool, parameters, and raw observation data.

Trace data can be collected seamlessly in platforms like Google Cloud Trace, streamlining root cause analysis by visualizing and searching traces.

Collecting and aggregating bug reports or 'thumbs down' feedback is critical to generate insights and trigger alerts for operational issues.

A2A allows any agent to publish a digital 'business card' (Agent Card), a simple JSON file advertising capabilities, network endpoint, and security credentials.

Unlike MCP for transactional requests, Agent 2 Agent communication is typically for additional problem solving.

A client agent sends a task request to a server agent, which can provide streaming updates over a long-running connection.

Digital mandates act as verifiable proof of user intent, creating a non-repudiable audit trail for every transaction.

Guard models examine the agent's proposed plan before execution, flagging potentially risky or policy-violating steps for review.

An agent needs a cryptographically verifiable identity, often using standards like SPIFFE, analogous to an employee ID badge.

Once identified, an agent can be granted specific, least-privilege permissions, like a SalesAgent having CRM access but a HRonboardingAgent being denied.

Without an agent identity construct, agents cannot work on behalf of humans with limited delegated authority.

The process requires clear definition of user accounts (OAuth), service accounts (to run code), and agent identities (to use delegated authority).

After authentication, policies constrain access to services, often done at the API governance layer with MCP and A2A services.

The next layer involves building guardrails into tools, models, and sub-agents to enforce policies.

For dynamic security, ADK provides Callbacks and Plugins; a before_tool_callback inspects parameters of a tool call before it runs.

A common plugin pattern is 'Gemini as a Judge', using a fast, inexpensive model like Gemini Flash-Lite to screen inputs and outputs for prompt injections or harmful content.

The agent itself becomes a new attack vector vulnerable to prompt injection, data poisoning, and inadvertent leakage of sensitive data.

A robust platform provides a defense-in-depth strategy, starting with protecting data from training base models and using controls like VPC Service Controls.

The strategy requires input and output filtering, acting like a firewall for prompts and responses.

The platform must offer contractual protections, like intellectual property indemnity for training data and generated output, giving enterprises legal and technical confidence.

This control plane serves two primary, interconnected functions: Runtime Policy Enforcement and Centralized Governance.

Infrastructure needs range from scale-to-zero for irregular traffic to dedicated capacity like Provisioned Throughput for LM services or 99.9% SLAs for runtimes like Cloud Run.

Without adaptability, an agent's performance degrades over time, a process called 'aging', leading to loss of utility and trust.

Dynamically reconfiguring multi-agent design patterns or using Reinforcement Learning from Human Feedback (RLHF) are active research areas.

It is not in the execution path, functioning as a standalone off-production platform with assistance from any LM model and offline tools.

It offers a simulation environment for agents to 'exercise' on new data and learn, excellent for 'trial-and-error' with many optimization pathways.

It can call advanced synthetic data generators to guide simulation to be realistic and pressure-test agents, including red-teaming and critiquing agents.

The arsenal of optimization tools is not fixed; it can adopt new tools via open protocols or learn new concepts and craft tools.

Agent Gym can connect to human domain experts for consulting on outcomes, guiding optimizations for edge-cases of 'tribal knowledge'.