<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	 xmlns:media="http://search.yahoo.com/mrss/" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:media="http://search.yahoo.com/mrss/"
>

<channel>
	<title>RPABOTS.WORLD</title>
	<atom:link href="https://rpabotsworld.com/tag/a2a-protocol/feed/" rel="self" type="application/rss+xml" />
	<link>https://rpabotsworld.com</link>
	<description>RPA, Agentic AI &amp; Intelligent Automation — Tutorials, Tools &amp; Career Guides</description>
	<lastBuildDate>Fri, 30 Oct 2026 05:07:17 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.5</generator>
	<itunes:subtitle>RPABOTS.WORLD</itunes:subtitle>
	<itunes:summary>RPA, Agentic AI &amp; Intelligent Automation — Tutorials, Tools &amp; Career Guides</itunes:summary>
	<itunes:explicit>clean</itunes:explicit>
	<item>
		<title>Top 100+ Google ADK Interview Questions and Answers for 2026</title>
		<link>https://rpabotsworld.com/google-adk-interview-questions-answers-2026/</link>
					<comments>https://rpabotsworld.com/google-adk-interview-questions-answers-2026/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Thu, 29 Oct 2026 04:40:35 +0000</pubDate>
				<category><![CDATA[Learning & Career]]></category>
		<category><![CDATA[A2A Protocol]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32520</guid>

					<description><![CDATA[110+ Google ADK interview questions with detailed answers, code snippets, and system design scenarios.]]></description>
										<content:encoded><![CDATA[
<h1 class="wp-block-heading">Top 100+ Google ADK Interview Questions and Answers for 2026</h1>



<p class="wp-block-paragraph">Google&#8217;s Agent Development Kit crossed 20,000 GitHub stars within its first year — and with ADK 2.0 reaching GA in May 2026, demand for engineers who can build, orchestrate, and deploy ADK agents is accelerating across every major cloud shop. Whether you are interviewing at a Google Cloud partner, a startup building on Gemini, or an enterprise migrating from monolithic RPA to agentic AI, the questions below cover the full surface area interviewers draw from: fundamentals, agent types, tools, state, memory, multi-agent orchestration, callbacks, deployment, the A2A protocol, and scenario-based system design. Every answer includes the code or config you would write on a whiteboard, not just the concept behind it. If you are building your first ADK agent or preparing to architect a production fleet, this is your single reference — <a href="https://rpabotsworld.com/agent-skills-explosion-open-source-repos-registries-security-2026/">the agentic AI skills landscape in 2026</a> makes it clear that framework fluency is now a hiring filter, not a nice-to-have.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 1: Core Concepts &amp; Fundamentals (Q1–Q15)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q1. What is Google ADK and why was it created?</h3>



<p class="wp-block-paragraph">The <strong>Agent Development Kit (ADK)</strong> is Google&#8217;s open-source framework — released under the Apache 2.0 license at Google Cloud Next in April 2025 — for building, debugging, and deploying AI agents. It was created to give developers a code-first, production-grade path from prototype to deployed agent, with deep integration into the Google Cloud ecosystem (Vertex AI, Cloud Run, GKE) while remaining model-agnostic through LiteLLM adapters. Google&#8217;s own Agentspace (formerly Gemini Enterprise) and Customer Engagement Suite run on ADK internally.</p>



<h3 class="wp-block-heading">Q2. What languages does ADK support?</h3>



<p class="wp-block-paragraph">ADK ships SDKs for <strong>five languages</strong>: Python (the most mature, v2.0.0 GA May 2026), TypeScript/JavaScript (v2.0.0 GA August 2026), Go (v2.0.0 GA June 2026), Java (v1.0.0 GA March 2026), and Kotlin (runs on the JVM alongside the Java SDK). Each has its own GitHub repository under the <code>google/</code> org.</p>



<h3 class="wp-block-heading">Q3. What is the difference between ADK 1.x and ADK 2.0?</h3>



<p class="wp-block-paragraph">ADK 1.x modeled agents as class hierarchies composed through workflow agents (SequentialAgent, ParallelAgent, LoopAgent). ADK 2.0 introduced a <strong>graph-based Workflow Runtime</strong> where agents, tools, and functions become nodes in a directed graph with explicit routing, retries, state management, and human-in-the-loop steps — conceptually closer to LangGraph&#8217;s approach but with ADK&#8217;s multi-language and Google Cloud integration advantages. Graph workflows are available in Python, TypeScript, and Go.</p>



<h3 class="wp-block-heading">Q4. Name the core primitives in ADK&#8217;s architecture.</h3>



<p class="wp-block-paragraph">The seven core primitives are:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Agent</strong> — the reasoning unit (LlmAgent, BaseAgent, workflow agents)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Tool</strong> — extends capabilities beyond conversation (function tools, MCP tools, OpenAPI tools, AgentTool)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Session</strong> — holds the context of a single conversation, including Events and State</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>State</strong> — key-value working memory scoped by prefix (user:, app:, temp:, unprefixed)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Event</strong> — the atomic unit of communication (user messages, agent replies, tool calls)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Memory</strong> — long-term recall across sessions, distinct from session state</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Runner</strong> — manages execution flow, orchestrates agents based on events, coordinates backend services</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q5. How does ADK relate to Gemini?</h3>



<p class="wp-block-paragraph">ADK is <strong>optimized for Gemini</strong> (supporting context caching with Gemini 2.0+, grounding with Google Search, and bidirectional audio/video streaming via the Gemini Live API) but is <strong>model-agnostic</strong>. Through <code>LiteLLM</code> adapters, you can plug in OpenAI, Anthropic Claude, Cohere, Mistral, AWS Bedrock models, Ollama for local inference, or vLLM for self-hosted serving. The <code>BaseLlm</code> interface also allows custom model integrations.</p>



<h3 class="wp-block-heading">Q6. What is the simplest ADK agent you can build?</h3>



<pre><code>from google.adk import Agent
root_agent = Agent(
    name="greeter",
    model="gemini-2.5-flash",
    instruction="You are a friendly greeter. Say hello and ask how you can help.",
)
</code></pre>



<p class="wp-block-paragraph">This minimal agent has a name, a model, and an instruction. Run it with <code>adk run .</code> in the terminal or <code>adk web</code> for the browser UI.</p>



<h3 class="wp-block-heading">Q7. How do you run and test an ADK agent locally?</h3>



<p class="wp-block-paragraph">ADK provides three local modes:</p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><code>adk run &lt;agent_path></code> — terminal chat REPL</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>adk web</code> — browser-based ADK Studio on port 8000 with Events, Traces, State, Artifacts, and Evals tabs</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>adk api_server &lt;agent_path></code> — launches a FastAPI server for programmatic testing</li></p>



<p class="wp-block-paragraph"></ul></p>



<h3 class="wp-block-heading">Q8. What is the Runner and how does it work?</h3>



<p class="wp-block-paragraph">The <code>Runner</code> is the execution engine. It receives events (user messages), routes them to the appropriate agent, processes the agent&#8217;s response (including tool calls), and yields output events. The basic pattern:</p>



<pre><code>from google.adk import Runner
from google.adk.sessions import InMemorySessionService
session_service = InMemorySessionService()
runner = Runner(agent=root_agent, app_name="my_app", session_service=session_service)
session = await session_service.create_session(app_name="my_app", user_id="user-1")
async for event in runner.run_async(user_id="user-1", session_id=session.id, new_message=content):
    print(event)
</code></pre>



<h3 class="wp-block-heading">Q9. What is the difference between an Agent and a Tool in ADK?</h3>



<p class="wp-block-paragraph">An <strong>Agent</strong> has reasoning capability — it receives context, decides what to do, and can call tools or delegate to sub-agents. A <strong>Tool</strong> is a deterministic function an agent calls to perform a specific action (query an API, run code, search the web). The agent decides <em>when</em> to call a tool based on the tool&#8217;s name and docstring; the tool executes and returns a result.</p>



<h3 class="wp-block-heading">Q10. What is ADK Studio?</h3>



<p class="wp-block-paragraph">ADK Studio is the developer UI launched with <code>adk web</code>. It displays an interactive chat interface alongside an inspection panel with tabs for: <strong>Info</strong> (agent graph visualization), <strong>Events</strong> (message/tool-call timeline), <strong>State</strong> (current session key-values), <strong>Artifacts</strong> (files and binary data), and <strong>Evals</strong> (test case management). You can save conversations as evaluation cases and replay them with different model parameters.</p>



<h3 class="wp-block-heading">Q11. How does ADK handle authentication with Google Cloud?</h3>



<p class="wp-block-paragraph">Set <code>GOOGLE_GENAI_USE_VERTEXAI=TRUE</code> to use Vertex AI (authenticates via Application Default Credentials or service account). Otherwise, set a <code>GOOGLE_API_KEY</code> environment variable for the Gemini API directly. For third-party models via LiteLLM, each provider&#8217;s API key is set through provider-specific environment variables.</p>



<h3 class="wp-block-heading">Q12. What license is ADK released under and what does that mean for enterprise use?</h3>



<p class="wp-block-paragraph">ADK is <strong>Apache 2.0</strong> — permissive, no copyleft. Enterprises can use, modify, and distribute ADK in proprietary products without disclosing source code. The only requirement is preserving the copyright notice and license text. This is the same license as Kubernetes, TensorFlow, and most Google open-source projects.</p>



<h3 class="wp-block-heading">Q13. Name three Google products that run on ADK internally.</h3>



<p class="wp-block-paragraph">Google has stated ADK powers: (1) <strong>Agentspace</strong> (formerly Gemini Enterprise) — the enterprise knowledge agent, (2) <strong>Customer Engagement Suite</strong> — contact center AI, and (3) <strong>Vertex AI Agent Gallery</strong> — the managed agent marketplace.</p>



<h3 class="wp-block-heading">Q14. What is the difference between declarative and code-defined agents?</h3>



<p class="wp-block-paragraph"><strong>Code-defined</strong>: you write Python (or TypeScript/Go/Java) and expose <code>root_agent</code> in <code>agent.py</code>. <strong>Declarative</strong>: you define agents in <code>root_agent.yaml</code> with fields like <code>agent_class: LlmAgent</code>, <code>model</code>, <code>instruction</code>, <code>sub_agents</code>, and <code>tools</code>. Declarative agents are useful for non-engineers or configuration-driven deployments where agent behavior should be editable without code changes.</p>



<h3 class="wp-block-heading">Q15. How does ADK compare to LangGraph at a high level?</h3>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Maker | <strong>Google ADK:</strong> Google | <strong>LangGraph:</strong> LangChain</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Core model | <strong>Google ADK:</strong> Agent tree + graph workflows (2.0) | <strong>LangGraph:</strong> Directed graph with checkpoints</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Languages | <strong>Google ADK:</strong> Python, TS, Go, Java, Kotlin | <strong>LangGraph:</strong> Python, JS (beta)</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Model support | <strong>Google ADK:</strong> Gemini-first, model-agnostic via LiteLLM | <strong>LangGraph:</strong> Model-agnostic</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> MCP support | <strong>Google ADK:</strong> Native McpToolset | <strong>LangGraph:</strong> Community adapters</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> A2A protocol | <strong>Google ADK:</strong> Native | <strong>LangGraph:</strong> Not native</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Deployment | <strong>Google ADK:</strong> Vertex AI Agent Engine, Cloud Run, GKE | <strong>LangGraph:</strong> LangGraph Platform, self-hosted</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Evaluation | <strong>Google ADK:</strong> Built-in CLI + evalsets | <strong>LangGraph:</strong> LangSmith</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 2: Agent Types &amp; Architecture (Q16–Q28)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q16. What is LlmAgent and when do you use it?</h3>



<p class="wp-block-paragraph"><code>LlmAgent</code> is the core agent type — a model-backed reasoning unit defined by a <code>name</code>, <code>model</code>, and <code>instruction</code>, with optional <code>tools</code>, <code>sub_agents</code>, and <code>output_key</code>. Use it whenever you need an agent that reasons about its task using a language model.</p>



<pre><code>from google.adk import LlmAgent
writer = LlmAgent(
    name="writer_agent",
    model="gemini-2.5-pro",
    instruction="Write a blog post about {topic}. Be detailed and cite sources.",
    tools=&#91;web_search],
    output_key="draft",
)
</code></pre>



<h3 class="wp-block-heading">Q17. What is BaseAgent and how do you build a custom agent?</h3>



<p class="wp-block-paragraph"><code>BaseAgent</code> is the abstract base class for custom Python orchestration agents that <strong>do not use a language model</strong> for their own logic. You subclass it and implement <code>_run_async_impl(ctx)</code>, yielding events from sub-agents:</p>



<pre><code>from google.adk import BaseAgent, InvocationContext, Event, EventActions
class ReviewLoop(BaseAgent):
    writer: LlmAgent
    critic: LlmAgent
    max_iterations: int = 3
    async def _run_async_impl(self, ctx: InvocationContext):
        for i in range(self.max_iterations):
            async for event in self.writer.run_async(ctx):
                yield event
            async for event in self.critic.run_async(ctx):
                yield event
            verdict = ctx.session.state.get("critique", "")
            if "APPROVED" in verdict:
                break
</code></pre>



<p class="wp-block-paragraph">Use BaseAgent when your orchestration logic is deterministic, conditional, or involves patterns that workflow agents cannot express (e.g., branching based on parsed critique content).</p>



<h3 class="wp-block-heading">Q18. Explain SequentialAgent with an example.</h3>



<p class="wp-block-paragraph"><code>SequentialAgent</code> runs its <code>sub_agents</code> in fixed order, one after another. Each agent can read state written by previous agents:</p>



<pre><code>from google.adk import SequentialAgent
pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=&#91;researcher, writer, editor],
)
</code></pre>



<p class="wp-block-paragraph">In this example, <code>researcher</code> writes findings to state, <code>writer</code> reads them to produce a draft, and <code>editor</code> polishes the draft. The sequence is deterministic and always runs in order.</p>



<h3 class="wp-block-heading">Q19. How does ParallelAgent work?</h3>



<p class="wp-block-paragraph"><code>ParallelAgent</code> runs all its <code>sub_agents</code> concurrently. Each child agent runs independently and writes its output to state. Use it when tasks are independent and you want to minimize latency:</p>



<pre><code>from google.adk import ParallelAgent
data_gatherer = ParallelAgent(
    name="parallel_research",
    sub_agents=&#91;market_researcher, competitor_analyst, tech_scanner],
)
</code></pre>



<p class="wp-block-paragraph">All three sub-agents run simultaneously. A downstream SequentialAgent can then aggregate their results.</p>



<h3 class="wp-block-heading">Q20. What is LoopAgent and how do you stop it?</h3>



<p class="wp-block-paragraph"><code>LoopAgent</code> repeats its <code>sub_agents</code> until a stop signal is received or <code>max_iterations</code> is reached. An agent inside the loop stops it by calling <code>tool_context.actions.escalate = True</code> from a tool:</p>



<pre><code>from google.adk import LoopAgent
def approve_draft(draft: str, tool_context) -&gt; dict:
    """Call this when the draft meets quality standards."""
    tool_context.actions.escalate = True
    tool_context.actions.skip_summarization = True
    return {"status": "approved"}
refinement_loop = LoopAgent(
    name="refinement",
    sub_agents=&#91;writer_agent, critic_agent],
    max_iterations=5,
)
</code></pre>



<h3 class="wp-block-heading">Q21. When would you use LoopAgent vs. a custom BaseAgent loop?</h3>



<p class="wp-block-paragraph">Use <strong>LoopAgent</strong> when the loop body is identical every iteration — the same agents run in the same order, and the only branching is &#8220;continue or stop.&#8221; Use a <strong>custom BaseAgent</strong> when the next iteration depends on the previous result — for example, if a factual critique triggers a research sub-agent while a stylistic critique skips it. The custom agent can inspect state between iterations and conditionally invoke different sub-agents.</p>



<h3 class="wp-block-heading">Q22. How do you compose a multi-level agent hierarchy?</h3>



<p class="wp-block-paragraph">Nest workflow agents to create complex pipelines:</p>



<pre><code>root = SequentialAgent(
    name="article_pipeline",
    sub_agents=&#91;
        theme_agent,                    # LlmAgent: picks a theme
        LoopAgent(
            name="refinement_loop",
            sub_agents=&#91;writer, critic], # iterates until approved
            max_iterations=3,
        ),
        ParallelAgent(
            name="post_processing",
            sub_agents=&#91;seo_optimizer, image_generator],  # run concurrently
        ),
    ],
)
</code></pre>



<h3 class="wp-block-heading">Q23. What is the Agent Config and why does it matter?</h3>



<p class="wp-block-paragraph">Agent Config is the declarative YAML representation of an agent&#8217;s properties — model, instruction, tools, sub_agents, output_key, and callbacks. It allows non-developers to modify agent behavior without touching Python code. In CI/CD pipelines, you can version-control YAML configs and deploy different agent configurations per environment (dev/staging/prod).</p>



<h3 class="wp-block-heading">Q24. How does instruction templating work?</h3>



<p class="wp-block-paragraph">Agent instructions support <strong>state-based templating</strong>. Placeholders like <code>{topic}</code> are replaced with the corresponding session state value before the LLM call. Use <code>{key?}</code> for optional placeholders (omitted if the key is absent):</p>



<pre><code>writer = LlmAgent(
    name="writer",
    instruction="Write a blog post about {topic}. Previous critique: {critique?}",
    output_key="draft",
)
</code></pre>



<p class="wp-block-paragraph">When <code>session.state["topic"] = "agentic AI"</code>, the instruction becomes: &#8220;Write a blog post about agentic AI. Previous critique: &#8221; (empty because <code>critique</code> is not yet in state).</p>



<h3 class="wp-block-heading">Q25. What is output_key and why is it important?</h3>



<p class="wp-block-paragraph"><code>output_key</code> automatically stores the agent&#8217;s final response into <code>session.state</code> under the specified key name. This is the primary mechanism for agents to communicate through shared state — a writer agent with <code>output_key="draft"</code> stores its output so the critic agent&#8217;s instruction can reference <code>{draft}</code>.</p>



<h3 class="wp-block-heading">Q26. How do agents communicate with each other in ADK?</h3>



<p class="wp-block-paragraph">Agents communicate through <strong>shared state</strong>, not direct calls. Each agent writes to session state (via <code>output_key</code> or tool-based state writes), and downstream agents read those values through instruction templating or tool access. This decoupled design means agents can be rearranged, replaced, or tested independently.</p>



<h3 class="wp-block-heading">Q27. What is the event loop and how does it drive agent execution?</h3>



<p class="wp-block-paragraph">The ADK event loop is a cycle between the Runner and agent logic: (1) Runner receives a user event, (2) passes it to the root agent, (3) agent processes and may call tools, (4) each action produces an Event that enters the session history, (5) Runner yields output events back to the caller. For workflow agents, the Runner traverses the agent tree, executing each sub-agent according to the workflow pattern (sequential, parallel, or loop).</p>



<h3 class="wp-block-heading">Q28. Can an ADK agent operate without an LLM?</h3>



<p class="wp-block-paragraph">Yes. A <code>BaseAgent</code> subclass contains pure Python logic — no model call required. Workflow agents (SequentialAgent, ParallelAgent, LoopAgent) are also model-free orchestrators. Only <code>LlmAgent</code> requires a model. This means you can mix deterministic automation steps with LLM-powered reasoning in the same pipeline.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 3: Tools System (Q29–Q42)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q29. What types of tools does ADK support?</h3>



<p class="wp-block-paragraph">ADK supports six tool categories:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Function tools</strong> — any Python function with type annotations and a docstring</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Built-in tools</strong> — <code>google_search</code>, <code>code_execution</code>, <code>vertex_ai_search</code></li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>MCP tools</strong> — connect to any MCP server via <code>McpToolset</code> (stdio and Streamable HTTP)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>OpenAPI tools</strong> — auto-generated from an OpenAPI spec</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>AgentTool</strong> — wraps another agent as a callable tool</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>LongRunningFunctionTool</strong> — for async operations that pause the session until completion</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q30. How do you create a function tool?</h3>



<p class="wp-block-paragraph">Any Python function becomes a tool. ADK generates the OpenAPI schema from the docstring and type annotations:</p>



<pre><code>def get_weather(city: str) -&gt; dict:
    """Get the current weather for a city.
    Args:
        city: The name of the city to check weather for.
    Returns:
        A dictionary with temperature and conditions.
    """
    # Implementation here
    return {"status": "success", "temperature": 72, "conditions": "sunny"}
agent = LlmAgent(
    name="weather_bot",
    model="gemini-2.5-flash",
    instruction="Help users check the weather.",
    tools=&#91;get_weather],
)
</code></pre>



<p class="wp-block-paragraph">The model decides when to call the tool based on its <strong>name and docstring</strong> — write them clearly.</p>



<h3 class="wp-block-heading">Q31. What is ToolContext and what can you do with it?</h3>



<p class="wp-block-paragraph"><code>ToolContext</code> (or <code>Context</code> in ADK 2.0) is injected by ADK into any tool function that declares it as a parameter. It provides access to:</p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><code>tool_context.state</code> — read/write session state</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>tool_context.actions.escalate</code> — signal a LoopAgent to stop</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>tool_context.actions.skip_summarization</code> — skip the model&#8217;s summary of tool output</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>tool_context.actions.transfer_to_agent</code> — transfer control to another agent</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>tool_context.request_confirmation()</code> — pause for human approval</li></p>



<p class="wp-block-paragraph"></ul></p>



<h3 class="wp-block-heading">Q32. How does AgentTool differ from sub_agents delegation?</h3>



<p class="wp-block-paragraph"><strong>AgentTool</strong> wraps an agent as a tool — the calling agent sends a request, receives a result, and <strong>keeps control</strong>. With <strong>sub_agents delegation</strong> (via <code>transfer_to_agent</code>), control <strong>transfers</strong> to the target agent and does not return to the caller. Use AgentTool when the parent agent needs to process the sub-agent&#8217;s result; use delegation when the sub-agent should take over completely.</p>



<pre><code>from google.adk import AgentTool
research_tool = AgentTool(agent=research_agent)
writer = LlmAgent(
    name="writer",
    instruction="Write an article. Use research_agent for facts when needed.",
    tools=&#91;research_tool],
    output_key="draft",
)
</code></pre>



<h3 class="wp-block-heading">Q33. How do you connect an MCP server as a tool source?</h3>



<p class="wp-block-paragraph">ADK&#8217;s <code>McpToolset</code> connects to any MCP server, exposing its tools to your agent:</p>



<pre><code>from google.adk.tools.mcp import McpToolset
# Stdio-based MCP server
mcp_tools = McpToolset(
    command="npx",
    args=&#91;"-y", "@anthropic/mcp-server-filesystem", "/data"],
)
# Streamable HTTP MCP server
mcp_tools = McpToolset(url="https://mcp.example.com/mcp")
agent = LlmAgent(
    name="file_agent",
    tools=&#91;mcp_tools],
)
</code></pre>



<h3 class="wp-block-heading">Q34. What are built-in tools and when should you use them?</h3>



<p class="wp-block-paragraph">Built-in tools are pre-packaged capabilities:</p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><code>google_search</code> — grounds responses with live web search results via Google Search</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>code_execution</code> — lets the agent generate and run Python code in a sandboxed environment</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>vertex_ai_search</code> — searches enterprise data indexed in Vertex AI Search</li></p>



<p class="wp-block-paragraph"></ul></p>



<p class="wp-block-paragraph">Use them when you need grounding (search), computation (code execution), or enterprise data retrieval without building custom API integrations.</p>



<h3 class="wp-block-heading">Q35. What is LongRunningFunctionTool?</h3>



<p class="wp-block-paragraph"><code>LongRunningFunctionTool</code> wraps an asynchronous operation that may take minutes or hours — human approvals, external API callbacks, or batch jobs. It pauses the session and resumes when the operation completes. This is the primary mechanism for <strong>human-in-the-loop authorization flows</strong> in production.</p>



<h3 class="wp-block-heading">Q36. How does the model decide which tool to call?</h3>



<p class="wp-block-paragraph">The model selects tools based on <strong>name and docstring matching</strong>. ADK auto-generates an OpenAPI schema from the function&#8217;s type annotations, name, and docstring, then passes it to the model as available functions. Clear, specific docstrings are critical — a vague docstring leads to incorrect tool selection. The instruction &#8220;Call this when the draft is good enough to publish&#8221; in a tool&#8217;s docstring acts as the governing rule.</p>



<h3 class="wp-block-heading">Q37. How do you handle tool authentication in ADK?</h3>



<p class="wp-block-paragraph">ADK provides an authentication framework for tools that access external services. For MCP tools, you can configure OAuth flows where each user&#8217;s permissions are respected. For custom function tools, you handle authentication in the function body — reading credentials from state, environment variables, or a secrets manager. ADK&#8217;s tool authentication docs cover OAuth, API key, and service account patterns.</p>



<h3 class="wp-block-heading">Q38. What are tool limitations in ADK?</h3>



<p class="wp-block-paragraph">Key limitations to know: (1) the <code>output_schema</code> parameter on an agent blocks tool use and agent transfers on the same agent — use instruction-based parsing instead; (2) tool call frequency depends on the model&#8217;s judgment, which can be inconsistent; (3) complex nested return types may not be perfectly represented in the auto-generated schema; (4) MCP tools add network latency per call.</p>



<h3 class="wp-block-heading">Q39. How do you test tools in isolation?</h3>



<p class="wp-block-paragraph">Call the function directly in a unit test, passing a mock <code>ToolContext</code>. For integration tests, use <code>adk eval</code> with evalsets that include expected tool trajectories:</p>



<pre><code># Unit test
def test_get_weather():
    result = get_weather("London")
    assert result&#91;"status"] == "success"
    assert "temperature" in result
# Eval-based test (evalset.json)
# Verifies the agent calls get_weather with city="London"
# and produces a response containing the temperature
</code></pre>



<h3 class="wp-block-heading">Q40. Can you use LangChain or CrewAI tools inside ADK?</h3>



<p class="wp-block-paragraph">Yes. ADK provides tool wrappers for LangChain tools, LlamaIndex tools, and CrewAI tools, allowing you to reuse existing tool ecosystems without rewriting them. This is part of ADK&#8217;s interoperability design — you are not locked into one framework&#8217;s tool format.</p>



<h3 class="wp-block-heading">Q41. How do you create an OpenAPI tool?</h3>



<p class="wp-block-paragraph">Point ADK at an OpenAPI specification, and it auto-generates callable tools for each endpoint:</p>



<pre><code>from google.adk.tools.openapi import OpenAPIToolset
api_tools = OpenAPIToolset(spec_url="https://api.example.com/openapi.json")
agent = LlmAgent(
    name="api_agent",
    tools=&#91;api_tools],
)
</code></pre>



<p class="wp-block-paragraph">Each endpoint becomes a tool whose parameters match the spec&#8217;s request schema.</p>



<h3 class="wp-block-heading">Q42. What is skip_summarization and when should you use it?</h3>



<p class="wp-block-paragraph">When a tool returns a result, ADK normally makes an additional LLM call to summarize the tool&#8217;s output for the user. Setting <code>tool_context.actions.skip_summarization = True</code> bypasses this extra call. Use it for tools whose output is already user-friendly (e.g., a formatted response) or tools that only modify state without producing user-visible output (e.g., the <code>escalate</code> tool in a loop).</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 4: State Management &amp; Sessions (Q43–Q55)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q43. What are the four state prefixes and their scopes?</h3>



<p class="wp-block-paragraph"><strong>Prefix:</strong> <code>user:</code> | <strong>Scope:</strong> Per-user | <strong>Lifecycle:</strong> Persists across sessions | <strong>Use Case:</strong> User preferences, profile metadata</p>



<p class="wp-block-paragraph"><strong>Prefix:</strong> <code>app:</code> | <strong>Scope:</strong> App-wide | <strong>Lifecycle:</strong> Shared across users | <strong>Use Case:</strong> Global configuration, feature flags</p>



<p class="wp-block-paragraph"><strong>Prefix:</strong> (none) | <strong>Scope:</strong> Session | <strong>Lifecycle:</strong> Current session only | <strong>Use Case:</strong> Conversation continuity, task progress</p>



<p class="wp-block-paragraph"><strong>Prefix:</strong> <code>temp:</code> | <strong>Scope:</strong> Invocation | <strong>Lifecycle:</strong> Single model call | <strong>Use Case:</strong> Scratch data, intermediate calculations</p>



<h3 class="wp-block-heading">Q44. How do you read and write session state?</h3>



<p class="wp-block-paragraph">Write directly via assignment; read through instruction templates or tool access:</p>



<pre><code># Writing state (in a tool or setup code)
session.state&#91;"topic"] = "agentic AI"
session.state&#91;"user:preferred_language"] = "Python"
session.state&#91;"temp:scratch"] = {"step": 1}
# Reading via instruction template
instruction = "Write about {topic} in {user:preferred_language?}"
# Reading in a tool
def my_tool(query: str, tool_context) -&gt; dict:
    topic = tool_context.state.get("topic", "general")
    return {"result": f"Searching for {topic}: {query}"}
</code></pre>



<h3 class="wp-block-heading">Q45. What is the difference between State and History?</h3>



<p class="wp-block-paragraph"><strong>State</strong> is a curated key-value store holding only the values needed to drive the workflow — task progress, flags, preferences, and scratch data. <strong>History</strong> is the complete transcript of all Events (messages, tool calls, agent outputs). State is concise and structured; history is comprehensive and chronological. An interviewer wants to hear that state is &#8220;working memory&#8221; while history is the &#8220;audit trail.&#8221;</p>



<h3 class="wp-block-heading">Q46. What is a Session in ADK?</h3>



<p class="wp-block-paragraph">A Session is the top-level container for a single conversation. It holds: (1) the <strong>session ID</strong>, (2) the <strong>user ID</strong>, (3) the <strong>event history</strong> (ordered list of Events), and (4) the <strong>state</strong> (key-value working memory). Sessions are managed by a <code>SessionService</code> — <code>InMemorySessionService</code> for development, database-backed services for production.</p>



<h3 class="wp-block-heading">Q47. What session backends does ADK support?</h3>



<p class="wp-block-paragraph">ADK supports multiple async session providers:</p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><code>memory://</code> — in-memory, development only</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>sqlite://</code> — SQLite for local persistence</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>PostgreSQL</strong> via <code>asyncpg</code> — production-grade</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Vertex AI Agent Engine</strong> — managed sessions with auto-scaling</li></p>



<p class="wp-block-paragraph"></ul></p>



<p class="wp-block-paragraph">The session interface is pluggable — swap backends without changing agent code.</p>



<h3 class="wp-block-heading">Q48. How do you persist state across sessions using the user: prefix?</h3>



<p class="wp-block-paragraph">Values stored with the <code>user:</code> prefix persist across sessions for that user. Set them in a tool or during session initialization:</p>



<pre><code>def save_preference(preference: str, value: str, tool_context) -&gt; dict:
    """Save a user preference that persists across conversations."""
    tool_context.state&#91;f"user:{preference}"] = value
    return {"status": "saved", "key": preference, "value": value}
</code></pre>



<p class="wp-block-paragraph">The next time this user starts a new session, <code>session.state["user:preference"]</code> is already populated.</p>



<h3 class="wp-block-heading">Q49. What are Events and why are they important?</h3>



<p class="wp-block-paragraph">Events are the atomic unit of communication in ADK. Every action — user message, agent reply, tool call, tool result, state change — is an Event in the session history. Events enable: (1) <strong>replay and debugging</strong> (recreate any point in the conversation), (2) <strong>observability</strong> (trace exactly what happened), (3) <strong>evaluation</strong> (compare actual trajectories against expected ones).</p>



<h3 class="wp-block-heading">Q50. How do you emit state changes through Events?</h3>



<p class="wp-block-paragraph">For production workflows needing deterministic state updates with full audit trail, emit state changes explicitly through Events:</p>



<pre><code>from google.adk import Event, EventActions
event = Event(
    author="review_loop",
    actions=EventActions(state_delta={"iteration": 2, "status": "reviewing"}),
)
yield event
</code></pre>



<p class="wp-block-paragraph">This ensures every state change appears in the event history and can be replayed or audited.</p>



<h3 class="wp-block-heading">Q51. What is context compression and why does ADK need it?</h3>



<p class="wp-block-paragraph">Long conversations accumulate many events, which can exceed the model&#8217;s context window. ADK&#8217;s <strong>context compression</strong> (also called compaction) shortens the history while preserving essential information. ADK also supports <strong>model context caching</strong> with Gemini 2.0+ to reduce redundant processing of repeated context.</p>



<h3 class="wp-block-heading">Q52. How do you manage state isolation between agents?</h3>



<p class="wp-block-paragraph">In ADK, all agents within a session share the same state dictionary. Isolation is achieved through <strong>naming conventions</strong>: use the agent name as a prefix (e.g., <code>writer:draft</code>, <code>critic:feedback</code>) or use <code>output_key</code> which automatically namespaces the output. For strict isolation, use <code>temp:</code> prefix for data that should not leak between invocations.</p>



<h3 class="wp-block-heading">Q53. How does session rewind work?</h3>



<p class="wp-block-paragraph">ADK supports session rewind — rolling back the session to a previous event, effectively undoing everything after that point. This is useful for: (1) recovering from bad agent decisions, (2) implementing &#8220;undo&#8221; in user-facing applications, (3) branching conversations for A/B testing different agent strategies.</p>



<h3 class="wp-block-heading">Q54. What is session migration?</h3>



<p class="wp-block-paragraph">Session migration moves a session between backends — for example, from <code>InMemorySessionService</code> during development to PostgreSQL in production, or between regions for latency optimization. ADK&#8217;s pluggable session interface makes this possible without changing agent code.</p>



<h3 class="wp-block-heading">Q55. Best practices for state management in production?</h3>



<p class="wp-block-paragraph">Key best practices:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Keep state minimal</strong> — store only values needed to drive the workflow</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Use prefixes consistently</strong> — <code>user:</code> for persistence, <code>temp:</code> for scratch</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Avoid storing sensitive data</strong> in long-lived state fields</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Use <code>output_key</code></strong> for agent-to-agent communication instead of manual state writes</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Emit state deltas via Events</strong> in production for auditability</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Start small and expand</strong> — add state keys only when needed</li></p>



<p class="wp-block-paragraph"></ol></p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 5: Memory &amp; Artifacts (Q56–Q65)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q56. What is the difference between State and Memory?</h3>



<p class="wp-block-paragraph"><strong>State</strong> is session-scoped working memory — it lives and dies with the conversation (except <code>user:</code> and <code>app:</code> prefixed keys). <strong>Memory</strong> is long-term recall that persists across sessions, enabling agents to remember user interactions, decisions, and context from previous conversations. State is a key-value store; memory is a searchable knowledge base.</p>



<h3 class="wp-block-heading">Q57. How do you store memories in ADK?</h3>



<p class="wp-block-paragraph">Use a callback to archive the current session&#8217;s state and history into memory at the end of a conversation:</p>



<pre><code>async def archive_run(callback_context):
    """After-agent callback that saves session to memory."""
    await callback_context.add_session_to_memory()
    return None
agent.after_agent_callback = archive_run
</code></pre>



<h3 class="wp-block-heading">Q58. How do you retrieve memories?</h3>



<p class="wp-block-paragraph">ADK provides a <code>load_memory</code> built-in tool that lets agents search past sessions:</p>



<pre><code>agent = LlmAgent(
    name="assistant",
    instruction="Help the user. Use load_memory to recall past conversations when relevant.",
    tools=&#91;load_memory],
)
</code></pre>



<p class="wp-block-paragraph">The agent can then query memory naturally: &#8220;What did we discuss about the migration project last week?&#8221;</p>



<h3 class="wp-block-heading">Q59. What memory backends does ADK support?</h3>



<p class="wp-block-paragraph">Two backends:</p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><code>InMemoryMemoryService</code> — local development, no persistence</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Vertex AI Memory Bank</strong> — production-grade, managed by Google Cloud, with vector search and semantic retrieval</li></p>



<p class="wp-block-paragraph"></ul></p>



<h3 class="wp-block-heading">Q60. What are Artifacts in ADK?</h3>



<p class="wp-block-paragraph">Artifacts are the system for saving, loading, and versioning <strong>files and binary data</strong> (images, PDFs, generated documents, code files) within a session. They are managed through an <code>ArtifactService</code> and visible in ADK Studio&#8217;s Artifacts tab. Use artifacts when your agent generates or processes files that need to be stored alongside the conversation.</p>



<h3 class="wp-block-heading">Q61. How do Artifacts differ from State?</h3>



<p class="wp-block-paragraph">State holds small key-value pairs for workflow logic. Artifacts hold larger binary or file data — a generated report, an uploaded image, a code file. State is accessed by key; artifacts are versioned files. You would not store a 50KB PDF in state, but you would store it as an artifact.</p>



<h3 class="wp-block-heading">Q62. When should you use Memory vs. State vs. Artifacts?</h3>



<p class="wp-block-paragraph"><strong>Need:</strong> Pass data between agents in one session | <strong>Use:</strong> State (unprefixed) | <strong>Example:</strong> <code>output_key="draft"</code></p>



<p class="wp-block-paragraph"><strong>Need:</strong> Persist user preferences across sessions | <strong>Use:</strong> State (<code>user:</code> prefix) | <strong>Example:</strong> <code>user:timezone = "EST"</code></p>



<p class="wp-block-paragraph"><strong>Need:</strong> Remember past conversations | <strong>Use:</strong> Memory | <strong>Example:</strong> <code>load_memory</code> tool</p>



<p class="wp-block-paragraph"><strong>Need:</strong> Store generated files | <strong>Use:</strong> Artifacts | <strong>Example:</strong> PDF report, generated image</p>



<p class="wp-block-paragraph"><strong>Need:</strong> Scratch data for one model call | <strong>Use:</strong> State (<code>temp:</code> prefix) | <strong>Example:</strong> <code>temp:search_results</code></p>



<h3 class="wp-block-heading">Q63. How does Vertex AI Memory Bank work under the hood?</h3>



<p class="wp-block-paragraph">Vertex AI Memory Bank stores session transcripts as vector embeddings, enabling semantic search across past conversations. When an agent calls <code>load_memory</code>, the query is embedded and matched against stored sessions using vector similarity. This allows retrieval like &#8220;find the conversation where we discussed the database migration&#8221; without exact keyword matching.</p>



<h3 class="wp-block-heading">Q64. Can agents share memory across different applications?</h3>



<p class="wp-block-paragraph">Memory is scoped by <code>app_name</code> in the Runner configuration. Two agents in the same app share memory. To share across apps, you would use a shared memory service or implement cross-app memory retrieval through custom tools.</p>



<h3 class="wp-block-heading">Q65. How do you implement a &#8220;forget me&#8221; feature using ADK&#8217;s memory?</h3>



<p class="wp-block-paragraph">Implement a tool that deletes user-specific memories from the memory service, or use the <code>user:</code> state prefix to clear persisted preferences. For GDPR compliance, combine both: clear <code>user:</code> state keys and purge memory entries associated with the user ID from the memory backend.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 6: Multi-Agent Orchestration (Q66–Q78)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q66. What are the three orchestration paradigms in ADK 2.0?</h3>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Graph-based</strong> — fixed processes defined as nodes and edges in a directed graph (new in 2.0)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Dynamic</strong> — control flow written with native language constructs (if/else, loops) in custom BaseAgent code</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Collaborative</strong> — a coordinator agent uses LLM reasoning to delegate to bounded sub-agents</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q67. How does dynamic delegation work?</h3>



<p class="wp-block-paragraph">A coordinator agent&#8217;s LLM reads the user request, evaluates sub-agent descriptions, and routes to the best match using <code>transfer_to_agent</code>:</p>



<pre><code>def route_to_specialist(topic: str, tool_context) -&gt; dict:
    """Route to the appropriate specialist agent."""
    tool_context.state&#91;"topic"] = topic
    tool_context.actions.transfer_to_agent = "specialist_agent"
    return {"route": "specialist"}
coordinator = LlmAgent(
    name="coordinator",
    instruction="Analyze the request and route to the right specialist.",
    tools=&#91;route_to_specialist],
    sub_agents=&#91;billing_agent, tech_support_agent, sales_agent],
)
</code></pre>



<p class="wp-block-paragraph">Control moves to the selected sub-agent and does not return to the coordinator.</p>



<h3 class="wp-block-heading">Q68. How do you implement human-in-the-loop in ADK?</h3>



<p class="wp-block-paragraph">ADK&#8217;s HITL uses a two-phase tool pattern with <code>request_confirmation</code>:</p>



<pre><code>def confirm_action(action: str, tool_context) -&gt; dict:
    """Execute an action after human approval."""
    confirmation = tool_context.tool_confirmation
    if confirmation is None:
        # Phase 1: request human approval
        tool_context.request_confirmation(
            hint="Please approve this action.",
            payload={"action": action, "risk_level": "high"},
        )
        return {"status": "awaiting_approval"}
    # Phase 2: human has responded
    if confirmation.payload.get("approved"):
        return {"status": "approved", "action": action}
    return {"status": "rejected"}
</code></pre>



<p class="wp-block-paragraph">The run pauses after Phase 1. When the human responds, ADK reruns the tool with <code>tool_confirmation</code> populated.</p>



<h3 class="wp-block-heading">Q69. What is the A2A protocol and how does ADK support it?</h3>



<p class="wp-block-paragraph">The <strong>Agent2Agent (A2A) protocol</strong> is Google&#8217;s open standard for agent-to-agent communication across different frameworks. ADK provides native A2A support: agents can expose themselves as A2A endpoints with auto-generated Agent Cards, and they can consume A2A agents from other frameworks (LangGraph, CrewAI, etc.). The protocol launched with 50+ partners and is backed by 150+ organizations through the Linux Foundation. ADK supports A2A in Python, Go, Java, and Kotlin.</p>



<h3 class="wp-block-heading">Q70. What is an Agent Card?</h3>



<p class="wp-block-paragraph">An Agent Card is a machine-readable descriptor that advertises an agent&#8217;s capabilities, accepted inputs, outputs, and connection details — think of it as an OpenAPI spec for agents. ADK auto-generates Agent Cards from your agent definitions. Other A2A-compatible frameworks can discover and call your agent using its card.</p>



<h3 class="wp-block-heading">Q71. How does ADK handle agent-to-agent communication?</h3>



<p class="wp-block-paragraph">Two mechanisms:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Within an ADK application</strong>: agents communicate through shared state and the <code>transfer_to_agent</code> / <code>AgentTool</code> patterns</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Across frameworks/services</strong>: the A2A protocol enables inter-framework communication — an ADK agent can call a LangGraph agent (or vice versa) using standardized A2A endpoints</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q72. Design a customer support system with tiered escalation using ADK.</h3>



<pre><code># Tier 1: FAQ bot
faq_agent = LlmAgent(name="faq_bot", instruction="Answer common questions from the knowledge base.", tools=&#91;kb_search])
# Tier 2: Technical specialist
tech_agent = LlmAgent(name="tech_support", instruction="Handle technical troubleshooting.", tools=&#91;log_analyzer, remote_diag])
# Tier 3: Human escalation
def escalate_to_human(issue: str, tool_context) -&gt; dict:
    tool_context.request_confirmation(hint="Human agent needed", payload={"issue": issue})
    return {"status": "escalated"}
# Coordinator
coordinator = LlmAgent(
    name="support_coordinator",
    instruction="Route based on complexity. Simple questions → faq_bot. Technical → tech_support. Unresolvable → escalate.",
    tools=&#91;escalate_to_human],
    sub_agents=&#91;faq_agent, tech_agent],
)
</code></pre>



<h3 class="wp-block-heading">Q73. How do you build a plan-and-execute pattern in ADK?</h3>



<p class="wp-block-paragraph">Use a SequentialAgent chaining a planner and executor:</p>



<pre><code>planner = LlmAgent(
    name="planner",
    model="gemini-2.5-pro",   # stronger model for planning
    instruction="Break the task into numbered steps. Output as JSON array.",
    output_key="plan",
)
executor = LlmAgent(
    name="executor",
    model="gemini-2.5-flash",  # faster model for execution
    instruction="Execute each step in {plan}. Report results.",
    tools=&#91;web_search, code_execution],
    output_key="results",
)
pipeline = SequentialAgent(name="plan_execute", sub_agents=&#91;planner, executor])
</code></pre>



<h3 class="wp-block-heading">Q74. What is the reflexion loop pattern?</h3>



<p class="wp-block-paragraph">A <code>LoopAgent</code> wrapping a draft agent and a critic agent. The critic scores each iteration; the loop stops when the score exceeds a threshold or <code>max_iterations</code> is reached:</p>



<pre><code>draft_agent = LlmAgent(name="drafter", instruction="Write a response to {query}. Address: {critique?}", output_key="draft")
critic_agent = LlmAgent(name="critic", instruction="Score the draft 1-10. If score &gt;= 8, call approve_tool. Else provide critique.", tools=&#91;approve_tool], output_key="critique")
reflexion = LoopAgent(name="reflexion", sub_agents=&#91;draft_agent, critic_agent], max_iterations=5)
</code></pre>



<h3 class="wp-block-heading">Q75. How do you implement a supervisor pattern in ADK?</h3>



<p class="wp-block-paragraph">The supervisor is a coordinator LlmAgent with sub_agents. Unlike delegation (which transfers control), the supervisor uses <code>AgentTool</code> to call workers and retain control, making decisions between each worker&#8217;s output:</p>



<pre><code>supervisor = LlmAgent(
    name="supervisor",
    instruction="Coordinate the team. Use research_tool for facts, writer_tool for drafts, reviewer_tool for quality checks.",
    tools=&#91;AgentTool(agent=researcher), AgentTool(agent=writer), AgentTool(agent=reviewer)],
)
</code></pre>



<h3 class="wp-block-heading">Q76. How does ADK&#8217;s MCP support enable interoperability?</h3>



<p class="wp-block-paragraph">ADK&#8217;s <code>McpToolset</code> connects to any MCP-compliant server — this means your ADK agent can use tools from <a href="https://rpabotsworld.com/atlassian-rovo-mcp-agentic-multiplayer-protocol-guide/">any MCP ecosystem</a>, including filesystem access, database queries, Slack, GitHub, and hundreds of community servers. Combined with A2A for agent-to-agent calls, ADK agents can participate in heterogeneous multi-framework systems.</p>



<h3 class="wp-block-heading">Q77. What is ambient mode?</h3>



<p class="wp-block-paragraph">Ambient agents respond to <strong>external events</strong> — Cloud Pub/Sub messages, Eventarc triggers, or scheduled tasks — rather than user conversations. An ambient agent might monitor a data pipeline and autonomously fix errors, or process incoming webhook events. Deploy with <code>adk api_server</code> or the Vertex AI Agent Runtime.</p>



<h3 class="wp-block-heading">Q78. How do you handle failures in a multi-agent pipeline?</h3>



<p class="wp-block-paragraph">ADK 2.0&#8217;s graph workflows support <code>RetryConfig</code> with exception-aware automatic retries. For deterministic pipelines, wrap risky steps in a try/except within a BaseAgent, log the failure as an Event, and either retry, skip, or escalate. For LoopAgent, set <code>max_iterations</code> as a circuit breaker. Always emit state deltas for each failure so the event history captures the full recovery path.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 7: Callbacks &amp; Plugins (Q79–Q88)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q79. What are callbacks in ADK?</h3>



<p class="wp-block-paragraph">Callbacks are custom functions that run at specific points in the agent lifecycle — before or after a model call, before or after a tool call, or before or after an agent runs. Unlike tools (which the model chooses to call), callbacks are <strong>always executed</strong> at their registered point. They are used for logging, validation, state manipulation, and behavior modification.</p>



<h3 class="wp-block-heading">Q80. What callback types does ADK support?</h3>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><code>before_model_callback</code> — runs before the LLM is called; can modify the prompt or short-circuit</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>after_model_callback</code> — runs after the LLM responds; can inspect or modify the response</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>before_tool_callback</code> — runs before a tool executes; can block or modify tool inputs</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>after_tool_callback</code> — runs after a tool returns; can modify tool output</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>before_agent_callback</code> — runs before an agent starts processing</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><code>after_agent_callback</code> — runs after an agent completes</li></p>



<p class="wp-block-paragraph"></ul></p>



<h3 class="wp-block-heading">Q81. How do you implement a logging callback?</h3>



<pre><code>def log_model_response(callback_context, llm_response):
    """After-model callback that logs response metrics."""
    text = str(llm_response)
    word_count = len(text.split())
    callback_context.state&#91;"temp:last_word_count"] = word_count
    print(f"Model produced {word_count} words")
    return None  # None = observe only, don't modify
writer.after_model_callback = log_model_response
</code></pre>



<p class="wp-block-paragraph">Returning <code>None</code> means observe only. Returning a value <strong>replaces</strong> the original response.</p>



<h3 class="wp-block-heading">Q82. How can a callback modify agent behavior?</h3>



<p class="wp-block-paragraph">A <code>before_model_callback</code> can return a custom response, short-circuiting the LLM call entirely:</p>



<pre><code>def content_filter(callback_context, llm_request):
    """Block requests containing prohibited topics."""
    prompt_text = str(llm_request)
    if "prohibited_topic" in prompt_text.lower():
        return "I cannot help with that topic. Please ask something else."
    return None  # proceed normally
</code></pre>



<h3 class="wp-block-heading">Q83. What are Plugins and how do they differ from callbacks?</h3>



<p class="wp-block-paragraph">A <strong>callback</strong> is scoped to a single agent. A <strong>Plugin</strong> is registered once on the <code>App</code> and sees every agent and model call in the entire application. Plugins subclass <code>BasePlugin</code> and implement hooks like <code>before_run_callback</code>, <code>after_model_callback</code>, and <code>on_event_callback</code>.</p>



<pre><code>from google.adk import BasePlugin, App
class TokenCounter(BasePlugin):
    def __init__(self):
        super().__init__(name="token_counter")
        self.total_tokens = 0
    async def after_model_callback(self, *, callback_context, llm_response):
        usage = getattr(llm_response, "usage_metadata", None)
        if usage:
            self.total_tokens += usage.total_token_count
        return None
app = App(name="my_app", root_agent=coordinator, plugins=&#91;TokenCounter()])
</code></pre>



<h3 class="wp-block-heading">Q84. How do you register a plugin with an ADK application?</h3>



<p class="wp-block-paragraph">Pass plugins to the <code>App</code> constructor:</p>



<pre><code>app = App(
    name="production_app",
    root_agent=root_agent,
    plugins=&#91;TokenCounter(), LatencyTracker(), AuditLogger()],
)
runner = Runner(app=app, session_service=session_service)
</code></pre>



<p class="wp-block-paragraph"><strong>Note:</strong> Plugins do not run in <code>adk web</code> — they only execute when running through the application runner.</p>



<h3 class="wp-block-heading">Q85. When should you use a callback vs. a tool?</h3>



<p class="wp-block-paragraph"><strong>Criterion:</strong> Who triggers it? | <strong>Callback:</strong> ADK (always, at lifecycle points) | <strong>Tool:</strong> The model (by choice)</p>



<p class="wp-block-paragraph"><strong>Criterion:</strong> Best for | <strong>Callback:</strong> Logging, validation, guardrails, metrics | <strong>Tool:</strong> External actions, data retrieval, computation</p>



<p class="wp-block-paragraph"><strong>Criterion:</strong> Can it block execution? | <strong>Callback:</strong> Yes (by returning a value) | <strong>Tool:</strong> No (model decides to call or not)</p>



<p class="wp-block-paragraph"><strong>Criterion:</strong> Scope | <strong>Callback:</strong> One agent (callback) or all (plugin) | <strong>Tool:</strong> Agents that have it in their tools list</p>



<p class="wp-block-paragraph">Use callbacks for <strong>small, mechanical checks or logging</strong>, not expensive reasoning — a callback that makes its own LLM call defeats the purpose.</p>



<h3 class="wp-block-heading">Q86. How do you implement a guardrail using before_tool_callback?</h3>



<pre><code>def validate_tool_input(callback_context, tool_name, tool_input):
    """Block dangerous tool calls."""
    if tool_name == "execute_sql" and "DROP" in str(tool_input).upper():
        return {"error": "Destructive SQL operations are blocked."}
    return None  # allow the tool call
agent.before_tool_callback = validate_tool_input
</code></pre>



<h3 class="wp-block-heading">Q87. What is on_event_callback in plugins?</h3>



<p class="wp-block-paragraph"><code>on_event_callback</code> fires for every Event in the session — user messages, agent responses, tool calls, state changes. Use it for comprehensive audit logging, real-time monitoring dashboards, or streaming events to an external observability system.</p>



<h3 class="wp-block-heading">Q88. Can plugins modify agent behavior at runtime?</h3>



<p class="wp-block-paragraph">Yes. A plugin&#8217;s <code>after_model_callback</code> can replace the LLM response (e.g., for content filtering across all agents), and <code>before_run_callback</code> can inject state or modify the conversation context before any agent processes it. Use with caution — plugins affect the entire application and are harder to test in isolation.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 8: Deployment &amp; Production (Q89–Q100)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q89. What are the deployment options for ADK agents?</h3>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Vertex AI Agent Runtime</strong> (formerly Agent Engine) — managed, auto-scaling, REST endpoint, built-in sessions/memory/tracing. Single command: <code>adk deploy agent_runtime</code></li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Cloud Run</strong> — containerized, pay-per-request, <code>adk deploy cloud_run --with_ui</code> for embedded web UI</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>GKE</strong> — Kubernetes deployment with Helm charts and manifests for full orchestration control</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Self-hosted</strong> — run inside any FastAPI (Python), Express (TS), Go, or JVM service</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q90. How do you deploy to Cloud Run?</h3>



<pre><code># Single command deployment
adk deploy cloud_run --project my-project --region us-central1
# With embedded web UI
adk deploy cloud_run --project my-project --region us-central1 --with_ui
</code></pre>



<p class="wp-block-paragraph">ADK builds a container, pushes it to Artifact Registry, and deploys to Cloud Run. The <code>--with_ui</code> flag embeds ADK Studio for debugging in production.</p>



<h3 class="wp-block-heading">Q91. What is the Vertex AI Agent Runtime?</h3>



<p class="wp-block-paragraph">The Agent Runtime is Google&#8217;s managed environment for ADK agents. It provides: auto-scaling, REST API endpoints, managed sessions and memory, built-in tracing and monitoring, IAM-based access control, and billing per compute/memory. Deploy with <code>adk deploy agent_runtime</code> or through the <code>google-cloud-aiplatform</code> SDK (v1.95.0+).</p>



<h3 class="wp-block-heading">Q92. How does ADK&#8217;s evaluation framework work?</h3>



<p class="wp-block-paragraph">ADK evaluation uses <strong>evalsets</strong> — JSON files containing test trajectories with expected tool calls and responses:</p>



<pre><code># Run evaluation from CLI
adk eval my_agent/ evalset.json
# Three scoring axes:
# 1. Tool trajectory match — did the agent call the right tools in the right order?
# 2. Response match — exact match, ROUGE score, or LLM-as-judge
# 3. Custom metrics — your own scoring functions
</code></pre>



<p class="wp-block-paragraph">Evalsets can be saved from ADK Studio conversations or created manually. CI/CD pipelines can gate deployments on evaluation pass/fail.</p>



<h3 class="wp-block-heading">Q93. How do you implement CI/CD for ADK agents?</h3>



<p class="wp-block-paragraph">A typical pipeline:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Lint &amp; type-check</strong> the agent code</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Run unit tests</strong> for individual tools</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Run eval tests</strong> with <code>adk eval</code> — check tool trajectory and response quality</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Build container</strong> (if deploying to Cloud Run or GKE)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Deploy to staging</strong> and run integration tests</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Promote to production</strong> if all gates pass</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q94. What observability features does ADK provide?</h3>



<p class="wp-block-paragraph">ADK includes:</p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><strong>Logging</strong> — structured logs for agent decisions, tool calls, and errors</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Metrics</strong> — latency, token usage, tool call frequency</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Traces</strong> — distributed tracing showing the full execution path including sub-agent calls</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Developer UI</strong> — visual inspection of events, state, and traces in ADK Studio</li></p>



<p class="wp-block-paragraph"></ul></p>



<p class="wp-block-paragraph">For production, integrate with Google Cloud Monitoring, Cloud Logging, and Cloud Trace.</p>



<h3 class="wp-block-heading">Q95. How do you handle model routing in production?</h3>



<p class="wp-block-paragraph">ADK supports <strong>model routing</strong> — directing different agents to different models based on cost, latency, and capability needs. A common pattern: use Gemini 2.5 Pro for complex planning/reasoning agents and Gemini 2.5 Flash for high-volume execution agents. Configure in the agent definition or dynamically through state-based model selection.</p>



<h3 class="wp-block-heading">Q96. What is the Agent Starter Pack?</h3>



<p class="wp-block-paragraph">The <strong>Agent Starter Pack</strong> is a set of sample agents in the <code>google/adk-samples</code> GitHub repository with one-click deployment templates. It includes patterns for customer support, data analysis, code generation, and multi-agent pipelines — ready to fork and customize for production.</p>



<h3 class="wp-block-heading">Q97. How do you handle secrets and credentials in deployed agents?</h3>



<p class="wp-block-paragraph">Never store secrets in state or agent code. Use: (1) <strong>Google Secret Manager</strong> for API keys and passwords, accessed at runtime; (2) <strong>IAM service accounts</strong> for Google Cloud service authentication; (3) <strong>environment variables</strong> injected at deployment time (not committed to source control); (4) ADK&#8217;s built-in auth framework for OAuth flows.</p>



<h3 class="wp-block-heading">Q98. What is the cost model for Vertex AI Agent Runtime?</h3>



<p class="wp-block-paragraph">Agent Runtime bills for <strong>compute and memory</strong> based on the resources allocated to your agent, even when idle. It is a managed runtime with auto-scaling — you pay for the baseline plus additional capacity during traffic spikes. For cost-sensitive workloads, Cloud Run&#8217;s pay-per-request model may be more efficient for bursty traffic patterns.</p>



<h3 class="wp-block-heading">Q99. How do you scale ADK agents for high traffic?</h3>



<p class="wp-block-paragraph">Options by deployment target:</p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><strong>Agent Runtime</strong>: auto-scales automatically, managed by Google Cloud</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Cloud Run</strong>: configure min/max instances, concurrency, and CPU/memory per instance</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>GKE</strong>: use Horizontal Pod Autoscaler (HPA) based on request count, latency, or custom metrics</li></p>



<p class="wp-block-paragraph"></ul></p>



<p class="wp-block-paragraph">Key scaling considerations: session state backend must handle concurrent reads/writes, LLM API rate limits become the bottleneck, and tool call latency (especially external APIs) affects throughput.</p>



<h3 class="wp-block-heading">Q100. What security features does ADK provide for enterprise deployments?</h3>



<p class="wp-block-paragraph">Enterprise security capabilities include: <strong>IAM-based access control</strong> (who can deploy, invoke, and manage agents), <strong>audit logging</strong> (via plugins and Cloud Audit Logs), <strong>VPC Service Controls</strong> for network isolation, <strong>Customer-Managed Encryption Keys (CMEK)</strong>, <strong>DLP integration</strong> for sensitive data handling, and <strong>model safety filters</strong> via Gemini&#8217;s built-in content safety layers.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Section 9: Scenario-Based &amp; System Design (Q101–Q110)</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Q101. Design a document processing pipeline that extracts data from PDFs, validates it, and stores it in BigQuery.</h3>



<p class="wp-block-paragraph"><strong>Architecture:</strong> A SequentialAgent pipeline with three stages:</p>



<pre><code>extractor = LlmAgent(
    name="extractor",
    model="gemini-2.5-pro",
    instruction="Extract structured data from the uploaded PDF. Output as JSON.",
    tools=&#91;code_execution],  # for PDF parsing
    output_key="extracted_data",
)
validator = LlmAgent(
    name="validator",
    instruction="Validate {extracted_data} against the schema. Flag errors.",
    tools=&#91;schema_validator],
    output_key="validation_result",
)
loader = LlmAgent(
    name="loader",
    instruction="If {validation_result} shows no errors, load {extracted_data} to BigQuery.",
    tools=&#91;bigquery_insert],
    output_key="load_status",
)
pipeline = SequentialAgent(name="doc_pipeline", sub_agents=&#91;extractor, validator, loader])
</code></pre>



<p class="wp-block-paragraph"><strong>Key design decisions:</strong> Use artifacts to store the uploaded PDF. Use <code>output_key</code> for inter-agent communication. Add a LoopAgent around extractor+validator for self-correcting extraction. Add HITL approval before the BigQuery load step for high-value documents.</p>



<h3 class="wp-block-heading">Q102. How would you build a multi-language customer support agent?</h3>



<p class="wp-block-paragraph"><strong>Architecture:</strong> Coordinator with language detection → specialist delegation:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Language detector</strong> (tool) identifies the user&#8217;s language</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Coordinator</strong> LlmAgent routes to language-specific sub-agents via <code>transfer_to_agent</code></li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li>Each sub-agent has instructions and knowledge base in its language</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li>Common backend tools (CRM lookup, ticket creation) are shared across all agents</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li>Gemini&#8217;s native multilingual capabilities reduce the need for translation layers</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q103. Design a code review agent that reviews pull requests and suggests improvements.</h3>



<pre><code>analyzer = LlmAgent(
    name="code_analyzer",
    model="gemini-2.5-pro",
    instruction="Analyze the diff for bugs, security issues, and style violations.",
    tools=&#91;github_pr_tool, code_execution],
    output_key="analysis",
)
reviewer = LlmAgent(
    name="reviewer",
    instruction="Based on {analysis}, write constructive PR review comments.",
    output_key="review",
)
pipeline = SequentialAgent(name="code_review", sub_agents=&#91;analyzer, reviewer])
</code></pre>



<p class="wp-block-paragraph"><strong>Production considerations:</strong> Use an MCP server for GitHub integration. Add a HITL step before posting comments. Use evalsets with known-bad code to validate detection accuracy. Deploy as an ambient agent triggered by GitHub webhooks via Cloud Pub/Sub.</p>



<h3 class="wp-block-heading">Q104. How would you migrate an existing RPA bot to an ADK agent?</h3>



<p class="wp-block-paragraph">A phased approach for migrating from <a href="https://rpabotsworld.com/automation-anywhere-2026-platform-enterpriseclaw-agentic-guide/">traditional RPA platforms</a>:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Wrap existing RPA as tools</strong> — expose the RPA bot&#8217;s API as ADK function tools or MCP server. The agent orchestrates; the bot executes.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Add reasoning layer</strong> — the LlmAgent handles exception cases, unstructured inputs, and decision-making the RPA bot cannot.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Gradually replace</strong> — as confidence grows, replace RPA-executed steps with direct tool calls (API calls, database operations).</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Add multi-agent coordination</strong> — split the monolithic process into specialized agents for parallel execution and better maintainability.</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q105. Design a real-time monitoring agent that detects anomalies and auto-remediates.</h3>



<p class="wp-block-paragraph">Deploy as an <strong>ambient agent</strong> triggered by Cloud Pub/Sub or Eventarc:</p>



<pre><code># Ambient agent triggered by monitoring alerts
monitor = LlmAgent(
    name="monitor",
    instruction="Analyze the incoming alert. Classify severity. If auto-remediable, execute fix. If not, escalate to human.",
    tools=&#91;log_query, metric_query, restart_service, scale_up, escalate_to_human],
)
# Deploy as ambient agent responding to Pub/Sub
# adk deploy agent_runtime --trigger=pubsub --topic=monitoring-alerts
</code></pre>



<p class="wp-block-paragraph"><strong>Key patterns:</strong> Use <code>RetryConfig</code> for flaky remediation actions. Add a <code>before_tool_callback</code> to block destructive actions during business hours. Log all actions through a plugin for audit compliance.</p>



<h3 class="wp-block-heading">Q106. How would you build a research assistant that synthesizes information from multiple sources?</h3>



<pre><code>searcher = ParallelAgent(
    name="multi_search",
    sub_agents=&#91;
        LlmAgent(name="web_search", tools=&#91;google_search], output_key="web_results"),
        LlmAgent(name="doc_search", tools=&#91;vertex_ai_search], output_key="doc_results"),
        LlmAgent(name="db_search", tools=&#91;bigquery_query], output_key="db_results"),
    ],
)
synthesizer = LlmAgent(
    name="synthesizer",
    instruction="Synthesize findings from {web_results}, {doc_results}, and {db_results} into a coherent report.",
    output_key="report",
)
research_pipeline = SequentialAgent(
    name="research_assistant",
    sub_agents=&#91;searcher, synthesizer],
)
</code></pre>



<h3 class="wp-block-heading">Q107. Compare deploying the same agent on Agent Runtime vs. Cloud Run vs. GKE.</h3>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Setup effort | <strong>Agent Runtime:</strong> Lowest (single command) | <strong>Cloud Run:</strong> Low (container build) | <strong>GKE:</strong> Highest (K8s manifests)</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Scaling | <strong>Agent Runtime:</strong> Automatic | <strong>Cloud Run:</strong> Auto, configurable | <strong>GKE:</strong> HPA, full control</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Cost model | <strong>Agent Runtime:</strong> Compute + memory (always-on) | <strong>Cloud Run:</strong> Pay per request | <strong>GKE:</strong> Cluster + node costs</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Sessions/Memory | <strong>Agent Runtime:</strong> Managed | <strong>Cloud Run:</strong> Self-managed | <strong>GKE:</strong> Self-managed</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Customization | <strong>Agent Runtime:</strong> Limited | <strong>Cloud Run:</strong> Medium | <strong>GKE:</strong> Full</p>



<p class="wp-block-paragraph"><strong>Dimension:</strong> Best for | <strong>Agent Runtime:</strong> Quick production, managed ops | <strong>Cloud Run:</strong> Bursty traffic, cost optimization | <strong>GKE:</strong> Complex, multi-service architectures</p>



<h3 class="wp-block-heading">Q108. How would you implement a multi-tenant SaaS product using ADK?</h3>



<p class="wp-block-paragraph"><strong>Key architecture decisions:</strong></p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Tenant isolation:</strong> Use <code>app:</code> prefix for shared config, <code>user:</code> prefix for tenant-specific state. Each tenant gets its own session namespace.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Model routing:</strong> Premium tenants use Gemini 2.5 Pro; free tier uses Flash.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Rate limiting:</strong> Implement via a <code>before_model_callback</code> that checks tenant quotas.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Data isolation:</strong> Each tenant&#8217;s tools connect to their own data sources via tenant-scoped credentials from Secret Manager.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Deployment:</strong> Single GKE cluster with namespace-per-tenant or Cloud Run with traffic splitting.</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q109. Design a system where ADK agents collaborate with LangGraph agents via A2A.</h3>



<p class="wp-block-paragraph">Cross-framework collaboration using the <a href="https://rpabotsworld.com/amazon-bedrock-agentcore-enterprise-agent-platform-guide/">A2A protocol</a>:</p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>ADK coordinator</strong> — orchestrates the workflow and manages user interaction</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>LangGraph specialist</strong> — handles complex stateful analysis with checkpointing (exposed as an A2A endpoint)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>ADK workers</strong> — handle Google Cloud integrations (BigQuery, Vertex AI Search)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li>Each agent publishes an <strong>Agent Card</strong> describing its capabilities</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li>The coordinator discovers agents via their cards and invokes them through A2A calls</li></p>



<p class="wp-block-paragraph"></ol></p>



<h3 class="wp-block-heading">Q110. You inherit a slow ADK agent pipeline (30s per turn). How do you diagnose and fix it?</h3>



<p class="wp-block-paragraph"><strong>Diagnosis checklist:</strong></p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><strong>Trace analysis</strong> — use ADK Studio or Cloud Trace to identify the slowest steps</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Model latency</strong> — check if you are using a larger model than needed (Pro vs. Flash)</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Tool latency</strong> — external API calls are often the bottleneck; add caching or parallelize</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Unnecessary summarization</strong> — every tool call triggers an extra LLM call; add <code>skip_summarization</code> where appropriate</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Context length</strong> — long conversations slow down model inference; enable context compression</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Sequential bottlenecks</strong> — replace SequentialAgent with ParallelAgent where tasks are independent</li></p>



<p class="wp-block-paragraph"></ol></p>



<p class="wp-block-paragraph"><strong>Fixes:</strong> Switch reasoning-heavy agents to Gemini 2.5 Pro and execution agents to Flash. Cache frequent tool results in state. Use ParallelAgent for independent tasks. Enable context compression for long sessions. Add a <code>TokenCounter</code> plugin to track token usage per turn.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Frequently Asked Questions</h2>



<p class="wp-block-paragraph"></p>



<h3 class="wp-block-heading">Is Google ADK free to use?</h3>



<p class="wp-block-paragraph">Yes. ADK is open-source under the Apache 2.0 license — free to use, modify, and distribute. You pay only for the underlying services: Gemini API calls, Vertex AI compute, Cloud Run hosting, etc. The framework itself has no licensing cost.</p>



<h3 class="wp-block-heading">What is the minimum Python version for ADK 2.0?</h3>



<p class="wp-block-paragraph">Python 3.10 through 3.13 is supported for ADK 2.x (Python SDK).</p>



<h3 class="wp-block-heading">Can I use ADK with non-Google models like GPT-4 or Claude?</h3>



<p class="wp-block-paragraph">Yes. ADK supports OpenAI, Anthropic Claude, Cohere, Mistral, AWS Bedrock, Ollama, vLLM, and others through the <code>LiteLLM</code> adapter. The <code>BaseLlm</code> interface also allows custom integrations with any model provider.</p>



<h3 class="wp-block-heading">How does ADK compare to CrewAI?</h3>



<p class="wp-block-paragraph">CrewAI uses a role-based &#8220;crew&#8221; metaphor with YAML configuration — faster to prototype but less execution control. ADK provides deeper orchestration (graph workflows, custom BaseAgent, callbacks, plugins) and multi-language support. CrewAI is Python-only; ADK covers Python, TS, Go, Java, and Kotlin. ADK has stronger cloud-native integration; CrewAI has a simpler learning curve.</p>



<h3 class="wp-block-heading">What Google certifications cover ADK?</h3>



<p class="wp-block-paragraph">As of late 2026, ADK is covered in the <strong>Google Cloud Professional Machine Learning Engineer</strong> and <strong>Google Cloud Professional Cloud Architect</strong> certifications. Google has also published ADK-specific learning paths on Google Cloud Skills Boost.</p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">Key Takeaways</h2>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><ul></p>



<p class="wp-block-paragraph"><li><strong>ADK 2.0 is production-ready</strong> — Python, Go, and TypeScript all hit GA in 2026, with graph-based workflows as the headline feature.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Five agent types</strong> give you the right abstraction: LlmAgent (reasoning), SequentialAgent (pipelines), ParallelAgent (fan-out), LoopAgent (iteration), and BaseAgent (custom orchestration).</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>State management uses four prefixes</strong>: unprefixed (session), <code>user:</code> (persistent per-user), <code>app:</code> (global), and <code>temp:</code> (invocation-scoped).</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Tools are the extensibility layer</strong> — function tools, MCP servers, OpenAPI specs, AgentTool, and LongRunningFunctionTool cover every integration pattern.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Multi-agent communication</strong> happens through shared state, not direct calls — agents write to state; downstream agents read from it.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>A2A protocol</strong> enables cross-framework interoperability with 150+ supporting organizations.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Deployment flexibility</strong>: from Vertex AI Agent Runtime (managed) to Cloud Run (serverless) to GKE (full control) to self-hosted containers.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Built-in evaluation</strong> with evalsets, trajectory matching, and CLI tooling enables CI/CD quality gates before production deployment.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Callbacks and plugins</strong> separate cross-cutting concerns (logging, guardrails, metrics) from agent logic.</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><strong>Model-agnostic design</strong> means you are not locked into Gemini — LiteLLM adapters support OpenAI, Claude, Cohere, Mistral, Bedrock, and local models.</li></p>



<p class="wp-block-paragraph"></ul></p>



<p class="wp-block-paragraph"></p>



<h2 class="wp-block-heading">External References</h2>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><ol></p>



<p class="wp-block-paragraph"><li><a href="https://adk.dev/get-started/about/" rel="nofollow noopener" target="_blank">Google ADK Official Documentation</a> — Technical overview and API reference</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://aiwiki.ai/wiki/google_adk" rel="nofollow noopener" target="_blank">AIWiki — Google Agent Development Kit</a> — Version history, adoption stats, and feature summary</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://aipractitioner.substack.com/p/google-adk-explained-building-multi" rel="nofollow noopener" target="_blank">AI Practitioner — Google ADK Explained (Part 1)</a> — Architecture deep dive with code examples</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://aipractitioner.substack.com/p/google-adk-multi-agent-orchestration" rel="nofollow noopener" target="_blank">AI Practitioner — ADK Multi-Agent Orchestration (Part 2)</a> — Delegation, callbacks, plugins, HITL patterns</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://atlan.com/know/ai-agent/ai-agent-applications/what-is-google-adk/" rel="nofollow noopener" target="_blank">Atlan — What Is Google ADK?</a> — ADK 2.0 features and MCP integration guide</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://dev.to/gde/building-ai-agents-with-the-python-agent-development-kit-adk-2026-edition-v2-32hf" rel="nofollow noopener" target="_blank">DEV Community — Building AI Agents with ADK 2026 Edition</a> — Hands-on ADK 2.x tutorial</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://www.raftlabs.com/blog/ai-agent-framework-comparison" rel="nofollow noopener" target="_blank">RaftLabs — AI Agent Framework Comparison</a> — LangGraph vs CrewAI vs ADK vs OpenAI SDK</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://futureagi.com/blog/what-is-google-adk-2026" rel="nofollow noopener" target="_blank">FutureAGI — What Is Google ADK 2026</a> — Evaluation framework and deployment patterns</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://notes.kodekloud.com/docs/Google-ADK/ADK-Fundamentals/Using-State-to-Drive-Conversations/page.md" rel="nofollow noopener" target="_blank">KodeKloud — ADK State Management</a> — State prefixes and session patterns</li></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"></p>



<p class="wp-block-paragraph"><li><a href="https://docs.cloud.google.com/run/docs/ai/build-and-deploy-ai-agents/adk" rel="nofollow noopener" target="_blank">Google Cloud — Build and Deploy ADK Agents on Cloud Run</a> — Official deployment guide</li></p>



<p class="wp-block-paragraph"></ol></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/google-adk-interview-questions-answers-2026/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
		<media:thumbnail url="https://rpabotsworld.com/wp-content/uploads/2026/10/google-adk-interview-questions-answers-2026-thumbnail.png" />	</item>
		<item>
		<title>Pega Agentic Process Fabric: The Workflow-First Enterprise Agent Platform Guide (2026)</title>
		<link>https://rpabotsworld.com/pega-agentic-process-fabric-enterprise-agent-guide/</link>
					<comments>https://rpabotsworld.com/pega-agentic-process-fabric-enterprise-agent-guide/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Wed, 07 Oct 2026 02:35:32 +0000</pubDate>
				<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[A2A Protocol]]></category>
		<category><![CDATA[MCP]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32413</guid>

					<description><![CDATA[How Pega Agentic Process Fabric puts workflows before prompts. Architecture, MCP/A2A support, Infinity 26 flat-fee pricing, and what it means for RPA teams.]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Gartner projects that more than 40 percent of agentic AI projects will be canceled by the end of 2027, citing escalating costs and inadequate controls as the primary culprits. Pegasystems looked at that forecast and bet the company&#8217;s next platform release on a single contrarian idea: <strong>don&#8217;t let agents improvise at runtime</strong>. The result is Pega Agentic Process Fabric — an orchestration layer that treats AI agents not as autonomous decision-makers but as participants in governed, auditable workflows. If your enterprise already runs mission-critical processes on Pega, or you are evaluating where agent orchestration fits inside a regulated stack, this guide breaks down the architecture, the pricing model, and the competitive tradeoffs you need to understand before your next planning cycle.</p>



<h2 class="wp-block-heading">What Is Pega Agentic Process Fabric?</h2>



<p class="wp-block-paragraph">Pega Agentic Process Fabric is an extension of Pegasystems&#8217; existing Process Fabric architecture, redesigned to orchestrate AI agents alongside traditional applications, systems, and data sources. Announced at PegaWorld in June 2025 and shipped as part of <strong>Pega Infinity 26</strong> in July 2026, the fabric creates a unified registry where every discoverable agent, workflow, and data asset across the enterprise is cataloged and made available to an overarching orchestration agent.</p>



<p class="wp-block-paragraph">In practical terms, the fabric does three things. First, it <strong>discovers and registers</strong> every Pega workflow, third-party AI agent, system integration, and data source connected to it. Second, it <strong>selects the optimal execution path</strong> — which might be a Pega workflow, an external agent, or a combination — for any given request. Third, it <strong>governs the entire interaction</strong> with step-by-step monitoring, audit trails, and compliance controls that satisfy regulated industries.</p>



<p class="wp-block-paragraph">Pega CEO Alan Trefler framed the positioning bluntly: &#8220;Enterprises want the promise and power of automation that agents could offer, but we don&#8217;t think they want thousands of agents running unchecked, producing unreliable, undesirable results.&#8221; That philosophy shapes every design decision in the platform.</p>



<figure class="wp-block-image size-large"><img fetchpriority="high" decoding="async" width="1200" height="800" src="https://rpabotsworld.com/wp-content/uploads/2026/10/pega-agentic-process-fabric-enterprise-agent-guide-architecture-diagram.svg" alt="Pega Agentic Process Fabric three-layer architecture diagram showing Blueprint, Predictable AI Agents, and orchestration fabric" class="wp-image-32414" title="Pega Agentic Process Fabric: The Workflow-First Enterprise Agent Platform Guide (2026) 1"></figure>



<h2 class="wp-block-heading">The Workflow-First Philosophy: Why Pega Rejects Prompt Engineering</h2>



<p class="wp-block-paragraph">Most enterprise agent platforms let AI models reason their way through tasks at runtime — the agent receives a goal, consults tools and data, and figures out the steps on the fly. Pega takes the opposite approach. AI reasoning happens at <strong>design time</strong>, when Blueprint AI agents help architects create and refine workflows. At runtime, those workflows execute through <strong>semantic AI</strong> — deterministic, auditable, and repeatable.</p>



<p class="wp-block-paragraph">Trefler has been direct about why: &#8220;Anybody who&#8217;s asking people to write prompts where those prompts are going to run their business is setting themselves up for slews of challenges.&#8221; CTO Don Schuerman elaborated on the dual approach: &#8220;What we&#8217;ve taken is an approach that combines the power of agents to reason and think and act with the predictability that you get from workflows, from knowing that there are certain things you want to do in the business where you actually want to follow a predetermined path.&#8221;</p>



<p class="wp-block-paragraph">This is not academic. In financial services, healthcare, and government — industries where Pega has deep installed bases — a single unpredictable agent action in a claims adjudication or loan underwriting workflow could trigger a compliance violation. The workflow-first model means that every agent action maps back to an approved process definition, and every deviation is flagged rather than silently executed.</p>



<h3 class="wp-block-heading">What &#8220;Design-Time Reasoning, Runtime Execution&#8221; Actually Means</h3>



<p class="wp-block-paragraph">When a Pega customer needs a new business process, Blueprint AI agents analyze requirements, existing documentation, and best practices to <em>propose</em> a workflow. Architects review, modify, and approve it. Once approved, that workflow becomes immutable at runtime — the agent follows the steps, collects data, routes decisions, and escalates exceptions exactly as designed. The creative, potentially unpredictable AI reasoning is confined to the design phase, where human oversight is built into every approval gate.</p>



<p class="wp-block-paragraph">This stands in contrast to platforms where agents re-reason each task execution. Pega&#8217;s bet is that enterprises will prefer predictable costs and auditable outcomes over the flexibility of unconstrained runtime reasoning — especially after the first wave of &#8220;agent sprawl&#8221; projects hits cost overruns and compliance issues.</p>



<h2 class="wp-block-heading">Architecture Deep Dive: The Three-Layer Stack</h2>



<p class="wp-block-paragraph">Pega Agentic Process Fabric is built on three integrated layers, each with a distinct role in the agent lifecycle.</p>



<h3 class="wp-block-heading">Layer 1: Pega Blueprint — Design Agents</h3>



<p class="wp-block-paragraph">Blueprint is Pega&#8217;s AI-powered design environment. It functions as an agent itself — ingesting documentation, organizational best practices, customer data, and Pega&#8217;s own platform knowledge to generate optimized workflow definitions. Key capabilities include:</p>



<ul class="wp-block-list">
<li><strong>Automated workflow generation</strong> from natural-language requirements</li>



<li><strong>Legacy system analysis</strong> — upload videos, screenshots, source code, or database schemas of existing applications, and Blueprint reverse-engineers modernized process definitions</li>



<li><strong>Industry template application</strong> — pre-loaded best practices for financial services, healthcare, insurance, and government workflows</li>



<li><strong>SI integration</strong> — system integrators like TCS and Credera can embed proprietary intellectual property into Blueprint&#8217;s knowledge base</li>
</ul>



<p class="wp-block-paragraph">Blueprint is currently available for free with a Pega user ID at <a href="https://www.pega.com/blueprint" target="_blank" rel="noopener nofollow">pega.com/blueprint</a>, a strategic move that puts AI-assisted design in the hands of prospects before they commit to the full platform.</p>



<h3 class="wp-block-heading">Layer 2: Pega Predictable AI Agents — Workflow Execution</h3>



<p class="wp-block-paragraph">Once Blueprint produces an approved workflow, Pega Predictable AI technology converts it into a deployable agent via the <strong>Pega Agent Experience API</strong>. These agents combine workflow reliability with contextual AI reasoning — they follow the process definition step by step but use AI to handle natural-language interactions, document analysis, and decision support within the guardrails of the approved workflow.</p>



<p class="wp-block-paragraph">Two pre-built agents ship with the platform:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Agent</th><th>Function</th><th>Channels</th></tr></thead><tbody><tr><td><strong>Agentic Assignment Agent</strong></td><td>Proactively contacts employees or customers when additional data or approvals are needed; routes work items to the right person based on context</td><td>Email, chat, telephony</td></tr><tr><td><strong>Document Agent</strong></td><td>Analyzes complex documents through splitting, categorization, boundary detection, confidence scoring, and triage; includes a conversational interface for PDF and image insights</td><td>In-app, API</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Organizations can build custom agents on top of this layer using Pega Infinity Studio, the AI-native development environment introduced in Infinity 26.</p>



<h3 class="wp-block-heading">Layer 3: Pega Agentic Process Fabric — Orchestration</h3>



<p class="wp-block-paragraph">The fabric itself is the orchestration brain. It maintains the enterprise-wide registry of agents, workflows, data sources, and system integrations. When a request arrives — whether from a customer chatbot, an internal employee portal, or another agent — the fabric:</p>



<ol class="wp-block-list">
<li><strong>Parses intent</strong> and determines what needs to happen</li>



<li><strong>Traverses the registry</strong> to find available agents and workflows that can fulfill the request</li>



<li><strong>Selects the optimal path</strong> — possibly combining a Pega workflow with a third-party agent (e.g., a Salesforce CRM lookup) in a single orchestrated flow</li>



<li><strong>Monitors execution</strong> step by step with full audit trails</li>



<li><strong>Escalates exceptions</strong> to human operators when confidence thresholds are not met</li>
</ol>



<p class="wp-block-paragraph">Multi-channel delivery is built in. Agents can engage users through chatbots, email, voice, SMS, and embedded in-app experiences without rebuilding the underlying workflow for each channel.</p>



<h2 class="wp-block-heading">MCP and A2A Protocol Support: The Interoperability Play</h2>



<p class="wp-block-paragraph">Pega made a strategically significant move by supporting both the <strong>Model Context Protocol (MCP)</strong> and <strong>Agent-to-Agent (A2A)</strong> communication standards. With MCP support, every Pega application becomes an MCP server — meaning third-party agents from Anthropic Claude, Google Gemini, OpenAI, AWS AgentCore, and other MCP-compatible platforms can discover and invoke Pega workflows without custom integration code.</p>



<p class="wp-block-paragraph">The A2A protocol enables direct agent-to-agent orchestration across platforms. In a practical scenario, a customer-facing Claude agent could discover a Pega claims-processing workflow via MCP, invoke it, and receive structured results — all governed by Pega&#8217;s compliance layer. For architects already building on the <a href="https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/">A2A and MCP standards that joined the Agentic AI Foundation</a>, Pega&#8217;s adoption means one more enterprise-grade platform in the interoperable agent ecosystem.</p>



<p class="wp-block-paragraph">The MCP integration extends to development tools as well. Pega Infinity 26 connects to Claude Code, GitHub Copilot, OpenAI Codex, Claude Cowork, ChatGPT, and Office 365 Copilot through MCP, allowing developers to build and modify Pega workflows using their preferred AI-assisted coding environments.</p>



<h2 class="wp-block-heading">Pega Infinity 26: Flat-Fee AI Pricing Changes the Economics</h2>



<p class="wp-block-paragraph">Released on July 14, 2026, Pega Infinity 26 bundles Agentic Process Fabric with a pricing model that directly targets the biggest objection enterprises have to agentic AI: <strong>unpredictable token costs</strong>.</p>



<p class="wp-block-paragraph">Instead of charging per token — where a complex agent interaction might consume thousands of tokens across multiple LLM calls, making cost forecasting nearly impossible — Pega charges a <strong>flat fee per resolved case</strong>. The company calls this &#8220;Pega Predictable AI&#8221; pricing, and it includes an <strong>AI Token Cost Calculator</strong> so prospects can compare their projected costs against token-based alternatives from competing platforms.</p>



<p class="wp-block-paragraph">The economic argument is straightforward: if an agent resolves a customer service case, a claims triage, or a document classification task, the cost is the same regardless of how many LLM calls the workflow required internally. This eliminates the &#8220;AI token tax&#8221; that has caused some enterprises to throttle agent deployments after seeing their first production bills.</p>



<p class="wp-block-paragraph">Key components of Infinity 26 beyond pricing:</p>



<ul class="wp-block-list">
<li><strong>Pega Infinity Studio</strong> — AI-native development environment integrating coding agents with Blueprint best practices</li>



<li><strong>Pega Customer Engagement Studio</strong> — agent-powered workspace for marketers to create personalized 1:1 campaigns at scale</li>



<li><strong>Enhanced MCP integration</strong> — connects Blueprint, Studio, and the runtime platform to external AI coding tools</li>



<li><strong>Cloud deployment</strong> — available through Pega Cloud or managed cloud environments</li>
</ul>



<h2 class="wp-block-heading">Enterprise Governance: The Compliance Architecture</h2>



<p class="wp-block-paragraph">Governance is not a feature bolted onto the Agentic Process Fabric — it is the structural principle. Every agent interaction, whether initiated by a Pega agent or a connected third-party agent, passes through the same governance layer:</p>



<ul class="wp-block-list">
<li><strong>Authentication and access control</strong> — agent access is restricted based on user identity, role, and the specific workflow being invoked</li>



<li><strong>Agent-to-agent interaction regulation</strong> — the fabric controls which agents can communicate with which other agents, preventing unauthorized lateral movement</li>



<li><strong>Step-by-step action monitoring</strong> — every action taken by every agent is logged with timestamps, inputs, outputs, and the workflow step that triggered it</li>



<li><strong>Compliance reporting</strong> — audit trails can be exported for regulatory review, with the ability to replay any agent interaction from start to finish</li>



<li><strong>Human-in-the-loop escalation</strong> — configurable confidence thresholds trigger automatic escalation to human operators for high-stakes decisions</li>
</ul>



<p class="wp-block-paragraph">CTO Don Schuerman has emphasized that this directly addresses the &#8220;black box problem&#8221; that plagues less governed agent platforms. In regulated industries — banking, insurance, healthcare, government — explaining <em>why</em> an agent made a specific decision is not optional. Because every Pega agent action traces back to an approved workflow step, the audit trail is inherently explainable.</p>



<p class="wp-block-paragraph">For teams already evaluating agent governance frameworks, this is worth comparing against <a href="https://rpabotsworld.com/servicenow-ai-control-tower-enterprise-agent-governance-guide/">ServiceNow&#8217;s AI Control Tower approach</a> and <a href="https://rpabotsworld.com/ibm-watsonx-orchestrate-agentic-control-plane-guide/">IBM watsonx Orchestrate&#8217;s control plane model</a> — each takes a meaningfully different architectural approach to the same enterprise trust problem.</p>



<h2 class="wp-block-heading">Legacy Modernization: Blueprint as a Migration Engine</h2>



<p class="wp-block-paragraph">One capability that differentiates Pega from pure-play agent platforms is Blueprint&#8217;s ability to serve as a legacy modernization engine. The workflow is practical: organizations record their legacy application interfaces, upload the recordings (videos, screenshots, source code, database schemas) to Blueprint, and the AI analyzes the functionality to produce modernized workflow definitions.</p>



<p class="wp-block-paragraph">In a banking demo shown at PegaWorld, Blueprint analyzed a credit card management application and identified four distinct workflows to modernize: credit limit adjustments, account maintenance, transaction processing, and billing. Kerim Akgonul, Chief Product Officer, noted: &#8220;What Blueprint will do is go through and essentially what a human would do in months, it will just basically analyze all the content.&#8221;</p>



<p class="wp-block-paragraph">This matters for the RPA community specifically. Many organizations that deployed RPA bots five to eight years ago to automate legacy system interactions now face a choice: maintain the bots as the legacy systems evolve, or modernize the underlying processes. Pega is positioning Blueprint as the path from &#8220;screen-scraping bots on a legacy app&#8221; to &#8220;governed agents on a modern workflow platform&#8221; — a migration pitch aimed squarely at enterprises sitting on aging RPA estates.</p>



<p class="wp-block-paragraph">With 68 percent of IT decision makers reporting that legacy systems prevent modern technology adoption, the modernization play is arguably as strategically important as the agent orchestration capabilities.</p>



<h2 class="wp-block-heading">How Pega Compares: Enterprise Agent Platform Landscape</h2>



<p class="wp-block-paragraph">The enterprise agent orchestration market is forming rapidly, with several major platforms competing for the same budget line item. Here is how Pega&#8217;s approach compares to the leading alternatives:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Dimension</th><th>Pega Agentic Process Fabric</th><th>Salesforce Agentforce</th><th>ServiceNow AI Control Tower</th><th>IBM watsonx Orchestrate</th></tr></thead><tbody><tr><td><strong>Core philosophy</strong></td><td>Workflow-first: AI reasons at design time, workflows execute at runtime</td><td>Agent-first: pre-built role-based agents with configurable guardrails</td><td>Governance-first: centralized control tower monitors autonomous agents</td><td>Skill-first: agents composed from reusable skill libraries</td></tr><tr><td><strong>MCP support</strong></td><td>Yes — every app becomes an MCP server</td><td>Yes — via Agentforce platform</td><td>Limited</td><td>Yes — via watsonx.ai integration</td></tr><tr><td><strong>A2A protocol</strong></td><td>Yes</td><td>Yes</td><td>Partial</td><td>Yes</td></tr><tr><td><strong>Pricing model</strong></td><td>Flat fee per resolved case</td><td>Per conversation / per agent</td><td>Subscription-based</td><td>Subscription + token consumption</td></tr><tr><td><strong>Legacy modernization</strong></td><td>Built-in via Blueprint AI</td><td>Limited</td><td>Limited</td><td>Via watsonx Code Assistant</td></tr><tr><td><strong>Pre-built agents</strong></td><td>Assignment Agent, Document Agent, Blueprint design agents</td><td>Sales, Service, Marketing, Commerce, and custom agents</td><td>IT, HR, Customer Service agents</td><td>HR, procurement, IT agents</td></tr><tr><td><strong>Best fit</strong></td><td>Regulated industries with existing Pega investments and complex workflow requirements</td><td>Salesforce-centric organizations wanting fast agent deployment</td><td>ITSM-heavy enterprises wanting centralized agent governance</td><td>Multi-cloud enterprises wanting vendor-neutral orchestration</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The philosophical difference is the key differentiator. Salesforce and ServiceNow let agents reason at runtime within guardrails. Pega confines all reasoning to the design phase. Neither approach is universally superior — the right choice depends on whether your processes are well-defined enough to model as workflows (Pega&#8217;s sweet spot) or require the flexibility of runtime reasoning (where Salesforce and ServiceNow have an edge).</p>



<p class="wp-block-paragraph">For a deeper dive into how <a href="https://rpabotsworld.com/salesforce-agentforce-job-ready-agents-long-horizon-runtime-guide-3/">Salesforce Agentforce&#8217;s job-ready agents</a> compare, or how <a href="https://rpabotsworld.com/microsoft-agent-framework-1-0-foundry-agentic-ai-architect-guide/">Microsoft&#8217;s Agent Framework 1.0</a> fits into the picture, see our dedicated guides.</p>



<h2 class="wp-block-heading">Real-World Use Cases and Customer Signals</h2>



<p class="wp-block-paragraph">While Pega has not published detailed case studies from Agentic Process Fabric deployments (the product only reached general availability in July 2026), several customer signals indicate where early traction is forming:</p>



<h3 class="wp-block-heading">Financial Services</h3>



<p class="wp-block-paragraph">Erica van de Ven, Global Head of Financial Economic Crime Tech at <strong>Rabobank</strong>, stated: &#8220;We see incredible potential for deploying AI agents to improve efficiencies and deliver&#8221; better outcomes in financial crime detection. For banks, the governed workflow model aligns with anti-money laundering (AML) and know-your-customer (KYC) requirements where every decision must be documented and defensible.</p>



<h3 class="wp-block-heading">Insurance Claims Processing</h3>



<p class="wp-block-paragraph">Claims adjudication is a classic Pega stronghold. With Agentic Process Fabric, a claims workflow can now incorporate a Document Agent to analyze submitted evidence, an Assignment Agent to route complex cases to specialist adjusters, and third-party agents (via MCP) to pull data from external systems — all within a single governed flow that satisfies state insurance regulatory requirements.</p>



<h3 class="wp-block-heading">Customer Service Transformation</h3>



<p class="wp-block-paragraph">Pega Customer Engagement Studio, part of Infinity 26, enables contact centers to deploy agents that handle routine inquiries through workflow-governed conversations while escalating complex cases. The flat-fee pricing is particularly attractive here — high-volume customer service operations can budget agent costs per case rather than worrying about token consumption spikes during peak periods.</p>



<h3 class="wp-block-heading">Legacy System Migration</h3>



<p class="wp-block-paragraph">Organizations using Blueprint to modernize legacy applications represent a less obvious but potentially high-value use case. Credera CEO Mahesh Agrawal highlighted the unified directory spanning both Pega and non-Pega systems, enabling &#8220;conversational agents to collaborate, trigger, and complete workflows seamlessly&#8221; — a capability that matters when the modernization target is not replacing the legacy system entirely but wrapping it in governed agent access.</p>



<h2 class="wp-block-heading">What This Means for RPA Teams</h2>



<p class="wp-block-paragraph">If you are running an RPA center of excellence, Pega Agentic Process Fabric introduces a specific strategic question: <strong>where does workflow-governed agent orchestration fit alongside your existing bot estate?</strong></p>



<p class="wp-block-paragraph">The honest answer depends on your starting position. Teams already invested in Pega for case management, customer service, or decisioning have a natural upgrade path — the Agentic Process Fabric extends what they already run. Teams on UiPath, Automation Anywhere, or Power Automate are more likely to encounter Pega as a complementary orchestration layer than a bot replacement, especially if the organization already uses Pega for its core business processes.</p>



<p class="wp-block-paragraph">The more important signal is the pricing model. Flat-fee-per-case pricing directly challenges the token-based economics that have made some enterprises hesitant to scale agentic deployments. If Pega&#8217;s model proves sustainable at scale, expect competitive pressure on other platforms to offer similar predictable-cost options — which would benefit the entire market. For a broader look at how <a href="https://rpabotsworld.com/automation-anywhere-vs-uipath-agentic-procure-to-pay-2026/">Automation Anywhere and UiPath are approaching agentic process automation</a>, see our procure-to-pay comparison.</p>



<h2 class="wp-block-heading">Getting Started</h2>



<p class="wp-block-paragraph">For architects evaluating Pega Agentic Process Fabric, the on-ramp is straightforward:</p>



<ol class="wp-block-list">
<li><strong>Try Blueprint for free</strong> — sign up at <a href="https://www.pega.com/blueprint" target="_blank" rel="noopener nofollow">pega.com/blueprint</a> to explore the AI-assisted workflow design experience</li>



<li><strong>Map your process inventory</strong> — identify which business processes are well-defined enough to model as workflows (Pega&#8217;s strength) versus those that require flexible runtime reasoning</li>



<li><strong>Evaluate MCP compatibility</strong> — if you are building agents on Claude, Gemini, or OpenAI, test interoperability through MCP connections to Pega workflows</li>



<li><strong>Run the AI Token Cost Calculator</strong> — compare Pega&#8217;s flat-fee model against your current or projected token costs on other platforms</li>



<li><strong>Engage an SI partner</strong> — Pega&#8217;s system integrator ecosystem (TCS, Credera, Cognizant, Accenture) can provide proof-of-concept support, especially for legacy modernization scenarios</li>
</ol>



<h2 class="wp-block-heading">Frequently Asked Questions</h2>



<h3 class="wp-block-heading">What is Pega Agentic Process Fabric and how does it differ from regular RPA?</h3>



<p class="wp-block-paragraph">Pega Agentic Process Fabric is an AI agent orchestration layer that coordinates agents, workflows, systems, and data across the enterprise. Unlike traditional RPA, which automates individual screen-level tasks through bots, Agentic Process Fabric orchestrates end-to-end business processes using AI agents governed by predefined workflows. The key difference is scope: RPA bots execute repetitive steps, while the fabric manages entire process outcomes across multiple agents and systems.</p>



<h3 class="wp-block-heading">Does Pega Agentic Process Fabric work with non-Pega AI agents?</h3>



<p class="wp-block-paragraph">Yes. Through Model Context Protocol (MCP) and Agent-to-Agent (A2A) protocol support, the fabric can discover and orchestrate agents from Anthropic Claude, Google Gemini, OpenAI, AWS AgentCore, and other MCP-compatible platforms. Every Pega application becomes an MCP server, enabling third-party agents to invoke Pega workflows without custom integration.</p>



<h3 class="wp-block-heading">How does Pega&#8217;s flat-fee AI pricing work?</h3>



<p class="wp-block-paragraph">Instead of charging per token consumed by LLM calls (which can vary unpredictably based on conversation complexity), Pega charges a flat fee per resolved case. This means the cost of processing a customer service inquiry, a claims adjudication, or a document classification is the same regardless of how many AI interactions the workflow required internally. Pega provides an AI Token Cost Calculator to compare this model against token-based pricing from other platforms.</p>



<h3 class="wp-block-heading">Is Pega Agentic Process Fabric suitable for regulated industries?</h3>



<p class="wp-block-paragraph">It is specifically designed for them. The workflow-first architecture means every agent action maps back to an approved process definition with full audit trails, step-by-step monitoring, and compliance reporting. Agent access is controlled by authentication and role-based permissions, and agent-to-agent interactions are regulated to prevent unauthorized actions.</p>



<h3 class="wp-block-heading">Can Pega Agentic Process Fabric help modernize legacy applications?</h3>



<p class="wp-block-paragraph">Yes, through Pega Blueprint. Organizations can upload legacy application assets — videos of user interactions, screenshots, source code, database schemas — and Blueprint AI will analyze them to produce modernized workflow definitions. This positions the platform as both an agent orchestration layer and a legacy modernization engine.</p>



<h2 class="wp-block-heading">Key Takeaways</h2>



<ul class="wp-block-list">
<li><strong>Workflow-first, not prompt-first:</strong> Pega confines AI reasoning to design time and uses deterministic workflows at runtime — a fundamentally different architectural bet than most agent platforms.</li>



<li><strong>MCP and A2A native:</strong> every Pega application becomes an MCP server, making the platform interoperable with agents from Claude, Gemini, OpenAI, AWS AgentCore, and other MCP-compatible systems.</li>



<li><strong>Flat-fee pricing:</strong> Pega Infinity 26&#8217;s per-resolved-case pricing eliminates token-cost unpredictability — a direct response to the cost overruns that have stalled enterprise agent deployments.</li>



<li><strong>Governance by design:</strong> audit trails, access controls, agent-to-agent regulation, and human-in-the-loop escalation are structural, not optional add-ons.</li>



<li><strong>Legacy modernization built in:</strong> Blueprint AI can reverse-engineer legacy applications into governed agent workflows — a unique capability in the enterprise agent platform market.</li>



<li><strong>Best fit:</strong> regulated industries with complex, well-defined processes and existing Pega investments. Less suited to organizations that need maximum runtime agent flexibility for loosely defined tasks.</li>
</ul>



<h2 class="wp-block-heading">References</h2>



<ol class="wp-block-list">
<li>Pega, &#8220;<a href="https://www.pega.com/about/news/press-releases/pega-agentic-process-fabric-reliably-orchestrates-end-end-ai-automation" target="_blank" rel="noopener nofollow">Pega Agentic Process Fabric Reliably Orchestrates End-to-End AI Automation</a>,&#8221; Press Release, June 2, 2025.</li>



<li>BusinessWire, &#8220;<a href="https://www.businesswire.com/news/home/20260608601073/en/Pega-Powers-AI-Agents-to-Reliably-Drive-Mission-Critical-Work" target="_blank" rel="noopener nofollow">Pega Powers AI Agents to Reliably Drive Mission-Critical Work</a>,&#8221; June 8, 2026.</li>



<li>Constellation Research, &#8220;<a href="https://www.constellationr.com/blog-news/insights/pegasystems-launches-pega-agentic-process-fabric-rides-ai-momentum" target="_blank" rel="noopener nofollow">Pegasystems Launches Pega Agentic Process Fabric, Rides AI Momentum</a>,&#8221; Liz Miller, 2026.</li>



<li>Diginomica, &#8220;<a href="https://diginomica.com/pegas-agentic-approach-puts-workflows-first-prompts-second-heres-why-matters-enterprise-ai-adoption" target="_blank" rel="noopener nofollow">Pega&#8217;s Agentic Approach Puts Workflows First, Prompts Second — Here&#8217;s Why That Matters</a>,&#8221; 2026.</li>



<li>SiliconANGLE, &#8220;<a href="https://siliconangle.com/2025/06/02/pegasystems-expands-features-build-manage-ai-agents/" target="_blank" rel="noopener nofollow">Pegasystems Expands Features to Build and Manage AI Agents</a>,&#8221; June 2, 2025.</li>



<li>DevOps Digest, &#8220;<a href="https://www.devopsdigest.com/pega-infinity-26-released" target="_blank" rel="noopener nofollow">Pega Infinity 26 Released</a>,&#8221; July 2026.</li>



<li>BriefGlance, &#8220;<a href="https://briefglance.com/companies/pegasystems-inc/pulses/58120" target="_blank" rel="noopener nofollow">Pegasystems Launches Pega Infinity 26 with Flat-Fee AI Pricing Model</a>,&#8221; 2026.</li>



<li>Pega, &#8220;<a href="https://www.businesswire.com/news/home/20260714981812/en/" target="_blank" rel="noopener nofollow">Pega Infinity 26 Now Available to Deliver Predictable Outcomes with Predictable AI Costs</a>,&#8221; BusinessWire, July 14, 2026.</li>



<li>CX Today, &#8220;<a href="https://www.cxtoday.com/?p=992594" target="_blank" rel="noopener nofollow">Pegasystems Has Put a Price on Agentic Customer Service. Buyers Need the Fine Print</a>,&#8221; 2026.</li>
</ol>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/pega-agentic-process-fabric-enterprise-agent-guide/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
		<media:thumbnail url="https://rpabotsworld.com/wp-content/uploads/2026/10/pega-agentic-process-fabric-enterprise-agent-guide-youtube-thumbnail.svg" />	</item>
		<item>
		<title>A2A Joins MCP at the Agentic AI Foundation: The Complete Guide for Agentic AI Architects (2026)</title>
		<link>https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/</link>
					<comments>https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Sat, 05 Sep 2026 17:45:53 +0000</pubDate>
				<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[A2A Protocol]]></category>
		<category><![CDATA[MCP]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32343</guid>

					<description><![CDATA[A2A joins MCP under the Agentic AI Foundation with 250+ members. Complete architect's guide to the unified protocol stack, v1.0 spec, and production…]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">On August 17, 2026, Google&#8217;s Agent2Agent (A2A) protocol formally became a hosted project of the Agentic AI Foundation (AAIF) — the Linux Foundation-directed body that already governs Anthropic&#8217;s Model Context Protocol (MCP), Block&#8217;s goose agent framework, and OpenAI&#8217;s AGENTS.md convention. With more than 250 member organizations including AWS, Microsoft, Anthropic, Google, and OpenAI signed on as governance participants, this move consolidates the two most critical protocol layers of the agentic AI stack under a single neutral roof (<a href="https://aaif.io/blog/a2a-joins-aaif" target="_blank" rel="noopener nofollow">AAIF Official Announcement</a>).</p>



<p class="wp-block-paragraph">If you build multi-agent systems — or you will in the next 12 months — this is not a branding event. It is a structural shift in how your agents will discover, communicate with, and delegate work to agents built by other teams, other vendors, and other frameworks. This guide breaks down exactly what changed, why it matters for enterprise architectures, and what you should do about it now.</p>



<h2 class="wp-block-heading">Table of Contents</h2>



<ul class="wp-block-list">
<li><a href="#what-is-aaif">What Is the Agentic AI Foundation (AAIF)?</a></li>



<li><a href="#what-a2a-does">What A2A Actually Does — And How It Differs from MCP</a></li>



<li><a href="#aaif-stack">The Full AAIF Protocol Stack: Five Layers, One Governance Model</a></li>



<li><a href="#a2a-technical">A2A v1.0 Technical Architecture: Agent Cards, Tasks, and Streaming</a></li>



<li><a href="#production-use">Where A2A Is Already Running in Production</a></li>



<li><a href="#enterprise-impact">What This Means for Enterprise Agentic Architectures</a></li>



<li><a href="#rpa-implications">Implications for RPA Teams Moving to Agentic Workflows</a></li>



<li><a href="#getting-started">Getting Started: How to Adopt A2A + MCP in Your Stack Today</a></li>



<li><a href="#faqs">FAQs</a></li>



<li><a href="#key-takeaways">Key Takeaways</a></li>



<li><a href="#references">References</a></li>
</ul>



<h2 class="wp-block-heading">What Is the Agentic AI Foundation (AAIF)?</h2>



<p class="wp-block-paragraph">The Agentic AI Foundation launched in December 2025 as a Linux Foundation initiative to provide neutral, vendor-independent governance for the infrastructure that powers AI agents in production. Its founding members — Anthropic, OpenAI, and Block — contributed three anchor projects: MCP (the protocol for connecting agents to tools and data), goose (an open-source agent runtime from Block), and AGENTS.md (a specification for communicating instructions and conventions to AI agents).</p>



<p class="wp-block-paragraph">Within eight months, AAIF grew from fewer than 40 members to over 250. Platinum-tier signatories now include AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI (<a href="https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation" target="_blank" rel="noopener nofollow">Linux Foundation Press Release</a>). That breadth is deliberate. When foundational infrastructure protocols are owned by a single vendor, every downstream team absorbs that vendor&#8217;s roadmap constraints. When they are governed openly, the community shapes what gets built.</p>



<p class="wp-block-paragraph">For context, MCP alone had crossed 97 million monthly SDK downloads (Python + TypeScript combined) by February 2026. The protocol that standardizes how your agents connect to databases, APIs, and enterprise services is no longer any single company&#8217;s project — it belongs to the ecosystem. And now A2A, the protocol that standardizes how your agents talk to <em>each other</em>, sits in the same governance structure.</p>



<h2 class="wp-block-heading">What A2A Actually Does — And How It Differs from MCP</h2>



<p class="wp-block-paragraph">The simplest mental model: <strong>MCP is vertical, A2A is horizontal.</strong></p>



<p class="wp-block-paragraph">MCP standardizes the connection between an agent and its tools. When a Claude-based agent needs to query a PostgreSQL database, read a Google Drive file, or call a Salesforce API, MCP defines the protocol for that interaction — discovery, authentication, invocation, and response. It solves the &#8220;agent-to-tool&#8221; problem. If you&#8217;ve built MCP servers for your internal tools, you&#8217;ve already used this layer. (For a deeper dive, see our guide to <a href="https://rpabotsworld.com/what-is-mcp-server-ai-agents/">what MCP servers are and how they work</a>.)</p>



<p class="wp-block-paragraph">A2A solves a different problem: the &#8220;agent-to-agent&#8221; problem. When a procurement agent built on LangGraph needs to delegate a compliance check to a legal-review agent built on Google ADK, or when a customer-service agent on Salesforce Agentforce needs to route an IT escalation to a ServiceNow agent, A2A defines how those agents discover each other, negotiate capabilities, delegate tasks, and exchange results — regardless of their underlying framework.</p>



<p class="wp-block-paragraph">AAIF CTO Manik Surtani put it directly: &#8220;Where A2A fits is at the collaborative edge; where MCP fits is at the tool integration edge.&#8221; Together they form the plumbing for what analysts increasingly call the agentic AI economy (<a href="https://aaif.io/blog/a2a-joins-aaif" target="_blank" rel="noopener nofollow">AAIF Blog</a>).</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Dimension</th><th>MCP (Model Context Protocol)</th><th>A2A (Agent2Agent)</th></tr></thead><tbody><tr><td><strong>Primary function</strong></td><td>Agent <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2194.png" alt="↔" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Tool connectivity</td><td>Agent <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2194.png" alt="↔" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Agent interoperability</td></tr><tr><td><strong>Originated by</strong></td><td>Anthropic (2024)</td><td>Google (April 2025)</td></tr><tr><td><strong>Joined AAIF</strong></td><td>December 2025 (founding project)</td><td>August 2026</td></tr><tr><td><strong>Stable spec</strong></td><td>2026-07-28 stateless spec</td><td>v1.0 (March 2026)</td></tr><tr><td><strong>Core abstraction</strong></td><td>Tools, resources, prompts</td><td>Agent Cards, Tasks, Messages</td></tr><tr><td><strong>Discovery mechanism</strong></td><td>Server manifests</td><td>Agent Cards (signed JSON metadata)</td></tr><tr><td><strong>Communication pattern</strong></td><td>Request/response (tool invocation)</td><td>Task lifecycle (submitted → working → completed) + streaming</td></tr><tr><td><strong>Monthly SDK downloads</strong></td><td>97M+ (Feb 2026)</td><td>Growing rapidly post-v1.0</td></tr><tr><td><strong>Typical use case</strong></td><td>&#8220;My agent needs to read Jira tickets&#8221;</td><td>&#8220;My agent needs to delegate work to your agent&#8221;</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">The critical point: <strong>these protocols are complementary, not competing.</strong> A well-architected multi-agent system uses MCP for each agent&#8217;s tool access and A2A for inter-agent coordination. The AAIF governance model does not merge them — each retains its own technical steering committee — but ensures their roadmaps stay aligned.</p>



<h2 class="wp-block-heading">The Full AAIF Protocol Stack: Five Layers, One Governance Model</h2>



<p class="wp-block-paragraph">With A2A&#8217;s addition, the AAIF now governs a complete five-layer stack for agentic AI infrastructure. Understanding each layer is essential for architects designing production systems.</p>



<h3 class="wp-block-heading">Layer 1: Instructions and Context — AGENTS.md</h3>



<p class="wp-block-paragraph">AGENTS.md standardizes how projects communicate expectations, conventions, and operating instructions to AI agents. Think of it as the &#8220;README for agents&#8221; — a structured document that tells an agent what it can and cannot do within a given project, what coding standards to follow, what tools are available, and what guardrails apply. Contributed by OpenAI.</p>



<h3 class="wp-block-heading">Layer 2: Agent Runtime — goose</h3>



<p class="wp-block-paragraph">Block&#8217;s goose provides the environment in which an agent reasons, plans, invokes capabilities, and executes work. It is an open-source agent framework that handles the execution loop — the &#8220;engine&#8221; that an agent runs on top of.</p>



<h3 class="wp-block-heading">Layer 3: Agent-to-Tool Connectivity — MCP</h3>



<p class="wp-block-paragraph">Anthropic&#8217;s Model Context Protocol standardizes how agents connect to tools, data sources, applications, and services. MCP servers expose capabilities through a uniform interface, and MCP clients (agents) discover and invoke them. The <a href="https://rpabotsworld.com/mcp-2026-07-28-stateless-spec-agentic-ai-guide/">2026-07-28 stateless spec update</a> made MCP servers truly stateless, removing the requirement for persistent connections and making the protocol viable for serverless and edge deployments.</p>



<h3 class="wp-block-heading">Layer 4: Traffic Mediation — agentgateway</h3>



<p class="wp-block-paragraph">agentgateway sits at the boundary between agent systems and infrastructure, handling routing, policy enforcement, and observability. It is the operations layer — where you apply rate limiting, access control, audit logging, and traffic shaping to agent communications.</p>



<h3 class="wp-block-heading">Layer 5: Agent-to-Agent Interoperability — A2A</h3>



<p class="wp-block-paragraph">A2A standardizes how independent agents discover one another, communicate, delegate tasks, and exchange results across systems and organizational boundaries. This is the newest addition and the layer that makes true multi-vendor, multi-framework agent ecosystems possible.</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Layer</th><th>Project</th><th>What It Does</th><th>Contributed By</th></tr></thead><tbody><tr><td>Instructions</td><td>AGENTS.md</td><td>Tells agents how to behave in a project</td><td>OpenAI</td></tr><tr><td>Runtime</td><td>goose</td><td>Executes agent reasoning and planning</td><td>Block</td></tr><tr><td>Tool Access</td><td>MCP</td><td>Connects agents to tools, data, services</td><td>Anthropic</td></tr><tr><td>Operations</td><td>agentgateway</td><td>Routes, monitors, and controls agent traffic</td><td>Community</td></tr><tr><td>Inter-Agent</td><td>A2A</td><td>Agents discover and delegate work to other agents</td><td>Google</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Every major cloud provider and AI lab is a governance participant. This is not a Google stack or an Anthropic stack — it is the industry stack. For architects, this means you can design multi-agent systems against these protocols with reasonable confidence that they won&#8217;t be deprecated, forked, or locked behind a single vendor&#8217;s paywall.</p>



<h2 class="wp-block-heading">A2A v1.0 Technical Architecture: Agent Cards, Tasks, and Streaming</h2>



<p class="wp-block-paragraph">A2A v1.0 shipped in March 2026 with several critical capabilities that make it production-ready. Here&#8217;s what you need to understand as an implementer.</p>



<h3 class="wp-block-heading">Agent Cards: Discovery and Identity</h3>



<p class="wp-block-paragraph">Every A2A-capable agent publishes an <strong>Agent Card</strong> — a JSON metadata document describing its identity, capabilities, skills, service endpoint, and authentication requirements. Agent Cards are the discovery mechanism: other agents read your card to understand what you can do and how to reach you (<a href="https://a2a-protocol.org/latest/specification/" target="_blank" rel="noopener nofollow">A2A v1.0 Specification</a>).</p>



<p class="wp-block-paragraph">The v1.0 spec added <strong>signed Agent Cards</strong> with cryptographic identity verification. Clients verify the signatures field against the issuer&#8217;s public key (typically held in a curated registry or x5c chain) before trusting the card. This is not optional for enterprise deployments — unsigned agent cards in a multi-vendor system are the equivalent of unsigned API endpoints.</p>



<pre class="wp-block-code"><code>// Simplified Agent Card structure
{
  "@context": "https://a2a-protocol.org/v1.0",
  "name": "compliance-review-agent",
  "description": "Reviews procurement requests against regulatory requirements",
  "url": "https://agents.example.com/compliance",
  "version": "1.0.0",
  "skills": &#91;
    {
      "id": "regulatory-check",
      "name": "Regulatory Compliance Check",
      "description": "Evaluates a procurement request against applicable regulations",
      "inputModes": &#91;"text", "application/json"],
      "outputModes": &#91;"application/json"]
    }
  ],
  "authentication": {
    "schemes": &#91;"oauth2"],
    "credentials": "https://auth.example.com/.well-known/oauth-authorization-server"
  },
  "signatures": { }
}</code></pre>



<h3 class="wp-block-heading">Task Lifecycle: The State Machine</h3>



<p class="wp-block-paragraph">Every interaction in A2A revolves around a strict task state machine. When an agent receives a <code>SendMessage</code> call, it either returns a <code>Message</code> directly (for trivial responses) or instantiates a <code>Task</code> and transitions it through defined states:</p>



<p class="wp-block-paragraph"><strong>submitted → working → input-required → completed | canceled | failed</strong></p>



<p class="wp-block-paragraph">This is fundamentally different from simple request/response patterns. The <code>input-required</code> state is particularly important — it allows agents to negotiate, ask clarifying questions, or request additional context mid-task. A compliance agent reviewing a procurement request can pause in <code>input-required</code>, ask the requesting agent for additional documentation, receive it, and then continue to <code>completed</code>. This models how humans actually collaborate — with back-and-forth — rather than the fire-and-forget pattern of most API integrations.</p>



<h3 class="wp-block-heading">Streaming Architecture</h3>



<p class="wp-block-paragraph">For long-running tasks, A2A supports streaming via Server-Sent Events (SSE). Clients call <code>SendStreamingMessage</code> (to submit and stream in one step) or <code>SubscribeToTask</code> (to attach to an existing task). The server responds with <code>Content-Type: text/event-stream</code> and pushes <code>TaskStatusUpdateEvent</code> and <code>TaskArtifactUpdateEvent</code> objects until the task reaches a terminal state.</p>



<p class="wp-block-paragraph">This means your orchestrating agent doesn&#8217;t need to poll. It opens a stream, processes status updates and partial results as they arrive, and can display progress to end users in real time.</p>



<h3 class="wp-block-heading">Multi-Tenancy and Version Negotiation</h3>



<p class="wp-block-paragraph">The v1.0 spec added two enterprise-critical capabilities. <strong>Multi-tenancy</strong> allows a single A2A server to serve multiple tenants with isolated task namespaces. <strong>Version negotiation</strong> allows agents running different spec versions to discover the highest mutually supported version and communicate at that level — essential for organizations rolling out upgrades across a fleet of agents at different cadences.</p>



<h2 class="wp-block-heading">Where A2A Is Already Running in Production</h2>



<p class="wp-block-paragraph">A2A is not a whitepaper protocol. As of mid-2026, it is running in production across mobile platforms, cloud infrastructure, financial services, and supply chain logistics. Here are the most significant deployments (<a href="https://www.linuxfoundation.org/press/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year" target="_blank" rel="noopener nofollow">Linux Foundation Press Release, April 2026</a>).</p>



<h3 class="wp-block-heading">Huawei HarmonyOS: Mobile-Scale Agent Orchestration</h3>



<p class="wp-block-paragraph">Huawei standardized A2A as the protocol between Celia (its OS-level AI assistant) and in-app agents across the HarmonyOS developer platform. Supported scenarios include Celia delegating long-running tasks to app agents, Celia controlling app UI through an agent, and Celia requesting contextual recommendations from application agents. This is agent-to-agent communication operating at <em>mobile operating system scale</em> — billions of potential interactions daily.</p>



<p class="wp-block-paragraph">Tencent&#8217;s WeChat is among the first major apps integrating with Huawei and other Android OEM assistants over A2A, enabling messages, voice calls, and video calls initiated through an AI assistant. The flow runs with dual authorization through the A2A protocol.</p>



<h3 class="wp-block-heading">PayPal: Agentic Commerce</h3>



<p class="wp-block-paragraph">PayPal deployed A2A in production for merchant-facing workflows. A sales agent receives a natural-language request, uses A2A to locate and authenticate a PayPal-provided payment agent via its Agent Card, and initiates a transaction. Google Cloud and PayPal are extending this into the Agent Payments Protocol (AP2), where shopping and merchant agents communicate over A2A throughout product discovery, pricing, and order fulfillment, with AP2 handling the payment authorization layer. Over 60 organizations across payments and financial services already support this initiative.</p>



<h3 class="wp-block-heading">Cloud Platform Native Integration</h3>



<p class="wp-block-paragraph">Every major cloud platform now supports A2A natively:</p>



<ul class="wp-block-list">
<li><strong>Google Cloud:</strong> Supports developing and deploying A2A agents through Agent Development Kit (ADK), Agent Engine, Cloud Run, and GKE. If you&#8217;ve been <a href="https://rpabotsworld.com/building-multi-agent-systems-with-google-adk-the-complete-step-by-step-guide/">building multi-agent systems with Google ADK</a>, A2A support is already built into the framework.</li>



<li><strong>Microsoft Azure:</strong> Azure AI Foundry lets agents expose A2A endpoints and discover external agents through standard discovery. This integrates directly with Copilot Studio&#8217;s multi-agent orchestration capabilities.</li>



<li><strong>AWS:</strong> Amazon Bedrock AgentCore can host and operate A2A servers, enabling cross-framework and cross-cloud agent communication.</li>
</ul>



<h3 class="wp-block-heading">Enterprise IT: Cross-Vendor Agent Collaboration</h3>



<p class="wp-block-paragraph">A Salesforce CRM agent can route a support escalation to a ServiceNow ITSM agent. A Google Workspace agent can delegate document summarization to a specialized LLM agent on Azure. These aren&#8217;t theoretical scenarios — they are the explicit design targets of the protocol and the reason companies like Salesforce, SAP, ServiceNow, and Workday are all supporters.</p>



<h2 class="wp-block-heading">What This Means for Enterprise Agentic Architectures</h2>



<p class="wp-block-paragraph">The consolidation of A2A and MCP under one governance body has several concrete implications for architects designing production agent systems.</p>



<h3 class="wp-block-heading">1. The End of Custom Integration Code Between Agents</h3>



<p class="wp-block-paragraph">Before A2A, connecting agents built on different frameworks required custom integration code for every pairing. A LangGraph agent talking to a Google ADK agent needed bespoke glue. A UiPath process invoking a Bedrock agent needed a custom connector. With A2A, any agent that publishes an Agent Card and implements the task lifecycle can communicate with any other A2A-compatible agent. The cost isn&#8217;t in the agents — it&#8217;s in eliminating the O(n²) integration matrix.</p>



<h3 class="wp-block-heading">2. Protocol Vendor Lock-in Risk Drops Dramatically</h3>



<p class="wp-block-paragraph">When MCP was Anthropic&#8217;s project and A2A was Google&#8217;s project, architects legitimately worried about betting on one vendor&#8217;s protocol. With both under AAIF governance — and with every major cloud provider and AI lab signed on — the risk profile changes fundamentally. These are now industry standards with the same governance model that governs Linux, Kubernetes, and other foundational infrastructure. As our <a href="https://rpabotsworld.com/servicenow-ai-control-tower-enterprise-agent-governance-guide/">guide to enterprise agent governance</a> explores, governance is the hardest problem in agent deployments — and having protocol governance settled at the industry level removes one category of that risk entirely.</p>



<h3 class="wp-block-heading">3. The Agent Card Becomes Your Agent&#8217;s Resume</h3>



<p class="wp-block-paragraph">Agent Cards are not just a technical artifact. They are the mechanism by which your agents advertise their capabilities in a marketplace of agents. Organizations that invest in clear, well-structured Agent Cards — with precise skill descriptions, proper authentication, and cryptographic signatures — will find their agents get discovered and delegated to. Those that don&#8217;t will build agents that sit in isolation.</p>



<h3 class="wp-block-heading">4. Multi-Cloud Agent Architectures Become First-Class</h3>



<p class="wp-block-paragraph">With AWS, Azure, and Google Cloud all supporting A2A natively, you can now design architectures where agents on different clouds collaborate seamlessly. A fraud-detection agent on AWS Bedrock can delegate to a customer-history agent on Azure AI Foundry, which can invoke a risk-scoring agent on Google Cloud&#8217;s Agent Engine — all through standardized A2A communication. This is a concrete answer to the multi-cloud agent challenge that enterprises have been asking about.</p>



<h3 class="wp-block-heading">5. IBM&#8217;s ACP Merger Validates the Convergence</h3>



<p class="wp-block-paragraph">In August 2025, IBM&#8217;s Agent Communication Protocol (ACP) merged into A2A. This was an early signal that the industry was consolidating around A2A rather than sustaining competing protocols. IBM — the company behind <a href="https://rpabotsworld.com/ibm-watsonx-orchestrate-agentic-control-plane-guide/">watsonx Orchestrate&#8217;s agentic control plane</a> — decided to contribute its protocol work into A2A rather than maintain a separate standard. When a company with IBM&#8217;s enterprise footprint makes that call, it tells you where the industry consensus landed.</p>



<h2 class="wp-block-heading">Implications for RPA Teams Moving to Agentic Workflows</h2>



<p class="wp-block-paragraph">If your team currently runs UiPath, Automation Anywhere, Blue Prism, or Power Automate automations, the A2A + MCP stack has direct implications for your transition path to agentic workflows.</p>



<h3 class="wp-block-heading">RPA Processes as A2A-Accessible Agents</h3>



<p class="wp-block-paragraph">The A2A protocol makes it possible to wrap existing RPA processes as agent-accessible services. An RPA bot that processes invoices in SAP can be exposed via an Agent Card, making it discoverable and callable by any A2A-compatible agent. The bot doesn&#8217;t need to be rebuilt — it needs a wrapper that publishes its capabilities and implements the task lifecycle.</p>



<p class="wp-block-paragraph">This is significant because it provides a migration path that doesn&#8217;t require rip-and-replace. Your existing RPA investments become nodes in a broader agentic network. The <a href="https://rpabotsworld.com/uipath-vs-automation-anywhere-vs-blue-prism-agentic-platforms-2026/">latest comparison of UiPath, Automation Anywhere, and Blue Prism&#8217;s agentic capabilities</a> shows that all three vendors are moving toward agent-oriented architectures — A2A gives them a standard protocol to target.</p>



<h3 class="wp-block-heading">MCP for Tool Access, A2A for Process Orchestration</h3>



<p class="wp-block-paragraph">Here&#8217;s a practical architecture pattern for RPA-to-agentic migration:</p>



<ul class="wp-block-list">
<li><strong>MCP servers</strong> wrap your existing integrations: SAP connections, database queries, file system operations, email interactions. Each becomes a standard MCP tool that any agent can discover and invoke.</li>



<li><strong>A2A</strong> handles the orchestration layer: a customer-onboarding agent delegates KYC checks to a compliance agent, which delegates document extraction to an IDP agent, which delegates data entry to an RPA-wrapped SAP agent.</li>
</ul>



<p class="wp-block-paragraph">This pattern preserves your existing automation logic (the RPA bots doing the actual work) while adding an intelligent orchestration layer on top. It is a practical answer to the question every RPA team is asking: &#8220;How do we get to agentic without throwing away what we&#8217;ve built?&#8221;</p>



<h3 class="wp-block-heading">The Governance Question</h3>



<p class="wp-block-paragraph">Enterprise RPA programs already have governance frameworks — change management, access control, audit trails, error handling. The A2A protocol maps cleanly to these requirements. Agent Cards include authentication requirements. The task lifecycle provides auditable state transitions. The <a href="https://rpabotsworld.com/openai-presence-enterprise-ai-agent-platform-guide/">enterprise agent deployment considerations</a> we&#8217;ve covered previously apply directly — A2A doesn&#8217;t replace your governance; it gives it a standard protocol to enforce against.</p>



<h2 class="wp-block-heading">Getting Started: How to Adopt A2A + MCP in Your Stack Today</h2>



<p class="wp-block-paragraph">Here&#8217;s a practical roadmap for teams that want to start building with both protocols.</p>



<h3 class="wp-block-heading">Step 1: Start with MCP (If You Haven&#8217;t Already)</h3>



<p class="wp-block-paragraph">MCP has a larger ecosystem and more immediate utility for most teams. Wrap your most-used internal tools as MCP servers. The Python and TypeScript SDKs are mature, and most agent frameworks (LangGraph, Google ADK, Claude, Bedrock Agents) support MCP natively. Start with your database, your CRM, and your document store.</p>



<h3 class="wp-block-heading">Step 2: Design Your Agent Card</h3>



<p class="wp-block-paragraph">Before you implement A2A, design the Agent Card for your most valuable agent. What skills does it expose? What input/output modes does it support? What authentication is required? This exercise forces you to think about your agent&#8217;s external interface — which is often underdefined in internal agent projects.</p>



<h3 class="wp-block-heading">Step 3: Choose Your A2A SDK</h3>



<p class="wp-block-paragraph">Google provides official SDKs for Python, TypeScript/JavaScript, Java, and Go. The SDKs handle the task lifecycle, streaming, and Agent Card serving. If you&#8217;re on Google ADK, A2A support is built in. If you&#8217;re on LangGraph or another framework, use the standalone SDK.</p>



<pre class="wp-block-code"><code># Python: Minimal A2A server using the official SDK
from a2a.server import A2AServer, AgentCard, Skill

card = AgentCard(
    name="invoice-processor",
    description="Processes and validates supplier invoices",
    url="https://agents.internal.example.com/invoice",
    skills=&#91;
        Skill(
            id="validate-invoice",
            name="Invoice Validation",
            description="Validates invoice against PO and contract terms",
            input_modes=&#91;"application/json"],
            output_modes=&#91;"application/json"]
        )
    ]
)

server = A2AServer(card=card)

@server.on_message
async def handle(message, context):
    # Your agent logic here
    invoice_data = message.content
    result = await validate_against_po(invoice_data)
    return context.complete(result)

server.run(port=8080)</code></pre>



<h3 class="wp-block-heading">Step 4: Test Cross-Framework Communication</h3>



<p class="wp-block-paragraph">The value of A2A appears when agents on different frameworks need to collaborate. Build a simple two-agent system where Agent A (on one framework) delegates a task to Agent B (on another) via A2A. Verify the full lifecycle: discovery via Agent Card, task submission, status updates, and result retrieval. This is your proof of concept for multi-vendor agent architectures.</p>



<h3 class="wp-block-heading">Step 5: Layer in agentgateway for Operations</h3>



<p class="wp-block-paragraph">Once you have agents communicating via A2A, add AAIF&#8217;s agentgateway for routing, policy enforcement, and observability. This is where you apply rate limiting, access control, and audit logging — the operations layer that makes agent communication production-ready.</p>



<h2 class="wp-block-heading">Frequently Asked Questions</h2>



<h3 class="wp-block-heading">Does A2A replace MCP?</h3>



<p class="wp-block-paragraph">No. They solve different problems and are designed to work together. MCP handles agent-to-tool connectivity (your agent querying a database or calling an API). A2A handles agent-to-agent communication (your agent delegating work to another agent). A production system typically uses both — MCP for each agent&#8217;s tool access and A2A for inter-agent orchestration.</p>



<h3 class="wp-block-heading">Do I need to switch agent frameworks to use A2A?</h3>



<p class="wp-block-paragraph">No. A2A is framework-agnostic by design. An agent built on LangGraph can communicate with an agent built on Google ADK, Claude, or a custom framework. You add A2A support to your existing agent — you don&#8217;t rebuild the agent. The official SDKs (Python, TypeScript, Java, Go) handle the protocol layer.</p>



<h3 class="wp-block-heading">Is A2A ready for production use?</h3>



<p class="wp-block-paragraph">Yes. A2A v1.0 shipped in March 2026 with signed Agent Cards, multi-tenancy, and version negotiation. It is running in production at Huawei (mobile OS scale), PayPal (agentic commerce), and across AWS, Azure, and Google Cloud. Over 150 organizations are active supporters.</p>



<h3 class="wp-block-heading">How does A2A handle security and authentication?</h3>



<p class="wp-block-paragraph">Agent Cards include authentication requirements (OAuth 2.0, API keys, or custom schemes). The v1.0 spec added cryptographic signatures for Agent Cards, so clients can verify an agent&#8217;s identity before trusting its card. The task lifecycle is fully auditable, with each state transition logged.</p>



<h3 class="wp-block-heading">Can existing RPA processes be exposed via A2A?</h3>



<p class="wp-block-paragraph">Yes. An RPA process can be wrapped with an A2A server that publishes an Agent Card describing the process&#8217;s capabilities and implements the task lifecycle. The RPA bot continues to execute the actual work — A2A provides the discovery and communication layer that makes it accessible to other agents.</p>



<h2 class="wp-block-heading">Key Takeaways</h2>



<ul class="wp-block-list">
<li><strong>A2A + MCP under one roof is a structural shift.</strong> The two most critical agent protocol layers — tool connectivity (MCP) and inter-agent communication (A2A) — are now governed by the same Linux Foundation body with 250+ members including every major cloud provider and AI lab.</li>



<li><strong>MCP is vertical, A2A is horizontal.</strong> Use MCP to connect agents to tools and data. Use A2A to connect agents to other agents. Both are complementary and both are needed for production multi-agent systems.</li>



<li><strong>A2A is already in production.</strong> Huawei (mobile OS), PayPal (commerce), and all three major cloud platforms run A2A today. This is not vaporware.</li>



<li><strong>RPA teams have a migration path.</strong> Existing RPA processes can be wrapped as A2A-accessible agents without rebuilding them, preserving automation investments while adding intelligent orchestration.</li>



<li><strong>Agent Cards are your agent&#8217;s external interface.</strong> Invest in clear, well-structured Agent Cards with proper authentication and signatures. They determine whether your agents get discovered and trusted in multi-vendor ecosystems.</li>



<li><strong>Start with MCP, add A2A when you need multi-agent.</strong> For most teams, wrapping internal tools as MCP servers delivers immediate value. Layer A2A when you need agents to delegate work across framework or vendor boundaries.</li>
</ul>



<h2 class="wp-block-heading">References</h2>



<ol class="wp-block-list">
<li>Agentic AI Foundation. &#8220;A2A joins AAIF&#8217;s open agentic stack.&#8221; August 17, 2026. <a href="https://aaif.io/blog/a2a-joins-aaif" target="_blank" rel="noopener nofollow">https://aaif.io/blog/a2a-joins-aaif</a></li>



<li>Forbes. &#8220;Agent2Agent Joins The Agentic AI Foundation Alongside MCP.&#8221; August 19, 2026. <a href="https://www.forbes.com/sites/janakirammsv/2026/08/19/agent2agent-joins-the-agentic-ai-foundation-alongside-mcp/" target="_blank" rel="noopener nofollow">https://www.forbes.com/sites/janakirammsv/2026/08/19/</a></li>



<li>Axios. &#8220;AI agents inch toward interoperability.&#8221; August 17, 2026. <a href="https://www.axios.com/2026/08/17/a2a-agentic-ai-foundation-open-ai-standards" target="_blank" rel="noopener nofollow">https://www.axios.com/2026/08/17/</a></li>



<li>Linux Foundation. &#8220;A2A Protocol Surpasses 150 Organizations.&#8221; April 2026. <a href="https://www.linuxfoundation.org/press/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year" target="_blank" rel="noopener nofollow">https://www.linuxfoundation.org/press/</a></li>



<li>Linux Foundation. &#8220;Announces the Formation of the Agentic AI Foundation (AAIF).&#8221; December 2025. <a href="https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation" target="_blank" rel="noopener nofollow">https://www.linuxfoundation.org/press/</a></li>



<li>A2A Protocol. &#8220;v1.0 Specification.&#8221; March 2026. <a href="https://a2a-protocol.org/latest/specification/" target="_blank" rel="noopener nofollow">https://a2a-protocol.org/latest/specification/</a></li>



<li>AI Magazine. &#8220;Why Did Google&#8217;s A2A Join the Agentic AI Foundation?&#8221; August 2026. <a href="https://aimagazine.com/news/why-did-googles-a2a-join-the-agentic-ai-foundation" target="_blank" rel="noopener nofollow">https://aimagazine.com/news/</a></li>



<li>Tyk. &#8220;A2A protocol: Architecture and technical specification.&#8221; 2026. <a href="https://tyk.io/learning-center/a2a-protocol-architecture-and-technical-specification/" target="_blank" rel="noopener nofollow">https://tyk.io/learning-center/</a></li>



<li>Pebblous. &#8220;A2A Joins MCP at the Agentic AI Foundation.&#8221; 2026. <a href="https://blog.pebblous.ai/blog/a2a-mcp-agentic-ai-foundation-authorization/en/" target="_blank" rel="noopener nofollow">https://blog.pebblous.ai/blog/</a></li>



<li>Zylos Research. &#8220;Agent Interoperability Protocols 2026: MCP, A2A, ACP and the Path to Convergence.&#8221; March 2026. <a href="https://zylos.ai/research/2026-03-26-agent-interoperability-protocols-mcp-a2a-acp-convergence/" target="_blank" rel="noopener nofollow">https://zylos.ai/research/</a></li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/a2a-joins-mcp-aaif-agentic-ai-architects-guide/feed/</wfw:commentRss>
			<slash:comments>24</slash:comments>
		
		
			</item>
		<item>
		<title>Salesforce Agentforce 2026: Multi-Agent Orchestration Deep Dive</title>
		<link>https://rpabotsworld.com/salesforce-agentforce-multi-agent-orchestration-2026/</link>
					<comments>https://rpabotsworld.com/salesforce-agentforce-multi-agent-orchestration-2026/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Sun, 09 Aug 2026 07:35:36 +0000</pubDate>
				<category><![CDATA[AI Agents & Frameworks]]></category>
		<category><![CDATA[A2A Protocol]]></category>
		<category><![CDATA[MCP]]></category>
		<category><![CDATA[Salesforce Agentforce]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32239</guid>

					<description><![CDATA[Salesforce Agentforce hits $800M ARR with multi-agent orchestration GA, Atlas 3.0, A2A/MCP support, and U.S. Army IL5 deployment.]]></description>
										<content:encoded><![CDATA[<p>On August 5, 2026, the U.S. Army Human Resources Command became the first Department of War organization to deploy autonomous AI agents at Impact Level 5 — the highest sensitivity tier below classified systems — to serve 9.2 million soldiers, veterans, and military families. The platform running those agents: Salesforce Agentforce. Four days earlier, Agentforce crossed $800 million in annual recurring revenue, up 169% year-over-year, with 29,000 enterprise deals closed in under 18 months.</p>
<p>These aren&#8217;t marketing milestones. They&#8217;re signals that multi-agent orchestration — the ability for specialized AI agents to coordinate autonomously on complex workflows — has moved from research prototype to production infrastructure. And Salesforce&#8217;s Summer &#8217;26 release, which shipped multi-agent orchestration to general availability on June 15, is the architectural inflection point that made both the revenue surge and the military deployment possible.</p>
<p>This guide breaks down what actually shipped, how Atlas Reasoning Engine 3.0 routes work across agent teams, what A2A and MCP mean for your integration architecture, and what practitioners building on any platform — not just Salesforce — should take from this.</p>
<h2>What Shipped in Salesforce&#8217;s Summer 2026 Release</h2>
<p>The Summer &#8217;26 release is Salesforce&#8217;s largest Agentforce update since the product launched in late 2024. The headline capabilities that reached general availability:</p>
<table>
<thead>
<tr>
<th>Capability</th>
<th>Status</th>
<th>What It Does</th>
</tr>
</thead>
<tbody>
<tr>
<td>Multi-Agent Orchestration</td>
<td>GA (June 15, 2026)</td>
<td>One orchestrator agent coordinates specialized subagents across workflows</td>
</tr>
<tr>
<td>Atlas Reasoning Engine 3.0</td>
<td>GA</td>
<td>Dynamic semantic routing replaces hard-coded decision trees</td>
</tr>
<tr>
<td>Agent2Agent (A2A) Protocol</td>
<td>GA</td>
<td>Cross-platform agent-to-agent communication via HTTP/JSON-RPC</td>
</tr>
<tr>
<td>Native MCP Client</td>
<td>GA</td>
<td>Universal tool/data connectivity to any MCP-compliant server</td>
</tr>
<tr>
<td>Agentforce Commerce Agents</td>
<td>GA</td>
<td>Shopper, Buyer, and Merchant agents with transactional capabilities</td>
</tr>
<tr>
<td>Headless 360</td>
<td>GA</td>
<td>60+ MCP tools and 30 coding skills for programmatic Salesforce access</td>
</tr>
<tr>
<td>AgentExchange Marketplace</td>
<td>GA</td>
<td>70+ pre-built agents, unified with AppExchange and Slack Marketplace</td>
</tr>
<tr>
<td>Agent Health Monitoring</td>
<td>GA</td>
<td>Real-time alerts for error rate, latency, and escalation rate</td>
</tr>
</tbody>
</table>
<p>Each of these is worth understanding individually, but the real story is how they compose: Atlas 3.0 provides the reasoning layer, A2A and MCP provide the connectivity layer, and the commerce agents and AgentExchange provide the application layer. Together, they form what Salesforce calls an &#8220;agentic stack&#8221; — though the architectural pattern applies well beyond Salesforce&#8217;s ecosystem.</p>
<h2>How Atlas Reasoning Engine 3.0 Actually Works</h2>
<p>Atlas 3.0 is the coordination brain behind Agentforce&#8217;s multi-agent orchestration. Understanding its architecture matters even if you don&#8217;t use Salesforce, because the pattern it implements — description-driven semantic routing — is becoming the dominant paradigm for multi-agent systems across platforms.</p>
<h3>The Orchestrator Pattern</h3>
<p>The architecture follows a hub-and-spoke model. One <strong>orchestrator agent</strong> serves as the single public-facing interface. Behind it, multiple <strong>specialist subagents</strong> are registered, each with a natural-language description of its capabilities, instructions, and available actions.</p>
<p>When a request arrives, Atlas 3.0 doesn&#8217;t consult a routing table or match against keywords. Instead, it:</p>
<ol>
<li><strong>Evaluates the prompt</strong> — parses the user&#8217;s intent and identifies what data and actions the task requires.</li>
<li><strong>Scans subagent descriptions</strong> — reads the natural-language metadata profiles of every registered specialist agent.</li>
<li><strong>Builds an ad-hoc execution path</strong> — decomposes the request into sub-tasks and routes each to the best-matched specialist.</li>
<li><strong>Executes and reassembles</strong> — collects results from each specialist and composes a unified response.</li>
</ol>
<p>This is a complete departure from traditional decision-tree routing. There are no hard-coded if/then branches. The orchestrator&#8217;s routing decisions are fully dynamic, driven by semantic understanding of both the request and each agent&#8217;s declared capabilities.</p>
<h3>The ReAct Loop</h3>
<p>Under the hood, Atlas 3.0 uses a <strong>ReAct (Reason-Act-Observe)</strong> mechanism. The system loops through three phases until the user&#8217;s goal is fulfilled:</p>
<ol>
<li><strong>Reason</strong> — analyze the current state: what&#8217;s been accomplished, what&#8217;s missing, what to do next.</li>
<li><strong>Act</strong> — call a tool, invoke a subagent, or request information from the user.</li>
<li><strong>Observe</strong> — evaluate the result. If the goal isn&#8217;t met, loop back to Reason with the new information.</li>
</ol>
<p>This looping architecture means the orchestrator can handle multi-step workflows that unfold dynamically — asking clarifying questions, branching based on intermediate results, and recovering from partial failures — rather than following a predetermined script.</p>
<h3>Event-Driven Graph Architecture</h3>
<p>At the infrastructure level, Atlas 3.0 implements an <strong>event-driven directed graph</strong> of function nodes — retrieval, planning, action execution — that run concurrently using a publish-subscribe asynchronous pattern. Each node operates independently, enabling horizontal scaling as new tools or models are added. This graph-based design is what transforms a collection of individual models into what Salesforce&#8217;s engineering team calls a &#8220;compound AI system&#8221; — multiple reasoning components working as one coherent unit.</p>
<p>For practitioners familiar with <a href="https://rpabotsworld.com/langgraph-vs-crewai-vs-microsoft-agent-framework-vs-google-adk/">LangGraph&#8217;s graph-based agent orchestration</a>, the architectural parallels are striking. Both use directed graphs for execution flow, both support concurrent node execution, and both treat tool calls as first-class graph nodes. The key difference is that Atlas 3.0 is a managed, closed-source runtime optimized for Salesforce&#8217;s data model, while LangGraph provides a lower-level, open-source framework you wire together yourself.</p>
<h3>Why Description Quality Is the Make-or-Break Factor</h3>
<p>Here&#8217;s the critical operational insight from early Atlas 3.0 deployments: because routing is entirely description-driven, <strong>the quality of your agent descriptions directly determines routing accuracy</strong>. A vague description like &#8220;handles customer issues&#8221; will cause the orchestrator to misroute requests. A precise description like &#8220;resolves billing disputes for enterprise accounts by querying the ERP system, validating invoice line items, and issuing credit memos up to $5,000&#8221; gives Atlas 3.0 the semantic surface area it needs to route correctly.</p>
<p>This has practical implications for <a href="https://rpabotsworld.com/ai-agent-control-planes-enterprise-governance-guide/">enterprise agent governance</a>. Teams deploying multi-agent orchestration need description standards — a shared template, a review process, and metrics that track routing accuracy per agent. Salesforce&#8217;s own documentation now recommends treating agent descriptions as &#8220;production artifacts that require the same rigor as API contracts.&#8221;</p>
<h2>A2A + MCP: The Interoperability Architecture</h2>
<p>Summer &#8217;26 ships two complementary protocols that solve different connectivity problems. Understanding which does what — and where they overlap — is essential for architects designing multi-vendor agent ecosystems.</p>
<h3>MCP: Tool and Data Connectivity</h3>
<p>The <strong>Model Context Protocol (MCP)</strong> is an open-standard JSON-RPC protocol that defines how a large language model connects to external tools or data sources. In Agentforce, the native MCP client replaces the need for custom point-to-point Apex REST adapters. An Agentforce agent can discover, query, and interact with any MCP-compliant server through a secure, schema-aware integration layer — regardless of vendor.</p>
<p>With Headless 360, Salesforce now exposes 60+ MCP tools and 30 preconfigured coding skills, effectively turning the entire Salesforce platform into an MCP server that external agents can call into. This is a significant architectural shift: Salesforce is no longer just an application you interact with through a UI. It&#8217;s now a programmatic tool surface that any MCP-compliant agent — built on LangChain, CrewAI, OpenAI Agents SDK, or any other framework — can invoke.</p>
<h3>A2A: Agent-to-Agent Communication</h3>
<p>The <strong>Agent2Agent (A2A) protocol</strong>, originally proposed by Google, governs how autonomous agents communicate with one another. While MCP connects an agent to tools and data, A2A connects an agent to other agents. The protocol uses HTTP for transport, JSON-RPC for structured messaging, and event-based updates for asynchronous communication.</p>
<p>In practice, A2A means an Agentforce orchestrator can coordinate workflows with non-Salesforce specialist agents running on AWS Bedrock, Google Vertex AI, Azure AI Foundry, or any A2A-compliant platform. The orchestrator doesn&#8217;t need to know what platform a specialist runs on — it communicates through the standardized A2A protocol, the same way a web browser doesn&#8217;t need to know what server technology a website uses.</p>
<h3>How They Work Together</h3>
<p>The cleanest mental model:</p>
<table>
<thead>
<tr>
<th>Protocol</th>
<th>Connects</th>
<th>Analogy</th>
<th>Example</th>
</tr>
</thead>
<tbody>
<tr>
<td>MCP</td>
<td>Agent → Tools/Data</td>
<td>USB port</td>
<td>Agent queries a database, calls an API, reads a document</td>
</tr>
<tr>
<td>A2A</td>
<td>Agent → Agent</td>
<td>Email between colleagues</td>
<td>Sales agent asks compliance agent to review a contract</td>
</tr>
</tbody>
</table>
<p>In a multi-vendor enterprise, a single workflow might use both: the Agentforce orchestrator uses A2A to delegate a sub-task to a Google Vertex AI agent, which in turn uses MCP to call a proprietary analytics tool, then returns its result via A2A back to the orchestrator. This layered interoperability is what makes the &#8220;best-of-breed agent ecosystem&#8221; architecturally viable rather than just a talking point.</p>
<p>For a deeper look at how these <a href="https://rpabotsworld.com/prompts-vs-context-vs-loops-ai-engineering-guide/">protocol layers fit into the broader AI engineering stack</a>, see our recent map of the prompts-context-loops architecture.</p>
<h2>The U.S. Army HRC Deployment: Agentforce at Impact Level 5</h2>
<p>On August 5, 2026, the U.S. Army Human Resources Command (HRC) became the first Department of War organization to deploy Agentforce at Impact Level 5 — a security classification that covers controlled unclassified information at the highest sensitivity tier below classified systems.</p>
<h3>The Scale</h3>
<p>HRC&#8217;s workload is staggering by any enterprise standard:</p>
<ul>
<li><strong>9.2 million</strong> personnel served — active-duty soldiers, veterans, civilian staff, and military families</li>
<li><strong>600,000</strong> HR cases processed per year</li>
<li><strong>1,500+</strong> cases resolved per day</li>
<li>Workload spans career assignments, promotions, benefits administration, and personnel records</li>
</ul>
<h3>What the Agents Do</h3>
<p>The AI agents are deployed as part of HRC&#8217;s <strong>Digital Front Door</strong> — a cloud-based platform powered by Missionforce National Security that serves as the Army&#8217;s core HR engine. The agents provide:</p>
<ul>
<li>24/7 automated response to routine HR inquiries</li>
<li>Case history summarization for caseworkers</li>
<li>Policy and career information surfacing from approved Army sources</li>
<li>Automated triage and routing of the 1,500+ daily cases</li>
</ul>
<p>The agents don&#8217;t replace human caseworkers. They handle the routine inquiry volume — the &#8220;what&#8217;s my leave balance&#8221; and &#8220;when does my PCS order expire&#8221; questions — so that human specialists can focus on complex cases that require judgment, empathy, and institutional knowledge.</p>
<h3>Why IL5 Matters for the Industry</h3>
<p>Impact Level 5 authorization isn&#8217;t just a government compliance checkbox. It&#8217;s a signal that the security, auditability, and reliability requirements for autonomous AI agents have been met at a level that the most security-conscious organizations in the world consider acceptable. For enterprise architects in regulated industries — healthcare, financial services, energy, defense contracting — the Army&#8217;s IL5 deployment answers the question &#8220;can we trust AI agents with sensitive operational data?&#8221; with a concrete precedent rather than a vendor promise.</p>
<p>Missionforce National Security, the platform layer between Salesforce and the Army, adds additional capabilities for the defense and intelligence communities: a secure low-to-high deployment model for classified intelligence networks, decision-intelligence tooling for real-time command insights, and compliance controls aligned with DoD cybersecurity frameworks. Salesforce describes the full portfolio embedded in Missionforce as &#8220;Agentforce 360&#8221; — agents, data capabilities, and apps running as one integrated stack.</p>
<h2>The $800M ARR Milestone: What the Numbers Tell Practitioners</h2>
<p>Salesforce reported Agentforce at $800 million in annual recurring revenue in its Q4 FY2026 earnings (February 2026), representing 169% year-over-year growth. The broader context:</p>
<table>
<thead>
<tr>
<th>Metric</th>
<th>Value</th>
<th>What It Signals</th>
</tr>
</thead>
<tbody>
<tr>
<td>Agentforce ARR</td>
<td>$800M</td>
<td>Fastest enterprise SaaS ramp in recent memory — 18 months from launch</td>
</tr>
<tr>
<td>YoY Growth</td>
<td>169%</td>
<td>Accelerating, not decelerating — product-market fit is strengthening</td>
</tr>
<tr>
<td>Total Deals</td>
<td>29,000+</td>
<td>Well beyond Fortune 500 early adopters — mid-market penetration confirmed</td>
</tr>
<tr>
<td>Cross-Sell Rate</td>
<td>60%+ from existing customers</td>
<td>Agentforce is expanding within the installed base, not just acquiring net-new</td>
</tr>
<tr>
<td>Work Units Logged</td>
<td>2.4 billion</td>
<td>Agents are doing real work at scale, not sitting idle after deployment</td>
</tr>
<tr>
<td>Agentforce + Data 360 Combined</td>
<td>$2.9B ARR</td>
<td>200% YoY — the data platform is growing alongside the agent platform</td>
</tr>
</tbody>
</table>
<p>For practitioners, the 2.4 billion work units metric is the most telling. Revenue can be inflated by long-term contracts and enterprise discounts. Work units — actual agent executions — measure production usage. At 2.4 billion, Agentforce agents are processing roughly 6.5 million work units per day across the customer base. That&#8217;s not a pilot. That&#8217;s infrastructure.</p>
<p>The 60% cross-sell rate also reveals the adoption pattern: most Agentforce deployments start within organizations that already run Salesforce CRM. The agents extend existing workflows rather than requiring greenfield implementation. This is the same land-and-expand pattern that drove Salesforce&#8217;s original CRM growth — and it suggests that the competitive moat isn&#8217;t the AI technology itself (which competitors can replicate) but the integration depth with existing Salesforce data and processes (which they can&#8217;t easily match).</p>
<h2>Agentforce Commerce: When Agents Close Sales</h2>
<p>The Summer &#8217;26 release also brought Agentforce Commerce to general availability — and this is where the &#8220;agentic&#8221; label stops being abstract and starts carrying direct revenue implications.</p>
<h3>Three Commerce Agents</h3>
<p>The <strong>Shopper Agent</strong> is the headline capability, and Salesforce claims it&#8217;s the first genuinely transactional AI shopping assistant — meaning it doesn&#8217;t just recommend products but actually completes purchases within a single conversation. The agent checks live inventory, confirms carrier cutoffs, offers store pickup options, and closes the sale. Notably, Salesforce announced native integration with ChatGPT, Google Search (including AI Mode), and the Gemini app, which means the Shopper Agent can surface in the conversational interfaces where consumers are already spending time.</p>
<p>The <strong>Buyer Agent</strong> handles B2B procurement workflows — requisition creation, approval routing, contract-price validation — while the <strong>Merchant Agent</strong> automates merchandising tasks like catalog management, pricing optimization, and promotion scheduling.</p>
<h3>Storefront Next and the Developer Stack</h3>
<p>Alongside the agents, Salesforce shipped <strong>Storefront Next</strong> (GA), a composable storefront framework that promises production-ready commerce sites in under 30 minutes. More interesting for the developer audience is the <strong>Agentic B2C Developer Toolkit</strong>: a unified CLI, MCP server, IDE extension, and advanced agent skills that let developers use AI coding agents to spin up sandboxes, deploy cartridges, and manage jobs via conversational prompts.</p>
<p>The toolkit also includes <strong>Agentic Commerce Search</strong>, built on technology Salesforce acquired from Cimulate, which replaces traditional keyword-based product search with intent-aware, agent-driven search that understands natural-language queries like &#8220;something waterproof for a week-long hiking trip under $200.&#8221;</p>
<h2>What This Means for RPA and Automation Practitioners</h2>
<p>If you&#8217;re building on UiPath, Automation Anywhere, Power Automate, or any RPA platform, Salesforce&#8217;s multi-agent orchestration push isn&#8217;t a competitive threat — it&#8217;s a design pattern you need to understand because it&#8217;s coming to your platform too.</p>
<h3>The Convergence Pattern</h3>
<p>The architectural trajectory is clear across every major automation vendor in 2026:</p>
<ol>
<li><strong>RPA bots become agent tools.</strong> Your existing attended and unattended automations are increasingly invoked as &#8220;actions&#8221; or &#8220;skills&#8221; within agentic workflows — not replaced, but wrapped in an agent orchestration layer that decides when to call them.</li>
<li><strong>Orchestration moves from process-centric to goal-centric.</strong> Traditional RPA orchestrators execute predefined process flows. Agent orchestrators like Atlas 3.0 receive a goal (&#8220;resolve this billing dispute&#8221;) and dynamically compose the execution path. The practitioner&#8217;s job shifts from designing flowcharts to designing agent descriptions and tool registrations.</li>
<li><strong>Interoperability becomes non-negotiable.</strong> MCP and A2A aren&#8217;t Salesforce-only protocols. They&#8217;re open standards that UiPath, Google, Microsoft, and dozens of open-source projects already support. If you&#8217;re building automation solutions, your integration architecture needs to account for agent-to-agent communication, not just API-to-API.</li>
</ol>
<p>UiPath&#8217;s own trajectory — with coded agents, Agent Builder, and the <a href="https://rpabotsworld.com/top-trending-open-source-agentic-ai-repos/">growing ecosystem of open-source agent frameworks</a> — follows this same convergence pattern. The platform-specific syntax differs, but the architectural principles are shared: semantic routing, ReAct loops, tool registration, and multi-agent coordination.</p>
<h3>Skills to Develop</h3>
<p>Based on what the Agentforce deployment patterns reveal, RPA practitioners should prioritize:</p>
<ul>
<li><strong>Agent description writing</strong> — treat it as a technical skill, not a copywriting task. Your agent&#8217;s description is its routing contract.</li>
<li><strong>MCP server development</strong> — wrapping existing automations, APIs, and data sources as MCP tools makes them accessible to any agent on any platform.</li>
<li><strong>Multi-agent testing</strong> — orchestration introduces emergent behavior. A subagent that works perfectly in isolation can fail when another subagent&#8217;s output becomes its input. End-to-end orchestration testing is a new discipline.</li>
<li><strong>Agent observability</strong> — Salesforce&#8217;s Agent Health Monitoring (error rate, latency, escalation rate) is the minimum. Production agent systems need distributed tracing across the full orchestration graph.</li>
</ul>
<h2>Getting Started: Your First Multi-Agent Orchestration</h2>
<p>Whether you&#8217;re on Salesforce or studying the pattern for another platform, here&#8217;s the practical sequence for building a multi-agent orchestration from scratch.</p>
<h3>Step 1: Identify Your Specialist Agents</h3>
<p>Don&#8217;t start with the orchestrator. Start by listing the distinct capabilities your workflow needs. For a customer service use case, that might be: billing inquiry resolution, order status lookup, returns processing, and escalation to human agents. Each becomes a specialist.</p>
<h3>Step 2: Write Production-Quality Descriptions</h3>
<p>For each specialist, write a description that answers: What does this agent do? What data does it access? What actions can it take? What are its limits? Use the template:</p>
<pre><code>[Agent Name] handles [specific task type] for [specific user/customer segment]
by [actions it takes], using [data sources it accesses].
It can [explicit capabilities] but cannot [explicit limitations].
Escalate to [fallback agent/human] when [specific conditions].</code></pre>
<h3>Step 3: Register Tools via MCP</h3>
<p>Each specialist needs tools — database queries, API calls, document retrievals. Register these as MCP-compliant tool servers. Salesforce&#8217;s native MCP client handles discovery automatically; on other platforms, you&#8217;ll configure tool registrations in your agent framework&#8217;s tool registry.</p>
<h3>Step 4: Configure the Orchestrator</h3>
<p>The orchestrator&#8217;s job is coordination, not execution. Its configuration is minimal: a list of registered specialists, a system prompt defining its coordination behavior, and escalation rules for when no specialist matches or when confidence is low.</p>
<h3>Step 5: Test with Adversarial Routing Scenarios</h3>
<p>The most common failure mode in multi-agent orchestration isn&#8217;t a subagent failing — it&#8217;s the orchestrator routing to the wrong subagent. Test with ambiguous requests that could plausibly match multiple specialists, requests that require sequential handoffs between specialists, and requests that fall outside all specialists&#8217; capabilities.</p>
<h3>Step 6: Monitor and Iterate</h3>
<p>Deploy with Agent Health Monitoring (or your platform&#8217;s equivalent) tracking three metrics from day one: routing accuracy (did the right specialist get the task?), end-to-end resolution rate (did the workflow complete without human escalation?), and latency (how long did the full orchestration take?).</p>
<h2>Frequently Asked Questions</h2>
<h3>What is Salesforce Agentforce multi-agent orchestration?</h3>
<p>Multi-agent orchestration in Agentforce lets a single orchestrator agent coordinate multiple specialist subagents to handle complex, multi-step workflows. The orchestrator uses Atlas Reasoning Engine 3.0 to dynamically route tasks to the best-matched specialist based on natural-language descriptions, rather than hard-coded rules. It reached general availability on June 15, 2026, as part of the Summer &#8217;26 release.</p>
<h3>How does Atlas Reasoning Engine 3.0 differ from previous versions?</h3>
<p>Atlas 3.0 replaces traditional decision-tree routing with dynamic semantic interpretation. It reads each subagent&#8217;s natural-language description to make routing decisions, implements a ReAct (Reason-Act-Observe) loop for multi-step workflows, and uses an event-driven directed graph architecture that supports concurrent execution. The key practical difference: routing accuracy now depends on description quality rather than rule configuration.</p>
<h3>What is the difference between MCP and A2A in Agentforce?</h3>
<p>MCP (Model Context Protocol) connects an agent to external tools and data sources — think databases, APIs, document stores. A2A (Agent2Agent protocol) connects an agent to other agents across different platforms. MCP is like a USB port (plug in any tool); A2A is like email between colleagues (agents on different platforms exchange tasks and results). Both shipped to GA in Summer &#8217;26 and work together in multi-vendor workflows.</p>
<h3>Can non-Salesforce agents work with Agentforce orchestration?</h3>
<p>Yes. Through the A2A protocol, Agentforce orchestrators can delegate tasks to agents built on any A2A-compliant platform — including AWS Bedrock, Google Vertex AI, Azure AI Foundry, and open-source frameworks. Through MCP, external agents can also call into Salesforce as a tool surface using the 60+ MCP tools exposed via Headless 360.</p>
<h3>What does the U.S. Army IL5 deployment mean for enterprise adoption?</h3>
<p>Impact Level 5 is the highest sensitivity tier below classified systems. The Army HRC&#8217;s deployment of Agentforce at IL5 for 9.2 million personnel establishes a concrete precedent that autonomous AI agents can meet the security, auditability, and reliability requirements of the most security-conscious organizations. For regulated industries (healthcare, finance, energy), this deployment answers the &#8220;can we trust AI agents with sensitive data?&#8221; question with a verifiable reference rather than a vendor claim.</p>
<h2>Key Takeaways</h2>
<ul>
<li><strong>Multi-agent orchestration is now production-ready.</strong> Salesforce&#8217;s Summer &#8217;26 release brought multi-agent orchestration, Atlas 3.0, A2A, and MCP to general availability — not beta, not preview, GA.</li>
<li><strong>Description quality is the new routing logic.</strong> Atlas 3.0&#8217;s semantic routing means your agent descriptions are production artifacts. Treat them with the same rigor as API contracts.</li>
<li><strong>A2A + MCP enable multi-vendor agent ecosystems.</strong> Agents built on different platforms can now communicate (A2A) and share tools (MCP) through open standards. Single-vendor lock-in for agent orchestration is architecturally unnecessary.</li>
<li><strong>The U.S. Army&#8217;s IL5 deployment sets the regulatory precedent.</strong> If autonomous agents are trusted with 9.2 million military personnel records at IL5, the &#8220;too risky for production&#8221; argument loses force in most commercial contexts.</li>
<li><strong>$800M ARR in 18 months confirms product-market fit.</strong> With 29,000 deals and 2.4 billion work units logged, Agentforce is infrastructure, not experiment.</li>
<li><strong>RPA practitioners: learn the pattern, not just the platform.</strong> Semantic routing, ReAct loops, tool registration via MCP, and agent-to-agent communication via A2A are cross-platform architectural patterns. They&#8217;re coming to UiPath, Automation Anywhere, and every major automation platform.</li>
</ul>
<h2>References</h2>
<ol>
<li>Salesforce Press Release. &#8220;<a href="https://www.salesforce.com/news/press-releases/2026/08/05/us-army-hrc-agentforce-ai-powered-support/" target="_blank" rel="noopener nofollow">U.S. Army Human Resources Command Deploys Agentforce to Deliver 24/7 AI-Powered Support to 9.2 Million Soldiers, Veterans, and Military Families</a>.&#8221; August 5, 2026.</li>
<li>Salesforce Press Release. &#8220;<a href="https://www.salesforce.com/news/press-releases/2026/08/05/dow-agentforce-mission-readiness/" target="_blank" rel="noopener nofollow">Missionforce National Security Unveils IL5-Authorized AI Agents and Apps to Drive Decision Advantage, Readiness, and Enhanced Warfighter Support</a>.&#8221; August 5, 2026.</li>
<li>Salesforce. &#8220;<a href="https://www.salesforce.com/news/stories/summer-2026-product-release-announcement/" target="_blank" rel="noopener nofollow">Salesforce Summer 2026 Product Release Announcement</a>.&#8221; 2026.</li>
<li>Futurum Group. &#8220;<a href="https://futurumgroup.com/insights/salesforces-agentforce-deployment-a-major-shift-for-military-hr-operations/" target="_blank" rel="noopener nofollow">Agentic Enterprise: Salesforce Army HRC Win</a>.&#8221; 2026.</li>
<li>Enterprise DNA. &#8220;<a href="https://enterprisedna.co/resources/news/salesforce-summer-26-agentforce-800m-arr-multi-agent-2026/" target="_blank" rel="noopener nofollow">Agentforce Reaches $800M ARR as Multi-Agent Era Begins</a>.&#8221; 2026.</li>
<li>TechTimes. &#8220;<a href="https://www.techtimes.com/articles/318456/20260616/salesforce-agentforce-multi-agent-orchestration-hits-ga-agent-descriptions-now-drive-reliability.htm" target="_blank" rel="noopener nofollow">Salesforce Agentforce Multi-Agent Orchestration Hits GA: Agent Descriptions Now Drive Reliability</a>.&#8221; June 16, 2026.</li>
<li>ChatForest. &#8220;<a href="https://chatforest.com/builders-log/salesforce-summer-26-agentforce-multi-agent-orchestration-atlas-a2a-mcp-builder-guide/" target="_blank" rel="noopener nofollow">Salesforce Summer &#8217;26 Agentforce Multi-Agent Orchestration: Atlas 3.0, A2A, MCP, and the Seam Problem</a>.&#8221; 2026.</li>
<li>Salesforce Engineering. &#8220;<a href="https://engineering.salesforce.com/inside-the-brain-of-agentforce-revealing-the-atlas-reasoning-engine/" target="_blank" rel="noopener nofollow">Inside Agentforce: Revealing the Atlas Reasoning Engine</a>.&#8221; 2026.</li>
<li>Salesforce. &#8220;<a href="https://www.salesforce.com/agentforce/ai-agents/agent2agent-protocol/" target="_blank" rel="noopener nofollow">Agent2Agent Protocol: The Standard for AI Agent Interoperability</a>.&#8221; 2026.</li>
<li>Salesforce. &#8220;<a href="https://www.salesforce.com/blog/how-to-choose-integration-pattern-for-agentforce/" target="_blank" rel="noopener nofollow">Choose the Right Agentforce Integration Pattern: API, MCP, or A2A</a>.&#8221; 2026.</li>
<li>Salesforce. &#8220;<a href="https://www.salesforce.com/news/stories/agentforce-commerce-announcement/" target="_blank" rel="noopener nofollow">As AI Agents Transform Commerce, Salesforce Unleashes Its Biggest Agentforce Commerce Release Yet</a>.&#8221; July 6, 2026.</li>
<li>Salesforce. &#8220;<a href="https://www.salesforce.com/news/press-releases/2026/02/25/fy26-q4-earnings/" target="_blank" rel="noopener nofollow">Salesforce Delivers Record Fourth Quarter Fiscal 2026 Results</a>.&#8221; February 25, 2026.</li>
<li>Grazitti Interactive. &#8220;<a href="https://www.grazitti.com/blog/agentforce-multi-agent-orchestration-and-mcp-the-complete-architecture-guide/" target="_blank" rel="noopener nofollow">MCP and Agentforce Multi-Agent Orchestration in Salesforce</a>.&#8221; 2026.</li>
</ol>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/salesforce-agentforce-multi-agent-orchestration-2026/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
			</item>
	</channel>
</rss>

<!--
Performance optimized by W3 Total Cache. Learn more: https://www.boldgrid.com/w3-total-cache/?utm_source=w3tc&utm_medium=footer_comment&utm_campaign=free_plugin

Page Caching using Disk: Enhanced 

Served from: rpabotsworld.com @ 2026-11-20 11:29:08 by W3 Total Cache
-->