Google ADK

adk web starts a local dev UI over your agent folder, with chat plus Events, Trace and Eval tabs. adk run drives the same agent from the terminal. adk api_server serves it as a local HTTP API.

Nothing survives with InMemorySessionService — sessions, event history and state live in the process and vanish on restart. DatabaseSessionService writes them to a SQL database given by db_url, so the same session_id resumes afterwards.

Google ADK wraps any callable placed in an agent's tools list into a FunctionTool. The function name, its type-hinted parameters and its docstring become the declaration the model sees, so the docstring is functional code rather than a comment.

Use LlmAgent when the model must decide what happens next. Use ADK's SequentialAgent, ParallelAgent or LoopAgent when the order is already known: they run their sub_agents on fixed control flow and call no LLM of their own.

Through session state, not through a return value. Set output_key on the producing LlmAgent and ADK stores its final response under that key; the next agent reads it with a {key} placeholder in its instruction, or a tool reads it from state.

Returning a non-None value short-circuits the step. A before_model_callback that returns an LlmResponse skips the model call and uses that response; a before_tool_callback that returns a dict skips the tool and uses that dict as its result. Returning None lets the step proceed.

tool_trajectory_avg_score compares the tool calls the agent actually made — names and arguments, in order — against the ones recorded in the eval case, averaged over invocations. response_match_score compares the final response text to the expected text using ROUGE-1 similarity.

They set scope. An unprefixed key belongs to one session; app: is shared by every user of that app_name; user: follows one user_id across all their sessions; temp: exists only for the current invocation and is never persisted.

Runner.run_async is an async generator of Event objects — one per model chunk, tool call, tool response and agent message. Check event.is_final_response() to find the turn's answer; event.partial marks streaming fragments you should not treat as final.

Declare a parameter annotated with ADK's ToolContext type and the framework injects it, hiding it from the model's schema. Through it a tool reads and writes session state, sets actions such as skipping summarization or transferring control, and reaches artifacts, memory and auth.

A test file captures one simple session and is meant to run cheaply and often, like a unit test. An eval set file holds many named eval cases, each a full multi-turn session with its own starting state, and is the integration-tier artifact you record from the dev UI.

AgentTool exposes another agent as a callable function. When the model calls it, ADK runs that agent to completion as a nested invocation and returns its final response as the function result, so control comes straight back to the caller instead of being handed over.

Not in your process. google_search is a declaration ADK passes to a Gemini model, which performs the grounded search on Google's side and returns results with grounding metadata. ADK never runs a Python function for it, which is why it is restricted to Gemini models.

Two ways only: it reaches max_iterations, or a sub-agent escalates — by setting escalate on the tool context's actions, or emitting an event with escalate set. With neither configured, the loop keeps re-running its sub_agents indefinitely.

ParallelAgent gives each sub-agent its own branch of the conversation history, so branches do not see each other's messages. They still run against one shared session state, so two branches writing the same key race and the loser's work vanishes silently.

Conversations vanish and tool calls start getting denied. In-memory session, artifact and memory services are per-process, and Cloud Run runs many replaceable instances; local user credentials are replaced by the service account, and the dev UI and tracing are opt-in flags at deploy time.

The Session you hold is a snapshot; the session service only writes state when an Event is appended. Changes must travel as EventActions.state_delta on that event, so an in-place edit to the returned dict is lost on the next load.

Session history is this thread's events, reloaded in full every turn. A MemoryService is a separate searchable store of past sessions: you ingest finished ones with add_session_to_memory, and the agent queries them on demand through the load_memory tool.

The wrapped function returns an interim result immediately, such as a pending status with a ticket id, and ADK marks that call as long-running on the event it emits. The turn ends without blocking; the real outcome is delivered later as a function response carrying the same call id.

Decide per node whether the next step is a judgment or a known fact. Known steps become workflow agents; genuine judgment becomes a small set of sub_agents with sharply distinct descriptions. Every extra transfer hop is another model call, another failure point, and another thing to evaluate.

Choose Agent Engine when you want the platform to own sessions, memory and tracing and you accept Vertex coupling. Choose Cloud Run when you need control of the container, dependencies and networking, or the agent must live inside an existing service. Both are one adk deploy command.

Every in-memory service must go: they are per-process, so a request landing on another replica sees no session. Pick a shared backend for each — a database or Vertex session service, a durable memory service, and GcsArtifactService for blobs — and decide retention per store.

OpenAPIToolset generates one callable REST tool per operation in the spec, so a large API becomes hundreds of tools. Curate deliberately: filter the toolset down to the operations an agent actually needs, and split the rest across separate agents rather than loading one agent with everything.