Google ADK + Ertas

Build production agents with Google's Agent Development Kit — multi-language (Python/Java/Go) framework with first-class GCP integrations and full support for Ertas-trained local models.

Overview

Google ADK (Agent Development Kit) is Google's open-source agent framework, released in 2025 and maintained as the canonical agent stack for the Google Cloud and Vertex AI ecosystem. It is unusual among agent frameworks for offering multi-language runtime support: Python, Java, and Go all expose the same agent abstractions, which makes ADK a natural fit for enterprises that have heterogeneous backend stacks. By May 2026 the framework had crossed 17,000 GitHub stars and was being actively used in Google's own products and in customer deployments running on Vertex AI Agent Builder.

The framework's design centers on three abstractions: agents (LLM-powered actors), tools (typed functions or services agents can call), and workflows (structured patterns like sequential, parallel, and loop). Built-in connectors cover Google Workspace, Vertex AI Search, BigQuery, and the Google Cloud connector ecosystem. ADK is also tightly integrated with Vertex AI Agent Builder, Google Cloud's hosted agent platform, but the open-source SDK is fully usable standalone for self-hosted deployments.

ADK supports any OpenAI-compatible LLM endpoint as a model provider. While the framework's first-class story is Gemini and Vertex AI Model Garden, teams that want ADK's developer experience and Google connector ecosystem with self-hosted models can configure the LiteLLM provider to call any endpoint — including Ertas-trained models served via Ollama, vLLM, or Ertas Cloud.

How Ertas Integrates

Ertas-trained models work with Google ADK through its LiteLLM-based model abstraction. After fine-tuning in Studio and exporting to GGUF, you serve the model via Ollama, vLLM, or Ertas Cloud, then configure ADK's `LlmAgent` with the LiteLLM provider pointed at your endpoint. The agent abstractions, the workflow patterns, and the Google connector ecosystem all work transparently against your fine-tuned model.

The combination is particularly relevant for organizations with Google Cloud commitments that don't want their per-token Vertex AI bill to scale with users. ADK + Ertas-trained model + on-premise inference produces an agent stack that fits into existing GCP architectures (BigQuery, Vertex AI Search, Workspace connectors) while controlling inference costs. For high-volume agentic workloads — internal customer support, document processing, data analysis — this can flip per-task economics dramatically.

For multi-language deployments, ADK's Python/Java/Go parity is unusually valuable. Teams can fine-tune in Studio (which is language-agnostic), serve via a single inference endpoint, and then deploy ADK agents in whichever runtime fits their existing services. A Java backend can use the same fine-tuned model as a Python data-science workflow as a Go infrastructure tool.

Getting Started

1
Fine-tune your domain model in Ertas Studio
Train on data that captures your domain, tool schemas, and reasoning patterns. Studio works with any base model architecture compatible with the OpenAI-compatible serving APIs ADK calls.
2
Deploy to an OpenAI-compatible endpoint
Export to GGUF and serve via Ollama, vLLM, or Ertas Cloud. ADK calls the endpoint via LiteLLM's OpenAI-compatible adapter.
3
Install Google ADK and configure the model
Install google-adk in your language of choice. Create an `LlmAgent` configured with the LiteLLM provider and your endpoint URL.
4
Define tools and workflows
Add tools as typed functions or service connectors. Compose into ADK workflows (sequential, parallel, loop) or run a single LlmAgent. GCP connectors (BigQuery, Vertex Search, Workspace) work transparently.
5
Run self-hosted or deploy to Agent Builder
Run agents in your own infrastructure or deploy to Vertex AI Agent Builder. Both paths work with self-hosted inference; the model provider stays pointed at your endpoint.

python

from google.adk.agents import LlmAgent
from google.adk.models.lite_llm import LiteLlm
from google.adk.tools import FunctionTool

# Point ADK at your Ertas-trained model served via Ollama
model = LiteLlm(
    model="openai/ertas-data-analyst-14b",
    base_url="http://localhost:11434/v1",
    api_key="not-needed",
)

def query_bigquery(sql: str) -> dict:
    """Run a SQL query against the analytics dataset."""
    return bq_client.query(sql).to_dict()

def write_summary(text: str, recipient: str) -> str:
    """Send a summary email through Workspace."""
    return workspace_client.send_email(recipient, text)

agent = LlmAgent(
    name="Data Analyst",
    model=model,
    instructions="You answer business questions by querying BigQuery and summarizing findings.",
    tools=[
        FunctionTool(query_bigquery),
        FunctionTool(write_summary),
    ],
)

response = agent.run("What were Q4 conversion rates by acquisition channel? Email the summary to ops@company.com.")

Build a data-analyst agent with Google ADK backed by an Ertas-trained 14B model, with BigQuery and Workspace connectors handled by ADK's first-party tooling.

Benefits

Multi-language runtime: Python, Java, Go share unified agent abstractions
First-class Google Cloud integrations: BigQuery, Vertex Search, Workspace connectors
Open-source SDK with optional managed platform (Vertex AI Agent Builder)
Workflow patterns: sequential, parallel, loop multi-agent orchestration
Works with any OpenAI-compatible model — Gemini, OpenAI, Ertas-trained local models
Strong fit for enterprises with Google Cloud commitments and heterogeneous backend stacks